Make your first request in 2 minutes

Four steps: create a key, export it, list the models, send a chat request. Everything uses the same static base URL: https://api.unlimitedmodel.com/v1.

export UNLIMITEDMODEL_API_KEY="YOUR_KEY"

$env:UNLIMITEDMODEL_API_KEY="YOUR_KEY"

curl https://api.unlimitedmodel.com/v1/models \
  -H "Authorization: Bearer $UNLIMITEDMODEL_API_KEY"

curl.exe https://api.unlimitedmodel.com/v1/models `
  -H "Authorization: Bearer $env:UNLIMITEDMODEL_API_KEY"

curl https://api.unlimitedmodel.com/v1/chat/completions \
  -H "Authorization: Bearer $UNLIMITEDMODEL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "<MODEL_ID>",
    "messages": [
      {
        "role": "user",
        "content": "Hello!"
      }
    ]
  }'

from openai import OpenAI

client = OpenAI(
    base_url="https://api.unlimitedmodel.com/v1",
    api_key=os.environ["UNLIMITEDMODEL_API_KEY"],
)

response = client.chat.completions.create(
    model="<MODEL_ID>",
    messages=[{"role": "user", "content": "Hello!"}],
)

print(response.choices[0].message.content)

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.unlimitedmodel.com/v1",
  apiKey: process.env.UNLIMITEDMODEL_API_KEY,
});

const response = await client.chat.completions.create({
  model: "<MODEL_ID>",
  messages: [{ role: "user", content: "Hello!" }],
});

console.log(response.choices[0].message.content);

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.unlimitedmodel.com/v1",
  apiKey: process.env.UNLIMITEDMODEL_API_KEY,
});

const response = await client.chat.completions.create({
  model: "<MODEL_ID>",
  messages: [{ role: "user", content: "Hello!" }],
});

console.log(response.choices[0].message.content);

Choose from live models

This list comes from GET /v1/models. Pick an ID to copy it, then use it as the model value in your request.

What's next

• Stream responses token by token with "stream": true.
• Connect OpenCode, Continue, Aider or Open WebUI.
• Read the error reference before you ship.

Authentication

Every request authenticates with an API key sent as a Bearer token. Keys are created in your dashboard and scoped to your account.

Create an API key

1. Sign in and open your dashboard.
2. Open the API Keys tab and choose Create Key.
3. Give the key a name, then copy the full key. It is shown once and never again.
4. Revoke keys you no longer use from the same table.

Keys are prefixed with um_live_ so they are recognizable in logs and secret scanners.

Send the key

Pass the key in the Authorization header on every request:

Authorization: Bearer YOUR_API_KEY

export UNLIMITEDMODEL_API_KEY="YOUR_KEY"

curl https://api.unlimitedmodel.com/v1/models \
  -H "Authorization: Bearer $UNLIMITEDMODEL_API_KEY"

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.unlimitedmodel.com/v1",
    api_key=os.environ["UNLIMITEDMODEL_API_KEY"],
)

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.unlimitedmodel.com/v1",
  apiKey: process.env.UNLIMITEDMODEL_API_KEY,
});

Authentication failures

Model Catalog

The catalog of available models is managed dynamically. Always read the current IDs from GET /v1/models and pass one of those IDs as the model value in your requests.

List the catalog

curl https://api.unlimitedmodel.com/v1/models \
  -H "Authorization: Bearer $UNLIMITEDMODEL_API_KEY"

Each entry carries an id. That ID is the value you send as model:

{
  "object": "list",
  "data": [
    {
      "id": "<MODEL_ID>",
      "object": "model",
      "created": 1730000000,
      "owned_by": "unlimitedmodel"
    }
  ]
}

Live catalog

This list is fetched from GET /v1/models for your current session. Copy an ID and use it directly.

Things to know

• IDs change. When a model is retired, requests with the old ID return 404. Refresh the list instead of caching IDs forever.
• Tiers. Some models belong to tiers that specific plans do not include; requesting one returns 403 with an explanation.
• Context windows. Context limits are model-specific. Keep requests within the limits of the model you pick.

Base URL

All API endpoints live under one static base URL. It is the same for every account, key and model.

https://api.unlimitedmodel.com/v1

Endpoints

Required headers

Response headers

Responses include your current limit state so clients can back off before hitting a limit:

Limits are per API key and defined by your plan. See Errors for what a 429 looks like and plan limits for what each plan includes.

OpenAI compatibility

