OpenAI-Compatible

Use any OpenAI SDK — Python, Node, Go, Java, Rust — by setting the base URL. Also works with raw HTTP from any language. The original /api/chat endpoint still works too.

POST/v1/chat/completions or /api/chat (legacy)

cURL:

curl https://unlimited-ai-free.pages.dev/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_KEY" \
  -d '{
    "model": "gpt-5",
    "messages": [{"role": "user", "content": "Hello!"}],
    "stream": true
  }'

Python (openai SDK):

from openai import OpenAI
client = OpenAI(base_url='https://unlimited-ai-free.pages.dev', api_key='YOUR_KEY')
stream = client.chat.completions.create(
    model='gpt-5',
    messages=[{'role': 'user', 'content': 'Hello!'}],
    stream=True,
)
for chunk in stream:
    print(chunk.choices[0].delta.content or '', end='')

Python (requests — no SDK):

import requests, json
r = requests.post('https://unlimited-ai-free.pages.dev/v1/chat/completions',
    headers={'Authorization': 'Bearer YOUR_KEY', 'Content-Type': 'application/json'},
    json={'model': 'gpt-5', 'messages': [{'role': 'user', 'content': 'Hello!'}], 'stream': True},
    stream=True)
for line in r.iter_lines():
    if line: print(line.decode())

JavaScript (openai SDK):

import OpenAI from 'openai';
const client = new OpenAI({
  baseURL: 'https://unlimited-ai-free.pages.dev',
  apiKey: 'YOUR_KEY',
});
const stream = await client.chat.completions.create({
  model: 'gpt-5',
  messages: [{ role: 'user', content: 'Hello!' }],
  stream: true,
});
for await (const chunk of stream) {
  process.stdout.write(chunk.choices[0]?.delta?.content || '');
}

JavaScript (fetch — no SDK):

const res = await fetch('https://unlimited-ai-free.pages.dev/v1/chat/completions', {
  method: 'POST',
  headers: { 'Authorization': 'Bearer YOUR_KEY', 'Content-Type': 'application/json' },
  body: JSON.stringify({ model: 'gpt-5', messages: [{ role: 'user', content: 'Hello!' }], stream: true }),
});
const reader = res.body.getReader();
// read stream chunks...

Anthropic-Compatible

Use any Anthropic SDK — Python, Node, Go — or set environment variables for CLI tools. The same API key works here.

POST/v1/messages

cURL:

curl https://unlimited-ai-free.pages.dev/v1/messages \
  -H "Content-Type: application/json" \
  -H "x-api-key: YOUR_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -d '{
    "model": "claude-opus-4-7-20260101",
    "max_tokens": 1024,
    "messages": [{"role": "user", "content": "Hello!"}]
  }'

JavaScript (Anthropic SDK):

import Anthropic from '@anthropic-ai/sdk';
const client = new Anthropic({
  baseURL: 'https://unlimited-ai-free.pages.dev',
  apiKey: 'YOUR_KEY',
});
const msg = await client.messages.create({
  model: 'claude-opus-4-7-20260101',
  max_tokens: 1024,
  messages: [{ role: 'user', content: 'Hello!' }],
});

Python (anthropic SDK):

import anthropic
client = anthropic.Anthropic(
    base_url='https://unlimited-ai-free.pages.dev',
    api_key='YOUR_KEY',
)
msg = client.messages.create(
    model='claude-opus-4-7-20260101',
    max_tokens=1024,
    messages=[{'role': 'user', 'content': 'Hello!'}],
)

Environment variable setup (any tool):

export ANTHROPIC_BASE_URL=https://unlimited-ai-free.pages.dev
export ANTHROPIC_API_KEY=YOUR_KEY
# Then use any Anthropic-compatible tool or SDK normally

OpenCode / AI Editors

Use your API key in OpenCode, Cursor, Windsurf, or any AI coding tool that supports OpenAI-compatible providers.

OpenCode — add to opencode.json:

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "unlimited-ai": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Unlimited AI",
      "options": {
        "baseURL": "https://unlimited-ai-free.pages.dev"
      },
      "models": {
        "gpt-5": { "name": "GPT-5", "limit": { "context": 128000 } },
        "claude-opus-4-8": { "name": "Claude Opus 4.8", "limit": { "context": 200000 } },
        "claude-opus-4-7": { "name": "Claude Opus 4.7", "limit": { "context": 200000 } },
        "gemini-3-pro": { "name": "Gemini 3 Pro", "limit": { "context": 1000000 } },
        "deepseek-v4-pro": { "name": "DeepSeek V4 Pro", "limit": { "context": 128000 } },
        "grok-4": { "name": "Grok 4", "limit": { "context": 128000 } }
      }
    }
  }
}

