One base URL. Every model. 80% cheaper.

Connect Any App in 3 Steps

Works with any app that supports OpenAI or OpenAI Compatible connections. Three small changes and you are live.

https://api.freeaiapikey.com/v1

Example: Python (OpenAI SDK)

from openai import OpenAI

client = OpenAI(
    base_url="https://api.freeaiapikey.com/v1",  # change this
    api_key="your-api-key-here"               # your API key
)

response = client.chat.completions.create(
    model="openai/gpt-5",  # any model from /models
    messages=[{"role": "user", "content": "Hello!"}]
)

Example: Python (Anthropic SDK)

We fully support native Anthropic SDKs and prompt caching.

from anthropic import Anthropic

client = Anthropic(
    base_url="https://api.freeaiapikey.com",  # no /v1
    api_key="your-api-key-here"           # your API key
)

response = client.messages.create(
    model="anthropic/claude-sonnet-4.5",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hello!"}]
)

Example: cURL

curl https://api.freeaiapikey.com/v1/chat/completions \
  -H "Authorization: Bearer your-api-key-here" \
  -H "Content-Type: application/json" \
  -d '{"model": "openai/gpt-5", "messages": [{"role": "user", "content": "Hello!"}]}'

Integrations

Our API works with any tool that supports OpenAI-compatible endpoints. Pick yours.

curl -sL https://freeaiapikey.com/claude-code-setup.sh | bash

irm https://freeaiapikey.com/claude-code-setup.ps1 | iex

{
  "env": {
    "ANTHROPIC_API_KEY": "<your FreeAIapiKey>",
    "ANTHROPIC_AUTH_TOKEN": "",
    "ANTHROPIC_BASE_URL": "https://api.freeaiapikey.com"
  }
}

curl -sL https://freeaiapikey.com/codex-setup.sh | bash

irm https://freeaiapikey.com/codex-setup.ps1 | iex

npm install -g @openai/codex

model = "openai/gpt-5"
model_provider = "freeaiapikey"
web_search = "disabled"
model_context_window = 128000

[features]
multi_agent = false

[model_providers.freeaiapikey]
name = "FreeAIAPIKey"
base_url = "https://api.freeaiapikey.com/v1"
env_key = "FREEAIAPIKEY_API_KEY"
wire_api = "responses"

export FREEAIAPIKEY_API_KEY="your-api-key"

$env:FREEAIAPIKEY_API_KEY="your-api-key"

codex "your prompt here"

curl -sL https://freeaiapikey.com/cline-setup.sh | bash

irm https://freeaiapikey.com/cline-setup.ps1 | iex

cline --thinking high
# Options: none | low | medium | high | xhigh

curl -sL https://freeaiapikey.com/opencode-setup.sh | bash

irm https://freeaiapikey.com/opencode-setup.ps1 | iex

opencode run --variant xhigh "your prompt"
# Options: low | medium | high | xhigh | max

curl -sL https://freeaiapikey.com/kilocode-setup.sh | bash

irm https://freeaiapikey.com/kilocode-setup.ps1 | iex

kilo run --variant xhigh "your prompt"
# Options: low | medium | high | xhigh | max

curl -sL https://freeaiapikey.com/hermes-setup.sh | bash

irm https://freeaiapikey.com/hermes-setup.ps1 | iex

hermes chat --reasoning high
# Options: none | minimal | low | medium | high | xhigh | max | ultra

curl -sL https://freeaiapikey.com/openclaw-setup.sh | bash

irm https://freeaiapikey.com/openclaw-setup.ps1 | iex

openclaw chat --thinking high
# Options: none | minimal | low | medium | high | xhigh | max | ultra

curl -fsSL https://app.factory.ai/cli | sh

irm https://app.factory.ai/cli | iex

{
  "custom_models": [{
    "model_display_name": "freeaiapikey",
    "model": "<model from /models>",
    "base_url": "https://api.freeaiapikey.com/v1",
    "api_key": "YOUR_API_KEY",
    "provider": "generic-chat-completion-api"
  }]
}

{
  "models": {
    "providers": {
      "custom": {
        "baseUrl": "https://api.freeaiapikey.com/v1",
        "apiKey": "YOUR_API_KEY",
        "api": "openai-completions"
      }
    }
  }
}

Advanced Configuration

Detailed API reference and tool-specific integration guides below.

Quick Start

Our API is 100% OpenAI-compatible. Change the base URL and you are ready.

Three Things You Need

30-Second Setup

# Install: pip install openai
from openai import OpenAI

client = OpenAI(
    api_key="your-api-key-here",
    base_url="https://api.freeaiapikey.com/v1"
)

response = client.chat.completions.create(
    model="openai/gpt-5",
    messages=[{"role": "user", "content": "Hello!"}]
)

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

Authentication

Get Your API Key

1. Visit freeaiapikey.com/dashboard
2. Sign up or log in
3. Copy your API key from the dashboard

Using Your API Key

Include your API key in the Authorization header as a Bearer token:

curl https://api.freeaiapikey.com/v1/chat/completions \
  -H "Authorization: Bearer your-api-key-here" \
  -H "Content-Type: application/json" \
  -d '{"model": "openai/gpt-5", "messages": [{"role": "user", "content": "Hello!"}]}'

Base URL

All OpenAI-compatible API requests should be made to:

https://api.freeaiapikey.com/v1

Anthropic Endpoints