Request and response shapes follow the OpenAI Chat Completions API, so existing SDKs and tools work by changing the base URL and API key. See the generic OpenAI-compatible guide for a checklist you can apply to any client.

GET /v1/models

Returns the model IDs currently enabled for your account. Use this endpoint to discover the value for the model field in chat requests.

Request

curl https://api.unlimitedmodel.com/v1/models \
  -H "Authorization: Bearer $UNLIMITEDMODEL_API_KEY"

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.unlimitedmodel.com/v1",
    api_key=os.environ["UNLIMITEDMODEL_API_KEY"],
)

models = client.models.list()
for model in models.data:
    print(model.id)

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.unlimitedmodel.com/v1",
  apiKey: process.env.UNLIMITEDMODEL_API_KEY,
});

const models = await client.models.list();
models.data.forEach((model) => console.log(model.id));

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.unlimitedmodel.com/v1",
  apiKey: process.env.UNLIMITEDMODEL_API_KEY,
});

const models = await client.models.list();
for (const model of models.data) {
  console.log(model.id);
}

Response

{
  "object": "list",
  "data": [
    {
      "id": "<MODEL_ID>",
      "object": "model",
      "created": 1730000000,
      "owned_by": "unlimitedmodel"
    }
  ]
}

Try it against the live catalog

Errors

• 401 — missing or invalid API key.
• 403 — your subscription does not include API access.
• 429 — too many requests; back off and retry.

POST /v1/chat/completions

Creates a chat completion from a list of messages. The request and response follow the OpenAI Chat Completions shape, including streaming.

Request body

Examples

curl https://api.unlimitedmodel.com/v1/chat/completions \
  -H "Authorization: Bearer $UNLIMITEDMODEL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "<MODEL_ID>",
    "messages": [
      { "role": "system", "content": "You are a concise assistant." },
      { "role": "user", "content": "Explain what an API gateway does." }
    ],
    "temperature": 0.7
  }'

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.unlimitedmodel.com/v1",
    api_key=os.environ["UNLIMITEDMODEL_API_KEY"],
)

response = client.chat.completions.create(
    model="<MODEL_ID>",
    messages=[
        {"role": "system", "content": "You are a concise assistant."},
        {"role": "user", "content": "Explain what an API gateway does."},
    ],
    temperature=0.7,
)

print(response.choices[0].message.content)

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.unlimitedmodel.com/v1",
  apiKey: process.env.UNLIMITEDMODEL_API_KEY,
});

const response = await client.chat.completions.create({
  model: "<MODEL_ID>",
  messages: [
    { role: "system", content: "You are a concise assistant." },
    { role: "user", content: "Explain what an API gateway does." },
  ],
  temperature: 0.7,
});

console.log(response.choices[0].message.content);

import OpenAI from "openai";
import type { ChatCompletion } from "openai/resources/chat/completions";

const client = new OpenAI({
  baseURL: "https://api.unlimitedmodel.com/v1",
  apiKey: process.env.UNLIMITEDMODEL_API_KEY,
});

const response: ChatCompletion = await client.chat.completions.create({
  model: "<MODEL_ID>",
  messages: [{ role: "user", content: "Explain what an API gateway does." }],
});

console.log(response.choices[0]?.message?.content);

Response

{
  "id": "chatcmpl-...",
  "object": "chat.completion",
  "created": 1730000000,
  "model": "<MODEL_ID>",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "An API gateway sits between clients and backend services..."
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 24,
    "completion_tokens": 96,
    "total_tokens": 120
  }
}

Notes

• Model routing and provider selection happen behind the gateway; you only ever send the public model ID.
• When a model is unavailable, the request fails fast with 404 rather than a partial answer. See Errors.
• Tool calling depends on the selected model and route. If a model cannot use tools, the request returns an error instead of silently ignoring them.

Streaming

Set "stream": true to receive tokens as they are generated. The response is a stream of server-sent events, each carrying a chunk in the same shape as a chat completion.

How chunks arrive

• Each event is a line starting with data: followed by a JSON chunk.
• Chunks carry choices[0].delta with the incremental content.
• The stream ends with data: [DONE].
• Usage totals arrive on the final chunk when the provider reports them.

data: {"id":"chatcmpl-...","object":"chat.completion.chunk","choices":[{"index":0,"delta":{"role":"assistant","content":"An"}}]}

data: {"id":"chatcmpl-...","object":"chat.completion.chunk","choices":[{"index":0,"delta":{"content":" API"}}]}