Then store your API key via /connect and select a model with /model. For Cursor, set provider URL to https://unlimited-ai-free.pages.dev with your key.

Direct HTTP — Any Language, Any Client

Your API key works with any HTTP client in any language. No SDK needed.

Go:

package main
import ("bytes"; "encoding/json"; "fmt"; "net/http")
func main() {
  body, _ := json.Marshal(map[string]any{
    "model": "gpt-5", "messages": []any{map[string]string{"role":"user","content":"Hello!"}},
  })
  req, _ := http.NewRequest("POST", "https://unlimited-ai-free.pages.dev/v1/chat/completions",
    bytes.NewReader(body))
  req.Header.Set("Authorization", "Bearer YOUR_KEY")
  req.Header.Set("Content-Type", "application/json")
  resp, _ := http.DefaultClient.Do(req)
  // read resp.Body...
}

Ruby:

require 'net/http'
uri = URI('https://unlimited-ai-free.pages.dev/v1/chat/completions')
req = Net::HTTP::Post.new(uri)
req['Authorization'] = 'Bearer YOUR_KEY'
req['Content-Type'] = 'application/json'
req.body = '{"model":"gpt-5","messages":[{"role":"user","content":"Hello!"}]}'
res = Net::HTTP.start(uri.host, uri.port, use_ssl: true) { |http| http.request(req) }
puts res.body

PHP:

<?php
$ch = curl_init('https://unlimited-ai-free.pages.dev/v1/chat/completions');
curl_setopt_array($ch, [
  CURLOPT_POST => true,
  CURLOPT_HTTPHEADER => ['Authorization: Bearer YOUR_KEY', 'Content-Type: application/json'],
  CURLOPT_POSTFIELDS => json_encode(['model'=>'gpt-5','messages'=>[['role'=>'user','content'=>'Hello!']]]),
  CURLOPT_RETURNTRANSFER => true,
]);
echo curl_exec($ch);

Legacy API — Still Works

The original custom endpoints (/api/chat, /api/merge, /api/search) continue to work and are fully supported. These are simpler than the standard-compatible endpoints and use a minimal JSON schema. All use the same model IDs, the same rate limit (45 req/min), and the same API key.

`POST /api/chat` — Simple Chat

The original chat endpoint. Accepts a single message string and model ID. Returns a JSON stream with {"data":"..."} frames or a full JSON response when stream=false.

POST/api/chat

cURL (streaming):

curl https://unlimited-ai-free.pages.dev/api/chat \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_KEY" \
  -d '{
    "model": "gpt-5",
    "message": "Hello!",
    "stream": true
  }'

Python (streaming):

import requests, json
r = requests.post('https://unlimited-ai-free.pages.dev/api/chat',
    headers={'Authorization': 'Bearer YOUR_KEY', 'Content-Type': 'application/json'},
    json={'model': 'gpt-5', 'message': 'Hello!', 'stream': True},
    stream=True)
for line in r.iter_lines():
    if line: print(line.decode())

Request body fields:

Field	Type	Required	Description
`model`	string	Yes	Any model ID from the table
`message`	string	Yes	Your prompt text
`stream`	boolean	No	Default `true`
`system`	string	No	Custom instructions
`memoryToken`	string	No	Conversation context token
`effort`	string	No	`low`, `medium`, `high`

`POST /api/merge` — Merge AI

Send the same prompt to 2-3 models simultaneously and get their responses merged. Requires a models array instead of a single model ID.

POST/api/merge

cURL:

curl https://unlimited-ai-free.pages.dev/api/merge \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_KEY" \
  -d '{
    "models": ["gpt-5-mini", "claude-sonnet-4-6", "deepseek-v4-flash"],
    "message": "Explain quantum computing in 3 sentences."
  }'

Request body fields:

Field	Type	Required	Description
`models`	array	Yes	2-3 model IDs (1-4 also accepted)
`message`	string	Yes	Your prompt text
`stream`	boolean	No	Default `true`
`system`	string	No	Custom instructions

The merge endpoint counts each model as a separate request toward the rate limit (e.g., merging 3 models counts as 3 requests). The merge endpoint also injects a default models array if one is not provided — using all available models.

`POST /api/search` — Web Search

Perform a web search and get AI-generated results with cited sources. The same model receives the search results as context and generates a response.

POST/api/search

cURL:

curl https://unlimited-ai-free.pages.dev/api/search \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_KEY" \
  -d '{
    "model": "gpt-5-online",
    "message": "Latest AI news 2026"
  }'

Request body fields:

Field	Type	Required	Description
`model`	string	Yes	Model ID with web search support
`message`	string	Yes	Your search query
`stream`	boolean	No	Default `true`

Utility Endpoints

GET /api/key — Generate a new API key bound to your current IP address. No authentication required. Returns a JSON object with the key string, creation timestamp, and rate limit info. Keys are valid for as long as your IP does not change.

GET /api/usage — Check usage stats for your API key. Requires Authorization: Bearer YOUR_KEY header. Returns request count and remaining quota within the current rate limit window.

GET /v1/models — List all available models with their provider mappings. Returns a JSON array compatible with both OpenAI and Anthropic model listing formats. No streaming, requires API key.

GET /status — Health check endpoint. No authentication required. Returns {"status":"ok"} if the service is operational. Use this for uptime monitoring.

API Endpoint Quick Reference

All endpoints are rate-limited to 45 req/min per IP. The same model IDs work across all endpoints.

Endpoint	Compatible With	Auth Header	Streaming	Use Case
`POST /v1/chat/completions`	OpenAI SDK / tools	`Authorization: Bearer KEY`	Yes	Chat, tools, vision (text-only)
`POST /v1/messages`	Anthropic SDK / tools	`x-api-key: KEY`	Yes	Chat with Anthropic schema
`POST /api/chat`	Custom (legacy)	`Authorization: Bearer KEY`	Yes	Simple chat, one message at a time
`POST /api/merge`	Custom	`Authorization: Bearer KEY`	Yes	Merge 2-3 models
`POST /api/search`	Custom	`Authorization: Bearer KEY`	Yes	Web search with citations
`POST /api/upload`	Custom	None (upload)	No	Upload file (max 2 MB, no images)
`GET /api/files/:id`	Custom	None	No	Retrieve uploaded file
`GET /v1/models`	OpenAI / Anthropic	`Authorization: Bearer KEY`	No	List available models
`GET /api/key`	Custom	None (browser)	No	Generate a new API key
`GET /api/usage`	Custom	`Authorization: Bearer KEY`	No	Check real-time request count (requests/minute per IP)
`GET /api/active`	Custom	None	No	Active user count (last 60s)
`GET /status`	Custom	None	No	Health check

The effort parameter (low/medium/high) works with GPT-5 series models. The tools parameter works with OpenAI-compatible models that support function calling. All streaming endpoints use Server-Sent Events (SSE) with data: frames and a final data: {"done":true} frame. File upload via POST /api/upload accepts files up to 2 MB — images are not supported. Uploaded file content is resolved server-side when you reference the URL in a chat message (text files are inlined up to 50K chars; binary files appear as links). GET /api/active returns the number of active users in the last 60 seconds. Auto-scroll is built into both desktop and mobile UIs — scroll up to stop following AI output; a down-arrow button appears for easy return.

All Available Models

Use any of these model IDs with /v1/chat/completions (OpenAI), /v1/messages (Anthropic), or the original /api/chat endpoint. Works with any SDK or raw HTTP.

Model IDs are internal routing aliases — they map to a specific version or configuration of each provider's model and may not correspond to official public model names. The provider column indicates which company's API the request is routed to.

Model ID	Provider	Context	Notes
`gpt-5`	OpenAI	128K	Flagship
`gpt-5-1`	OpenAI	128K	Tier 1
`gpt-5-3`	OpenAI	128K	Tier 3
`gpt-5-4`	OpenAI	128K	Tier 4
`gpt-5-5`	OpenAI	128K	Highest tier
`gpt-5-mini`	OpenAI	128K	Fast, cheap
`gpt-5-nano`	OpenAI	128K	Fastest GPT
`gpt-5-online`	OpenAI	128K	Web search enabled
`claude-opus-4-8`	Anthropic	200K	Latest Opus
`claude-opus-4-7`	Anthropic	200K	Best reasoning
`claude-opus-4-6`	Anthropic	200K	Opus tier
`claude-opus-4-5`	Anthropic	200K	Opus tier
`claude-opus-4-1`	Anthropic	200K	Opus tier
`claude-sonnet-4-6`	Anthropic	200K	Fast, balanced
`claude-sonnet-4`	Anthropic	200K	Sonnet base
`google-2.5-pro`	Google	1M	Very long context
`gemini-3-pro`	Google	1M	Latest Gemini
`gemini-3-1-pro`	Google	1M	Gemini 3.1
`gemini-2.5-flash`	Google	1M	Fast Gemini
`deepseek-v4-pro`	DeepSeek	128K	Best DeepSeek
`deepseek-v4-flash`	DeepSeek	128K	Fast DeepSeek
`deepseek-v3`	DeepSeek	128K	Previous gen
`deepseek-r1`	DeepSeek	128K	Reasoning model
`grok-4`	xAI	128K	xAI flagship
`qwen-3-max`	Alibaba	128K	Best Qwen
`qwen-qwq-32b`	Alibaba	128K	Reasoning Qwen
`deepinfra-kimi-k2`	DeepInfra	128K	Kimi model
`llama-3-3-70b-versatile`	Meta	128K	Open-weight Llama

