Self-hosting the TypingMind static frontend

What the TypingMind repository actually contains

The README calls this the Static Self-host Version of TypingMind, distinct from the hosted app at typingmind.com. The repository is small: .gitignore, ACKNOWLEDGEMENT.md, LICENSE.md, README.md, package.json, src/, yarn.lock. The primary language is HTML, and the only declared dependency is http-server as a devDependency. That layout matters. There is no backend service, no database migration folder, no server entry point. The src/ directory is the whole application, and the README says you can use any other static web server to host it. The audience is people who already hold API keys for OpenAI, Anthropic, Google or a local inference server and want a chat interface that runs on their own machine or private server rather than inside someone else's product. The README's stated benefits are pay-per-use instead of a monthly subscription, conversations not used for training by OpenAI or Claude, and one interface across multiple models.

How a static bundle becomes a multi-model chat client

The architecture follows from the file list. Because there is no server code in the repository, the browser is the runtime. API keys and chat history live in the browser's local storage, which is what the README means by offline first and private by default: all your data, messages, and API keys are stored locally on your device. Requests go from the page directly to whichever provider you configured, which is why the README warns that hostnames other than localhost must use HTTPS for all app features to work. A plain HTTP origin on a real domain will break parts of the app, and the README does not enumerate which parts. Model support is not hardcoded to a fixed list. The README describes adding custom endpoints and custom models, including OpenRouter-style routers and locally hosted models such as LocalAI and Ollama, with configurable parameters including Temperature, Frequency_penalty, Presence_penalty, Top_P and Top_K. The practical consequence of a browser-only design is that anything requiring a secret the browser should not hold, such as a shared team key or server-side logging, has no place to live in this build.

Installing TypingMind and serving it on localhost:3000

The README gives four steps: clone the repo, install dependencies, start the server, open the app. The package.json defines exactly one script, start, which runs http-server against the src folder on port 3000. Because http-server is a devDependency, the install step is what makes the start script work. Run these two commands from the repository root.

Adding a custom model endpoint as a first task

Once the page loads at localhost:3000, the README's path for connecting anything beyond the built-in providers is the model dropdown. The sequence is: open the model dropdown, choose Model Settings, then Add Custom Models. You supply an Endpoint and a Model ID, and the README states that custom headers and body parameters are supported. There is a Test button before Add Model, so the dialog validates the endpoint before you commit it. If the test fails against a model running on your own machine, the README points at CORS: run your local model in CORS mode. That is the most common first-run failure for Ollama or LocalAI users, and it is a server-side setting on the inference process, not something you fix in TypingMind. The README links separate documentation pages for Local AI, Azure OpenAI, OpenRouter, fine-tuned OpenAI models, Mistral AI and Perplexity AI, which is where provider-specific header and body formats are described.

Where the self-host build stops and the licence key starts

The README is direct that this is not a fully free application: TypingMind is free to use with some basic features, a license key is needed to unlock all advanced features, and it points to the pricing page. The README does not list which features sit on each side of that line, so anyone evaluating the self-host build for a team should treat the feature list as aspirational until they confirm the split. The package.json declares the license as N/A, and the repository carries a LICENSE.md file whose contents are not reproduced here. That combination is the single biggest adoption risk in the repository. If your organisation requires a recognised open source licence before code can be deployed internally, this project does not present one in the metadata, and the README frames the software as a commercial product with a free tier. The README also does not document rollback, version pinning or an upgrade path for the self-host build, and no releases were retrieved, so there is no changelog to read before you replace src/ with a newer copy.

What the README does not answer about safety and operation

The privacy claim in the README is narrow and specific: data and API keys stay in the browser. That is a statement about storage location, not about what leaves the machine. Every prompt you send still travels to whichever provider you configured, and the README's argument is only that your conversations are not used for training by those providers and that you pay per token instead of a subscription. There is no mention of an audit log, a retention policy, a shared key vault, or any server-side control, because the architecture has no server. For a single engineer running the app on a laptop, that is the point. For a team that needs centralised key management or a record of who asked what, the static build is the wrong shape, and the README's answer is the separate Typing Mind Custom product aimed at teams, which is a different offering with its own hosting and user management.

TypingMind against a locally run chat UI such as Open WebUI

The closest alternative in this space is a self-hosted chat interface that runs its own backend, with Open WebUI as the common example. The difference is architectural rather than cosmetic. Open WebUI is a server application: it holds user accounts, stores conversations in a database, and can proxy model requests, which is why it can support multi-user access and server-side API key management. TypingMind's static build does none of that, because there is no process to hold state. In exchange, deployment is a static file host and the browser holds the secrets, so there is no database to back up and no server to patch. Which one fits depends on whether your problem is one person wanting a better interface for their own keys, or a group needing shared accounts. The README positions Typing Mind Custom as the answer to the second case, and that is a commercial product, not this repository.

Maintenance, upgrades and what the repository tells you

The last push to the repository was on 2026-09-03, so the code is being touched, but no releases were retrieved and the README documents no versioning scheme for the self-host build. Upgrading therefore means pulling the repository and replacing src/, and the README says nothing about whether local storage survives that. Since chat history and keys live in the browser, a change to the storage format between pulls is the failure mode to watch for, and the README does not describe an export path in the self-host instructions even though the feature list mentions Import/Export and Backup & Sync. The dependency surface is tiny, one devDependency for the local server, so the usual supply chain argument for a small install applies. The licence question is the real maintenance cost: LICENSE.md is present but the package metadata says N/A, and the README states a licence key is needed for advanced features. Anyone deploying this inside a company should read LICENSE.md and the pricing page before writing it into an internal runbook.

Editorial conclusion

Adopt the static self-host build if you want a local browser UI that talks to OpenAI, Claude, Gemini or a local model endpoint with your own API keys and you accept that the full feature set is gated behind a licence key. Do not adopt it if you need a server-side component, a documented open source licence, or a project you can fork and extend without permission. Before deploying, check LICENSE.md and the pricing page, and confirm your hostname serves over HTTPS. Then verify one custom model endpoint answers from the Model Settings dialog before you move any real conversations into it.

Frequently asked questions

Official sources

1. Issues
2. Project website
3. README
4. TypingMind/typingmind on GitHub