data: {"id":"chatcmpl-...","object":"chat.completion.chunk","choices":[{"index":0,"delta":{"content":" gateway"}}]}

data: [DONE]

cURL

Use -N to disable buffering so chunks print as they arrive.

curl -N https://api.unlimitedmodel.com/v1/chat/completions \
  -H "Authorization: Bearer $UNLIMITEDMODEL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "<MODEL_ID>",
    "stream": true,
    "messages": [
      { "role": "user", "content": "Write a short haiku about streaming." }
    ]
  }'

Python

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.unlimitedmodel.com/v1",
    api_key=os.environ["UNLIMITEDMODEL_API_KEY"],
)

stream = client.chat.completions.create(
    model="<MODEL_ID>",
    stream=True,
    messages=[{"role": "user", "content": "Write a short haiku about streaming."}],
)

for chunk in stream:
    delta = chunk.choices[0].delta
    if delta.content:
        print(delta.content, end="", flush=True)

JavaScript / TypeScript

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.unlimitedmodel.com/v1",
  apiKey: process.env.UNLIMITEDMODEL_API_KEY,
});

const stream = await client.chat.completions.create({
  model: "<MODEL_ID>",
  stream: true,
  messages: [{ role: "user", content: "Write a short haiku about streaming." }],
});

for await (const chunk of stream) {
  const delta = chunk.choices[0]?.delta?.content;
  if (delta) process.stdout.write(delta);
}

Errors

Failures return a JSON body with a type and a human-readable message, plus the usual HTTP status code. This page documents the statuses and error types the API actually returns.

Error response shape

{
  "type": "error",
  "error": {
    "type": "model_not_found",
    "message": "The requested customer-facing model is not available. Refresh /v1/models and try again."
  }
}

Status codes

Rate limits and throttling

Limits are per API key and come from your plan. Every response carries your current state:

• Requests per minute (RPM) counts each request, per key, over a sliding window.
• Tokens per minute (TPM) counts actual tokens used, per key.
• Concurrency limits how many requests run at once; excess requests wait or receive 429.
• When a 429 includes a retry hint, honor it. Otherwise wait for X-RateLimit-Reset.

Limits, fair use and usage

• Plan limits and fair-use terms — what each subscription includes.
• Usage dashboard — your token and request consumption.
• Troubleshooting — common causes and fixes.

cURL

The fastest way to test the API. Export your key once, then send requests against the static base URL.

Set your key

export UNLIMITEDMODEL_API_KEY="YOUR_KEY"

$env:UNLIMITEDMODEL_API_KEY="YOUR_KEY"

List models

curl https://api.unlimitedmodel.com/v1/models \
  -H "Authorization: Bearer $UNLIMITEDMODEL_API_KEY"

Chat completion

curl https://api.unlimitedmodel.com/v1/chat/completions \
  -H "Authorization: Bearer $UNLIMITEDMODEL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "<MODEL_ID>",
    "messages": [
      { "role": "user", "content": "Hello!" }
    ]
  }'

Streaming

curl -N https://api.unlimitedmodel.com/v1/chat/completions \
  -H "Authorization: Bearer $UNLIMITEDMODEL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "model": "<MODEL_ID>", "stream": true, "messages": [{ "role": "user", "content": "Hello!" }] }'

Python

Use the official OpenAI Python SDK and change only the base URL and key. No proprietary SDK is required.

Install

pip install openai

Client setup

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.unlimitedmodel.com/v1",
    api_key=os.environ["UNLIMITEDMODEL_API_KEY"],
)

Chat completion

response = client.chat.completions.create(
    model="<MODEL_ID>",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Summarize what a flat-rate API means."},
    ],
)

print(response.choices[0].message.content)

Streaming

stream = client.chat.completions.create(
    model="<MODEL_ID>",
    stream=True,
    messages=[{"role": "user", "content": "Count from 1 to 5."}],
)

for chunk in stream:
    delta = chunk.choices[0].delta
    if delta.content:
        print(delta.content, end="", flush=True)

List models

for model in client.models.list().data:
    print(model.id)

JavaScript / TypeScript

Use the official OpenAI JavaScript SDK in Node.js, Bun or Deno. Change the base URL and key, keep the rest of your code.

Install

npm install openai

Client setup

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.unlimitedmodel.com/v1",
  apiKey: process.env.UNLIMITEDMODEL_API_KEY,
});

Chat completion

