ChatAny: a self-hosted ChatGPT-Next-Web fork that adds Midjourney and StabilityAI

What ChatAny adds on top of ChatGPT-Next-Web

ChatAny is a web front end for several AI services behind one login. The README describes it as a fork of ChatGPT-Next-Web, and the feature list starts with a checked item for every function of the original. On top of that base it adds StabilityAI endpoints (Stable Image Ultra, Stable Image Core, Stable Diffusion 3) and a Midjourney integration that the README labels unofficial. The Midjourney side covers Imagine, Upscale, Variation, Zoom, Vary, Pan, Reroll, Describe and Blend, plus region redraw and reference images, with live progress percentages during generation.

The intended user is someone who wants to hand a browser link to a small group and let them chat and draw without signing up for each provider separately. A CODE environment variable sets an access password for the page, and the README notes that all remaining parameters behave as they do in ChatGPT-Next-Web. If you only need text chat against an OpenAI-compatible endpoint, the extra image plumbing is dead weight you still have to configure.

The Midjourney dependency is the real architecture decision

ChatAny does not talk to Midjourney directly. The README states that its Midjourney APIs are provided by an open source project of the same kind, and that you must either self-host that service or use a third-party relay before ChatAny is useful for drawing. The named project is trueai-org/midjourney-proxy, and two variables connect the two: MJ_PROXY_URL for the proxy address and MJ_PROXY_KEY for its API key.

That means the deployment is really two services, and the failure modes live at the seam. If the proxy is down or the key is wrong, chat still works and drawing does not, which is a confusing state for users who assume the whole page is broken. The proxy is also where your Midjourney account credentials live, so the blast radius of a leaked key is not limited to ChatAny. StabilityAI, by contrast, follows the simpler pattern of a direct API call with a key.

The rest of the stack is a Next.js 14 application with React 18, Zustand for state, and a Tauri CLI in devDependencies for desktop builds. The build script runs a mask step first (yarn mask, backed by app/masks/build.ts) and then builds with BUILD_MODE=standalone, which is what lets the Docker image ship a minimal server bundle.

Installing ChatAny with Docker and creating your first drawing

The README gives a one-line Docker command. Fill in your own OpenAI key and, if you want drawing, the two Midjourney proxy values. Leave the proxy variables empty if you only want chat.

docker run -d -p 3000:3000 \
   -e OPENAI_API_KEY="sk-xxx" \
   -e BASE_URL="https://api.openai.com" \
   -e MJ_PROXY_URL="" \
   -e MJ_PROXY_KEY="" \
   licoy/chatany:latest

After the container starts, port 3000 serves the app. If you set CODE, the page asks for it before showing the interface. The README also lists Vercel, Railway and Sealos buttons for hosted deployment, and a manual path for people who prefer to build from source:

npm install
npm run build
npm run start

The README notes npm run dev as the development alternative. To reach the drawing screen, click the paint icon in the top left and pick the model you want, which the README shows in a screenshot walkthrough. For a compose-based setup, the repository ships docker-compose.yml with two profiles: no-proxy and proxy. The proxy profile adds PROXY_URL to the same environment list, and the Dockerfile explains what happens with it: when PROXY_URL is set, the entrypoint writes a proxychains configuration and starts the server through proxychains instead of calling node server.js directly. That is the mechanism for reaching OpenAI from a network that cannot connect out on its own.

Where ChatAny stops being the right tool

The README opens with a notice that the project has stopped being maintained and points readers to a different desktop client. That is the single most important limitation, and it is stated by the project itself rather than inferred. The last push to the repository was on 2026-04-02, and the most recent release listed is v3.5.0 from 2024-10-30. A fork of ChatGPT-Next-Web that no longer tracks upstream will drift further from it over time, and any fix for a Next.js or dependency security issue has to come from you.

The second limitation is the Midjourney proxy requirement described above. There is no bundled proxy, so a fresh install with empty MJ_PROXY_URL cannot draw at all. The README also links third-party relay APIs while explicitly declining to guarantee them, which means the reliability of that path is outside the project's control.

Finally, consider the shape of the product. It is a web UI with a shared access code, not a multi-tenant platform. The README's PRO version pitch lists packages, redemption codes, invite rewards and referral payouts as things the free version does not have. If you need per-user accounts or billing, ChatAny's own documentation is telling you it is not that.

ChatAny compared with plain ChatGPT-Next-Web

The honest alternative is the upstream project ChatAny is forked from: ChatGPT-Next-Web. Both are Next.js apps with the same configuration vocabulary, since ChatAny's README says its remaining parameters are identical. The difference is scope. Upstream gives you chat, and you add image generation by running a separate tool and switching tabs. ChatAny folds StabilityAI and Midjourney into the same interface, with a dedicated drawing entry point and, for Midjourney, in-page controls for upscale, variation and region redraw.

That convenience costs you an extra moving part and a maintenance gap. Upstream is a separate codebase with its own release cadence; ChatAny's README states that its own maintenance has ended. So the comparison is not feature count against feature count. It is an integrated but frozen fork against a narrower project that you would have to extend yourself. If your users mostly chat and occasionally generate an image, the integration may not be worth the extra proxy service. If Midjourney operations from inside the chat UI are the point, ChatAny already implements them.

Licence and what upgrading costs you

ChatAny is MIT licensed, and the LICENSE file sits at the repository root. MIT is permissive: you can modify and redistribute it, including commercially, provided the copyright notice and permission notice are preserved. That matters here because the practical upgrade path for a stopped project is your own fork, and MIT gives you the room to make one. This is a description of the licence text, not legal advice; if you plan to ship a modified version as a product, have someone qualified read the LICENSE and the upstream ChatGPT-Next-Web licence, since a fork inherits obligations from both.

The upgrade cost is mostly dependency drift. The Dockerfile pins node:18-alpine, package.json pins Next.js ^14.1.1 and React ^18.2.0, and the build depends on a mask-generation step that runs before next build. Bumping any of those means rebuilding the standalone output and re-testing the Midjourney flows, which depend on the proxy's API shape rather than on ChatAny's own code. The .env.template file at the root is the place to look for the full variable list before you write your own compose file.

Editorial conclusion

ChatAny suits teams that already run ChatGPT-Next-Web, want Midjourney and StabilityAI controls in the same interface, and can operate a midjourney-proxy service themselves. It is the wrong choice if you need upstream fixes, because the README states the project is no longer maintained and the last push was on 2026-04-02. Before deploying, verify that your midjourney-proxy instance answers on MJ_PROXY_URL with the matching MJ_PROXY_KEY, and decide whether you are willing to patch the fork yourself.

Frequently asked questions

Official sources

1. ChatAnyTeam/ChatAny on GitHub
2. Issues
3. License: MIT
4. README
5. Releases