Trust & Privacy

Be aware of what this is. This is a personal hobby project run by an anonymous individual — not a company, not a professional platform. There is no ToS and no legal entity backing it. You have no contractual protection. Please treat it accordingly.

Why was this made? AI subscriptions are expensive — ChatGPT Plus, Claude Pro, Gemini Advanced, and others each cost $20+/month. The operator knows that many people cannot afford these subscriptions, cannot justify multiple $20+/month bills, or simply do not want to lock themselves into yet another recurring payment for something they use occasionally. This service exists so that anyone with an internet connection can access the best AI models regardless of their financial situation. It is a utility, not a business — built because the operator believes access to capable AI should not be gated by the ability to pay for multiple subscriptions.

Why anonymous? Running a public proxy to paid APIs can attract unwanted attention. Anonymity protects the operator and keeps the service online. This is a trade-off: it means there is no legal entity to hold accountable, but it also means there is no target for legal pressure that could shut the service down.

How are models accessed? The operator pays for official API access to OpenAI, Anthropic, Google, xAI, DeepSeek, Alibaba, DeepInfra, and Meta. All responses come from official provider APIs — nothing is reverse-engineered or unauthorized. Model IDs are internal routing aliases; see the table note above.

What about my data? The worker code does not log, store, or inspect prompts beyond forwarding them. The upstream gateway is private infrastructure configured not to log or persist requests. The operator does not sell, rent, license, or share user data with any third party — there is no data collection infrastructure, no analytics database, no advertising partnership, no data broker relationship, and no marketing list. There is nothing to sell because nothing is collected. You have no way to independently verify the gateway's behavior — that is the honest limitation.

No user API keys needed. The infrastructure key is free and scoped to your IP.

Rate limited to 45 requests/min per IP to prevent abuse and keep the service sustainable.

Risk by use case: Casual chat and coding help — low to moderate risk. Business documents, legal, medical, proprietary code, or production API integrations — very high risk. Use accordingly.

Malware risk: Any interaction — visiting the page or submitting a prompt — could theoretically deliver malware if the upstream gateway or an AI provider were compromised or malicious. The operator states this does not happen but cannot prove it. The frontend is a static HTML page with no third-party scripts, no download buttons, no executable payloads, no file uploads, no hidden iframes, and no redirect chains. You can verify this by inspecting the page source and monitoring network traffic in your browser's developer tools. There is no mechanism on this site to deliver a file to your device — the site does not host or serve any downloadable content. The only theoretical vector would be malicious content injected into the AI response stream, which would require the upstream gateway or an AI provider to be compromised. This risk is inherent to any service that proxies AI responses. Use at your own risk.

Credits: Not necessary, but appreciated. The operator doesn't require credit or attribution. If you find the service useful, tell someone about it — that's more meaningful than a credit line.

How is this funded? Entirely out of pocket by the operator. There are no advertisements, no data sales, no subscription fees, no premium tiers, no pay-per-use charges, no referral programs, no affiliate links, and no venture capital investment. The operator explicitly refuses donations (see the privacy statement, Section 13.1) — this is a deliberate choice to keep the service free of any financial dependency, obligation, or expectation from users or investors. The operator pays for: AI provider API usage fees (OpenAI, Anthropic, Google, xAI, DeepSeek, Alibaba, DeepInfra, Meta — each at commercial per-token rates), upstream gateway server hosting (rented VPS in a commercial data center), domain registration, and supporting infrastructure. These costs scale with user traffic — every new user who discovers the service and begins using it regularly increases the monthly bill. There is no revenue stream to offset this growth. There is no business model, no sustainability plan, no reserve fund, and no succession plan. This is a hobby project that the operator maintains because they find it interesting and useful. It will continue as long as it remains both affordable and interesting, and it will stop without ceremony when either condition fails. The operator has no intention of monetizing the service — not through ads, not through data sales, not through donations, not through subscriptions — because monetization would change the nature of the project from a hobby to an obligation. If the service becomes too expensive to maintain, the operator will shut it down rather than add payment infrastructure, sell user data, or display advertisements. Use it while it lasts, and do not build dependencies on its continued existence.

Read the full Privacy & Data Handling Statement →