const response = await client.chat.completions.create({
  model: "<MODEL_ID>",
  messages: [
    { role: "system", content: "You are a helpful assistant." },
    { role: "user", content: "Summarize what a flat-rate API means." },
  ],
});

console.log(response.choices[0]?.message?.content);

Streaming

const stream = await client.chat.completions.create({
  model: "<MODEL_ID>",
  stream: true,
  messages: [{ role: "user", content: "Count from 1 to 5." }],
});

for await (const chunk of stream) {
  const delta = chunk.choices[0]?.delta?.content;
  if (delta) process.stdout.write(delta);
}

List models

const models = await client.models.list();
models.data.forEach((model) => console.log(model.id));

Use UnlimitedModel with OpenCode

OpenCode supports custom OpenAI-compatible providers through the @ai-sdk/openai-compatible package. Add one provider block, set an environment variable, and pick a model.

Setup

1. Create an UnlimitedModel API key in your dashboard.
2. Store it as an environment variable (below).
3. Add UnlimitedModel as an OpenAI-compatible provider in opencode.json.
4. Add a model ID from GET /v1/models to the provider's models map.
5. Run OpenCode, open /models, and select the provider and model.

1. Environment variable

export UNLIMITEDMODEL_API_KEY="YOUR_KEY"

$env:UNLIMITEDMODEL_API_KEY="YOUR_KEY"

2. opencode.json

Put this in your project's opencode.json (or the global OpenCode config). The {env:...} syntax reads the key from your environment at startup.

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "unlimitedmodel": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "UnlimitedModel",
      "options": {
        "baseURL": "https://api.unlimitedmodel.com/v1",
        "apiKey": "{env:UNLIMITEDMODEL_API_KEY}"
      },
      "models": {
        "<MODEL_ID>": {
          "name": "<MODEL_ID>"
        }
      }
    }
  }
}

3. Get model IDs

curl https://api.unlimitedmodel.com/v1/models \
  -H "Authorization: Bearer $UNLIMITEDMODEL_API_KEY"

Copy an id from the response into the models map above. The key in that map and the name value can be the same ID.

4. Select it in OpenCode

1. Open OpenCode in your project.
2. Run /models.
3. Select UnlimitedModel as the provider.
4. Select the model you configured.

If you prefer storing the key with OpenCode instead of an environment variable, run /connect, choose Other, enter unlimitedmodel as the provider ID, and paste your key. The provider ID must match the key in your opencode.json.

Troubleshooting

OpenCode also has opencode auth list to confirm which credentials it has stored.

Use UnlimitedModel with Continue

Continue (VS Code and JetBrains) supports custom OpenAI-compatible API bases. Point the built-in openai provider at UnlimitedModel and set useResponsesApi: false so requests use /chat/completions.

Setup

1. Create an UnlimitedModel API key in your dashboard.
2. Open Continue's configuration file: config.yaml (the config file is opened with the gear icon in the Continue panel).
3. Add the model entry below.
4. Save; Continue reloads the configuration automatically.
5. Select UnlimitedModel in the model dropdown.

config.yaml

name: UnlimitedModel
version: 1.0.0
schema: v1

models:
  - name: UnlimitedModel
    provider: openai
    model: <MODEL_ID>
    apiBase: https://api.unlimitedmodel.com/v1
    apiKey: <YOUR_UNLIMITEDMODEL_API_KEY>
    useResponsesApi: false
    roles:
      - chat
      - edit
      - apply

Get model IDs

curl https://api.unlimitedmodel.com/v1/models \
  -H "Authorization: Bearer $UNLIMITEDMODEL_API_KEY"

The model value must exactly match an ID returned by that endpoint.

Troubleshooting

Use UnlimitedModel with Aider

Aider connects to any OpenAI-compatible endpoint. Point its OpenAI client at UnlimitedModel with two environment variables and prefix the model name with openai/.

Install Aider

python -m pip install aider-install
aider-install

Set the endpoint and key

export OPENAI_API_BASE="https://api.unlimitedmodel.com/v1"
export OPENAI_API_KEY="$UNLIMITEDMODEL_API_KEY"

$env:OPENAI_API_BASE="https://api.unlimitedmodel.com/v1"
$env:OPENAI_API_KEY=$env:UNLIMITEDMODEL_API_KEY

Run Aider

cd /to/your/project
aider --model openai/<MODEL_ID>

<MODEL_ID> must exactly match an ID returned by GET /v1/models:

curl https://api.unlimitedmodel.com/v1/models \
  -H "Authorization: Bearer $UNLIMITEDMODEL_API_KEY"

Troubleshooting

• 401: OPENAI_API_KEY is empty or wrong. Print it with echo $OPENAI_API_KEY (or $env:OPENAI_API_KEY) to confirm.
• 404: the model ID is stale; refresh GET /v1/models.
• Requests still going to OpenAI: make sure OPENAI_API_BASE is exported in the same shell that runs aider.

Use UnlimitedModel with Open WebUI

Open WebUI connects to any server that implements the OpenAI Chat Completions API. Add UnlimitedModel as a connection and its models appear in the picker.

Add the connection

1. Open Open WebUI and go to Settings → Admin → Connections.
2. In the Manage OpenAI API Connections list, click Add Connection (the plus button).
3. Enter the URL: https://api.unlimitedmodel.com/v1
4. Enter your API key in the API Key field.
5. Click Verify Connection. UnlimitedModel serves /v1/models, so verification and model auto-discovery both work.
6. Click Save.

Start chatting

1. Open the model selector at the top of the chat.
2. Pick the UnlimitedModel connection and a model ID from the catalog.
3. Send a message.

Notes

• Use the URL exactly as shown, without a trailing slash.
• If Open WebUI runs in Docker and you proxy the API through your host, replace localhost with host.docker.internal in your own proxy URL.
• RAG features that need embeddings require an embeddings endpoint, which UnlimitedModel does not expose. Point Open WebUI's embedding engine at a provider that does.

Generic OpenAI-Compatible Client

If your tool is not listed here, use this page. Any client that supports a custom OpenAI base URL works with UnlimitedModel by changing three things: base URL, API key and model ID.

Configuration

Verify from the terminal

curl https://api.unlimitedmodel.com/v1/chat/completions \
  -H "Authorization: Bearer $UNLIMITEDMODEL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "model": "<MODEL_ID>", "messages": [{ "role": "user", "content": "Hello!" }] }'

Checklist for any client

1. Set the base URL to https://api.unlimitedmodel.com/v1. Many clients append /chat/completions automatically; do not include it in the base.
2. Paste an UnlimitedModel API key as the API key. If the client asks for an "OpenAI key", this is the value to use.
3. Fetch or paste a model ID from GET /v1/models. Do not hardcode a model that may be retired.
4. If the client offers a choice between the Responses API and Chat Completions, choose Chat Completions.
5. Send one message and confirm you receive a completion. Then enable streaming if you want it.

Quick troubleshooting

Troubleshooting

Start with the status code. Each section below maps a symptom to the most likely cause and the fix.

401 Unauthorized

• The Authorization header is missing or malformed. It must be Authorization: Bearer YOUR_KEY.
• The key was revoked or belongs to another account.
• Your client is sending the key to the wrong host. Confirm the base URL is https://api.unlimitedmodel.com/v1.

403 Forbidden

• Your subscription does not include the requested model or tier. Check plan limits or choose a different model.
• The request was blocked by the safety policy.

404 Model not found

• The model ID is outdated. Refresh GET /v1/models and use an exact current ID.
• The model exists in the catalog but has no available route at the moment; retrying usually resolves it.

429 Too many requests

• You hit the per-key RPM, TPM or concurrency limit. Read X-RateLimit-Remaining and X-RateLimit-Reset and retry after the window.
• Reduce parallel requests if concurrency is the limit (X-Concurrency-Limit).

Streaming problems

• No output until the end: your HTTP client is buffering. With cURL, add -N.
• Partial text: parse choices[0].delta.content per event and stop at data: [DONE].
• Errors: authentication and model errors arrive as normal JSON responses with an error status, before any stream events.

Client-specific issues

• OpenCode: provider not appearing usually means the provider ID in your config does not match, the JSON is invalid, or the wrong npm package is set. See the OpenCode guide.
• Continue: hanging requests usually mean the client is using the Responses API. Set useResponsesApi: false. See the Continue guide.
• Aider: confirm OPENAI_API_BASE is exported in the same shell that runs Aider, and prefix the model with openai/. See the Aider guide.
• Open WebUI: if connection verification fails, add model IDs manually; chat still works. See the Open WebUI guide.

Still stuck?

Ask other UnlimitedModel users in the community Discord, or open a support ticket from your dashboard for account-specific issues.

FAQ

Short answers to the questions developers ask most.