For native Anthropic SDKs, use the root domain. Prompt caching is fully supported automatically.

https://api.freeaiapikey.com

Endpoints

Chat Completions

Request Body

{
  "model": "openai/gpt-5",
  "messages": [
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "Hello!"}
  ],
  "temperature": 0.7,
  "max_tokens": 4096,
  "stream": false
}

Parameters

Response

{
  "id": "chatcmpl-xxx",
  "object": "chat.completion",
  "created": 1234567890,
  "model": "openai/gpt-5",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "Hello! How can I help you today?"
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 10,
    "completion_tokens": 20,
    "total_tokens": 30
  }
}

Responses API

The /v1/responses endpoint provides full support for the modern OpenAI Responses API wire format, powering agentic clients like Codex CLI as well as OpenAI SDK applications.

cURL (Non-Streaming)

curl https://api.freeaiapikey.com/v1/responses \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $FREEAIAPIKEY_API_KEY" \
  -d '{
    "model": "openai/gpt-5",
    "input": "Explain quantum computing in one sentence."
  }'

cURL (Streaming)

curl -N https://api.freeaiapikey.com/v1/responses \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $FREEAIAPIKEY_API_KEY" \
  -d '{
    "model": "openai/gpt-5",
    "input": "Write a short poem about code.",
    "stream": true
  }'

Supported Parameters

Tool Calling & Supported Types

The gateway supports four tool types in Responses requests:

• function: Standard OpenAI function declaration with name, description, and parameters JSON schema.
• namespace: Namespaced tool declarations grouped by domain or service.
• custom: Freeform tool contracts (e.g. apply_patch) with unstructured or custom schema definitions.
• local_shell: Shell execution tools used by CLI coding agents.

{
  "model": "openai/gpt-5",
  "input": "What is the weather in Tokyo?",
  "tools": [
    {
      "type": "function",
      "name": "get_weather",
      "description": "Get current weather conditions for a location.",
      "parameters": {
        "type": "object",
        "properties": {
          "location": {"type": "string", "description": "City name"}
        },
        "required": ["location"]
      }
    }
  ]
}

Constraints & Notes

Streaming Responses

Enable streaming by setting stream: true:

response = client.chat.completions.create(
    model="openai/gpt-5",
    messages=[{"role": "user", "content": "Write a poem"}],
    stream=True
)

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

Free Models

We offer a selection of free models so you can explore the API without spending credits. Free models are identified by the :free suffix in their model ID.

Verified Account Required

How to Use Free Models

Pass the full model ID (including the :free suffix) in your request:

response = client.chat.completions.create(
    model="openai/gpt-4.1-nano:free",
    messages=[{"role": "user", "content": "Hello!"}]
)

Rate Limits

Free models are subject to per-user rate limits to ensure fair access for everyone. These limits apply to all users without an active paid plan.

Paid plan subscribers are not subject to free-model rate limits. Upgrade to a plan for unlimited access.

Non-Priority Processing

Free model requests are processed on a non-priority basis. During periods of high server load, streaming responses on free models may experience slower token delivery compared to paid models. This is because paid requests are prioritized in the processing queue.

If you need consistent, low-latency responses, we recommend switching to a paid model or subscribing to a plan for priority processing.

Availability

Code Examples

Pick a language. Same response shape, same auth, same models.

from openai import OpenAI

client = OpenAI(
    api_key="your-api-key-here",
    base_url="https://api.freeaiapikey.com/v1"
)

# Basic completion
response = client.chat.completions.create(
    model="openai/gpt-5",
    messages=[{"role": "user", "content": "Hello!"}]
)
print(response.choices[0].message.content)

# Streaming
for chunk in client.chat.completions.create(
    model="openai/gpt-5",
    messages=[{"role": "user", "content": "Write a story"}],
    stream=True
):
    print(chunk.choices[0].delta.content or "", end="")

import OpenAI from 'openai';

const client = new OpenAI({
  apiKey: 'your-api-key-here',
  baseURL: 'https://api.freeaiapikey.com/v1',
});

const response = await client.chat.completions.create({
  model: 'gpt-5',
  messages: [{ role: 'user', content: 'Hello!'' }],
});

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

curl https://api.freeaiapikey.com/v1/chat/completions \
  -H "Authorization: Bearer your-api-key-here" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model="openai/gpt-5",
    openai_api_key="your-api-key-here",
    openai_api_base="https://api.freeaiapikey.com/v1"
)

response = llm.invoke("Hello!")
print(response.content)

Pricing

Pay as you go. No monthly fees, no minimum spend. See live pricing for every model.

How much do you save?

FAQ

General Questions

Which tool should I use?

• Claude Code: best for terminal-based coding
• Cline CLI: autonomous AI software engineer in your terminal
• OpenCode CLI: powerful open-source terminal AI workspace
• KiloCode CLI: fast terminal AI agent
• Hermes Agent: multi-modal AI agent with ultra-deep reasoning
• OpenClaw: best for multi-channel AI agents
• Roo Code / Kilo Code: best for VS Code users
• Codex CLI: best for the OpenAI ecosystem
• Droid CLI: best for Factory AI users
• n8n: best for workflow automation

Which model should I use?

• gpt-5: general purpose, best overall
• claude-opus-4.5: complex reasoning and coding
• claude-sonnet-4.5: fast and cost-efficient
• gemini-3: long context and multimodal
• deepseek-v3.2: code generation

Support