The Best Open AI Chat Programs in 2026: 6 Popular Clients with Custom Base URLs

Many AI chat applications look similar, but the practical difference is often whether they let you choose the model service and change the API Base URL.

In this article, “open AI chat program” does not simply mean that the software license must be open source, nor does it mean that the application must be free. It means that the program meets at least these conditions:

• users can enter their own API key;
• users can customize a Base URL, API address, or API host;
• it can connect to OpenAI-compatible services, Ollama, LM Studio, or another compatible gateway;
• users are not forced to buy only the service bundled into the application.

The benefit is that official APIs, local models, third-party gateways, and private enterprise models can be switched from one interface. For example, you can connect several models to UnifyLLM and maintain only one provider configuration in the chat client.

How were these six programs selected?

The order below references public GitHub star counts checked on July 20, 2026, along with update activity, platform coverage, documentation quality, and custom-endpoint support. Stars change over time and are not the same as active users. This is a practical list of popular clients that work well with custom interfaces, not a strict market-share ranking.

1. Open WebUI: best for self-hosting and teams

Open WebUI is one of the most popular open-source AI web interfaces. Its documentation positions it as a unified interface that can connect Ollama, OpenAI, Anthropic, and other OpenAI-compatible providers.

Its strengths go beyond chat: file and image uploads, web search, multi-model comparison, knowledge bases, tool calls, MCP, user permissions, and usage management. For teams that want local and cloud models behind one entry point, Open WebUI is highly extensible.

Connecting a custom Base URL

The typical flow is:

1. Deploy Open WebUI with Docker or another method;
2. open Connections or OpenAI API settings in the admin panel;
3. add an OpenAI-compatible connection;
4. enter the API URL, API key, and model;
5. save and select the model in the chat model list.

For UnifyLLM, a typical OpenAI-compatible address is:

https://api.unifyllm.com/v1

Open WebUI is feature-complete and works well for shared use. The trade-off is that deployment and permission configuration are more involved than with a desktop client. If you only want a quick personal chat window, it may feel heavy.

2. NextChat: a lightweight and easy-to-deploy ChatGPT alternative

NextChat, formerly ChatGPT Next Web, is a lightweight web/PWA chat client. Its goal is a simple chat interface, so it is convenient to deploy on Vercel, Docker, or your own server.

The official README provides environment variables such as OPENAI_API_KEY and BASE_URL. BASE_URL overrides the default OpenAI API address. Multiple model services can be configured, making NextChat suitable for people who want a clean chat window without a complex knowledge base or team-permission system.

Advantages and cautions

• lightweight pages with low startup and deployment cost;
• multi-turn conversations, prompts, model switching, and common chat features;
• custom proxies and third-party gateways through environment variables;
• better for personal use than for complex Agents and team management.

Different NextChat versions may or may not append /v1 automatically. Check the current README and deployment UI before connecting a gateway so /v1 is not added twice. The same warning applies to every OpenAI-compatible client.

3. LobeHub / LobeChat: polished UI with complete Agent capabilities

LobeHub, still called LobeChat by many users, is a polished multi-model AI workspace covering providers, Agents, knowledge bases, plugins, MCP, and productivity features.

It suits users who want chat, knowledge, assistants, and tools in one workspace. Its learning curve is higher than that of a minimalist chat window, but it is easier to build lasting assistants and workflows.

Custom OpenAI Base URL

LobeHub’s self-hosting environment-variable documentation provides OPENAI_PROXY_URL to override the default OpenAI API Base URL. Examples include addresses with and without /v1, and the documentation stresses that the suffix depends on the gateway.

With UnifyLLM, use the current version’s configuration style, for example:

OPENAI_API_KEY=<your UnifyLLM API key>
OPENAI_PROXY_URL=https://api.unifyllm.com/v1

If you use LobeHub’s hosted version, check whether its current UI exposes custom providers. Self-hosting gives you more control over environment variables and network egress.

4. Cherry Studio: one of the most convenient desktop multi-model workspaces

Cherry Studio supports Windows, macOS, and Linux. Its documentation lists more than 60 provider templates, including OpenAI-compatible, Anthropic-compatible, Gemini, local inference, and special gateways.

Its main strength is a friendly configuration UI. Usually you can select a provider under Settings → Model Providers, enter an API key and address, and click Get Models. The documentation also offers a custom provider that can connect to OpenAI-, Anthropic-, or Gemini-compatible endpoints.

Connect Cherry Studio to UnifyLLM

1. Open Settings → Model Providers;
2. add a custom provider or choose the OpenAI-compatible type;
3. enter https://api.unifyllm.com/v1 as the API address;
4. enter your UnifyLLM API key;
5. click Get Models and select a model;
6. click Test and send a short message.

Cherry Studio also includes knowledge bases, Agents, MCP, translation, and multi-model comparison. The trade-off is that the first configuration requires you to understand the difference between providers, models, and capability types.

5. Chatbox: fast, cross-platform personal client

Chatbox supports Windows, macOS, Linux, iOS, Android, and the web. Its official site emphasizes that desktop applications can use your own API key with different model services instead of requiring Chatbox’s built-in AI service.

Chatbox is simple, cross-device, and good at prompt management. Its help center also provides an LM Studio connection guide: choose LM Studio in model-service settings and enter the API host. This shows that it can connect to local or networked compatible services as well as official APIs.

Suitable scenarios

• use the same provider across several computers and phones;
• install a client without deploying a server;
• save prompts, assistants, and conversations;
• connect LM Studio, an Ollama gateway, or an OpenAI-compatible proxy.

For UnifyLLM, choose an OpenAI-compatible provider and enter the API key and https://api.unifyllm.com/v1. If the current version defines API Host as a root host without a version suffix, follow the UI and make sure the final request path contains only one /v1.

6. LibreChat: one of the most configurable self-hosted options

LibreChat is a self-hosted multi-provider AI chat platform. It supports official and third-party models, Agents, files, RAG, tools, and extension configuration.

Its distinctive feature is treating custom endpoints as a first-class capability. The documentation provides librechat.yaml configuration, supports environment-variable API keys, and can set a key to user_provided so users enter their own key in the web UI.

An OpenAI-compatible endpoint in the quickstart documentation looks similar to:

version: 1.3.13
cache: true
endpoints:
  custom:
    - name: "UnifyLLM"
      apiKey: "${UNIFYLLM_API_KEY}"
      baseURL: "https://api.unifyllm.com/v1"
      models:
        default: ["gpt-5.6-sol"]
        fetch: true

Then add this to .env:

UNIFYLLM_API_KEY=your UnifyLLM API key

With Docker, make sure librechat.yaml is mounted into the container and restart after editing. LibreChat is a good fit for fine-grained provider, model, and permission control, but YAML, environment variables, and container mounts add maintenance cost.

How should you choose among the six?

Use this quick guide:

• team self-hosting, knowledge bases, and permissions: Open WebUI;
• the lightest chat page: NextChat;
• polished UI, Agents, and workflows: LobeHub / LobeChat;
• many models on a Windows, macOS, or Linux desktop: Cherry Studio;
• cross-device personal use with minimal setup: Chatbox;
• YAML-level control of endpoints and user keys: LibreChat.

All six can change a Base URL. The real differences are configuration entry points, self-hosting requirements, local-model support, knowledge bases, Agents, and where API keys are stored.

Quickly connect these programs through UnifyLLM

UnifyLLM provides an OpenAI-compatible interface for common chat clients. Start with these values in most programs that support custom Base URLs:

Protocol: OpenAI Compatible
Base URL: https://api.unifyllm.com/v1
API key: a dedicated key created in the UnifyLLM console
Model: choose from the model list or enter an exact ID such as gpt-5.6-sol

The general flow is:

1. sign in to the UnifyLLM console, create a dedicated API key, and confirm balance and model permissions;
2. choose OpenAI, OpenAI Compatible, Custom Provider, or a similar option in the target program;
3. set Base URL/API Host to https://api.unifyllm.com/v1;
4. paste the API key and fetch models or enter an exact model ID;
5. send a short request;
6. review usage logs to confirm the model, tokens, latency, and charge.

Where should /v1 go?

Clients handle Base URLs differently:

• if the client requests a complete OpenAI-compatible Base URL, use https://api.unifyllm.com/v1;
• if its documentation says it appends /v1 automatically, enter only https://api.unifyllm.com;
• for NextChat, LobeHub, and similar environment variables, follow the current version’s examples;
• the final request address must contain exactly one /v1, otherwise you may get a 404, an empty model list, or an incorrect path.

Why might the model list be empty?

An empty model list does not always mean the API is unavailable. Common causes include:

• /v1 is missing or duplicated;
• the client’s model-list endpoint and chat endpoint use different protocols;
• the API key lacks model permission or the account has insufficient balance;
• the client cached an old model list;
• the model ID differs from the console’s spelling.

Try entering a confirmed model ID manually, send a short request, and inspect UnifyLLM usage logs.

Security and privacy reminders

A custom Base URL gives you freedom, but also makes you responsible for configuration and data handling:

• never put an API key in a public GitHub repository, frontend code, or screenshot;
• use environment variables or a secret manager instead of writing keys directly into YAML;
• create separate keys for different clients and set quotas, expiration, and model restrictions;
• test with a low-quota key before running batch work or an automated Agent;
• do not send passwords, payment information, identity credentials, or unnecessary sensitive files to a third-party model;
• in a team deployment, check whether logs, reverse proxies, and backups expose request content or keys.

“Open” does not mean “risk-free.” It means the user controls model selection and endpoint configuration; the security boundary still needs to be managed.

Conclusion

In 2026, AI chat programs are moving from windows that only use one official model service to unified workspaces that connect multiple providers, local models, and private gateways. Open WebUI, NextChat, LobeHub, Cherry Studio, Chatbox, and LibreChat represent six directions: team self-hosting, lightweight web, Agent workspace, desktop multi-model management, cross-platform personal use, and high configurability.

If you switch models frequently or want one API entry point for several providers, choose a client with a custom Base URL and use UnifyLLM to manage models, keys, quotas, and usage. This is usually easier than maintaining a separate client for every provider.

References

• Open WebUI GitHub
• Open WebUI feature documentation
• NextChat GitHub and environment variables
• LobeHub GitHub
• LobeHub model-provider environment variables
• Cherry Studio GitHub
• Cherry Studio model-provider documentation
• Chatbox GitHub
• Chatbox LM Studio guide
• LibreChat GitHub
• LibreChat custom endpoints quickstart
• UnifyLLM Getting Started
• UnifyLLM Integrations