1interface ChatCompletionRequest {
2  model: string;              // e.g. "openai/gpt-4o"
3  messages: Message[];
4  stream?: boolean;
5  temperature?: number;       // 0-2, default 1
6  max_tokens?: number;
7  top_p?: number;             // 0-1
8  frequency_penalty?: number; // -2 to 2
9  presence_penalty?: number;  // -2 to 2
10  stop?: string | string[];
11  tools?: Tool[];
12  tool_choice?: ToolChoice;
13  response_format?: ResponseFormat;
14  seed?: number;
15
16  // MyRouter-specific
17  models?: string[];          // fallback model list
18  route?: "fallback";
19  provider?: ProviderPreferences;
20}
21
22interface Message {
23  role: "system" | "user" | "assistant" | "tool";
24  content: string | ContentPart[];
25  name?: string;
26  tool_calls?: ToolCall[];
27  tool_call_id?: string;
28}

1{
2  "model": "openai/gpt-4o",
3  "messages": [...],
4  "response_format": {
5    "type": "json_schema",
6    "json_schema": {
7      "name": "person",
8      "strict": true,
9      "schema": {
10        "type": "object",
11        "properties": {
12          "name": { "type": "string" },
13          "age": { "type": "integer" }
14        },
15        "required": ["name", "age"],
16        "additionalProperties": false
17      }
18    }
19  }
20}

1curl http://148.153.38.18:3010/v1/generation?id=$GENERATION_ID \
2  -H "Authorization: Bearer $MYROUTER_API_KEY"

1from openai import OpenAI
2
3client = OpenAI(
4    base_url="http://148.153.38.18:3010/v1",
5    api_key="$MYROUTER_API_KEY",
6)
7
8response = client.chat.completions.create(
9    model="openai/gpt-4o",
10    messages=[
11        {"role": "user", "content": "Hello, MyRouter!"}
12    ],
13)
14
15print(response.choices[0].message.content)

1pip install openai

1from openai import OpenAI
2
3client = OpenAI(
4    base_url="http://148.153.38.18:3010/v1",
5    api_key=os.environ["MYROUTER_API_KEY"],
6)
7
8response = client.chat.completions.create(
9    model="openai/gpt-4o",
10    messages=[
11        {"role": "user", "content": "Hello!"}
12    ],
13)

1stream = client.chat.completions.create(
2    model="openai/gpt-4o",
3    messages=[
4        {"role": "user", "content": "Write a haiku"}
5    ],
6    stream=True,
7)
8
9for chunk in stream:
10    content = chunk.choices[0].delta.content
11    if content:
12        print(content, end="")

1: MYROUTER PROCESSING
2
3data: {"id":"chatcmpl-123","object":"chat.completion.chunk","choices":[{"index":0,"delta":{"role":"assistant","content":""},"finish_reason":null}]}
4
5data: {"id":"chatcmpl-123","object":"chat.completion.chunk","choices":[{"index":0,"delta":{"content":"The"},"finish_reason":null}]}
6
7data: {"id":"chatcmpl-123","object":"chat.completion.chunk","choices":[{"index":0,"delta":{"content":" capital"},"finish_reason":null}]}
8
9data: {"id":"chatcmpl-123","object":"chat.completion.chunk","choices":[],"usage":{"prompt_tokens":12,"completion_tokens":8,"total_tokens":20}}
10
11data: [DONE]

1stream = client.chat.completions.create(
2    model="openai/gpt-4o",
3    messages=[{"role": "user", "content": "Long story"}],
4    stream=True,
5)
6
7for chunk in stream:
8    content = chunk.choices[0].delta.content
9    if content and "stop_word" in content:
10        stream.close()  # Cancel the stream
11        break
12    print(content, end="")

1response = client.chat.completions.create(
2    model="openai/gpt-4o",
3    messages=[
4        {"role": "user", "content": "Tell me a joke"}
5    ],
6    temperature=0.9,
7    top_p=0.95,
8    frequency_penalty=0.5,
9    presence_penalty=0.3,
10    max_tokens=256,
11)

1response = client.chat.completions.create(
2    model="openai/gpt-4o",
3    messages=[
4        {"role": "user", "content": "What's the weather in Tokyo?"}
5    ],
6    tools=[
7        {
8            "type": "function",
9            "function": {
10                "name": "get_weather",
11                "description": "Get current weather",
12                "parameters": {
13                    "type": "object",
14                    "properties": {
15                        "location": {"type": "string"}
16                    },
17                    "required": ["location"]
18                }
19            }
20        }
21    ],
22    tool_choice="auto",
23)

1{
2  "response_format": {
3    "type": "json_schema",
4    "json_schema": {
5      "name": "analysis",
6      "strict": true,
7      "schema": {
8        "type": "object",
9        "properties": {
10          "sentiment": {
11            "type": "string",
12            "enum": ["positive", "negative", "neutral"]
13          },
14          "confidence": { "type": "number" }
15        },
16        "required": ["sentiment", "confidence"],
17        "additionalProperties": false
18      }
19    }
20  }
21}

1{
2  "error": {
3    "code": 401,
4    "message": "Invalid API key provided.",
5    "metadata": {
6      "provider_name": "openai"
7    }
8  }
9}

1{
2  "error": {
3    "code": 403,
4    "message": "Input flagged by content moderation",
5    "metadata": {
6      "reasons": ["violence", "self-harm"],
7      "flagged_input": "...",
8      "provider_name": "openai",
9      "model_slug": "gpt-4o"
10    }
11  }
12}

1# Debug mode — streaming only
2stream = client.chat.completions.create(
3    model="openai/gpt-4o",
4    messages=[{"role": "user", "content": "Hi"}],
5    stream=True,
6    extra_body={
7        "debug": {"echo_upstream_body": True}
8    },
9)
10
11for chunk in stream:
12    if hasattr(chunk, "debug"):
13        print("Debug:", chunk.debug)
14    else:
15        content = chunk.choices[0].delta.content
16        if content:
17            print(content, end="")

1import time
2from openai import OpenAI, RateLimitError
3
4client = OpenAI(
5    base_url="http://148.153.38.18:3010/v1",
6    api_key="sk-myrouter-xxxx",
7)
8
9for attempt in range(3):
10    try:
11        response = client.chat.completions.create(
12            model="openai/gpt-4o",
13            messages=[{"role": "user", "content": "Hi"}],
14        )
15        break
16    except RateLimitError:
17        time.sleep(2 ** attempt)

1curl http://148.153.38.18:3010/v1/key \
2  -H "Authorization: Bearer $MYROUTER_API_KEY"

1{
2  "data": {
3    "label": "Production Key",
4    "limit": 100.0,
5    "limit_remaining": 74.5,
6    "limit_reset": "monthly",
7    "usage": 25.5,
8    "usage_daily": 3.2,
9    "usage_weekly": 12.8,
10    "usage_monthly": 25.5,
11    "is_free_tier": false
12  }
13}

1X-RateLimit-Limit-Requests: 60
2X-RateLimit-Limit-Tokens: 1000000
3X-RateLimit-Remaining-Requests: 59
4X-RateLimit-Remaining-Tokens: 999500
5X-RateLimit-Reset-Requests: 1s
6X-RateLimit-Reset-Tokens: 30ms

1tools = [
2    {
3        "type": "function",
4        "function": {
5            "name": "get_weather",
6            "description": "Get current weather for a city",
7            "parameters": {
8                "type": "object",
9                "properties": {
10                    "city": {"type": "string"},
11                    "unit": {
12                        "type": "string",
13                        "enum": ["celsius", "fahrenheit"]
14                    }
15                },
16                "required": ["city"]
17            }
18        }
19    }
20]
21
22response = client.chat.completions.create(
23    model="openai/gpt-4o",
24    messages=[
25        {"role": "user", "content": "Weather in Tokyo?"}
26    ],
27    tools=tools,
28    tool_choice="auto",
29)

1messages = [{"role": "user", "content": "Weather in Tokyo?"}]
2
3while True:
4    response = client.chat.completions.create(
5        model="openai/gpt-4o",
6        messages=messages,
7        tools=tools,
8    )
9    msg = response.choices[0].message
10    messages.append(msg)
11
12    if not msg.tool_calls:
13        print(msg.content)
14        break
15
16    for call in msg.tool_calls:
17        result = run_tool(call.function.name, call.function.arguments)
18        messages.append({
19            "role": "tool",
20            "tool_call_id": call.id,
21            "content": result,
22        })

1{
2  "choices": [{
3    "message": {
4      "role": "assistant",
5      "content": null,
6      "tool_calls": [{
7        "id": "call_abc123",
8        "type": "function",
9        "function": {
10          "name": "get_weather",
11          "arguments": "{\"city\":\"Tokyo\"}"
12        }
13      }]
14    },
15    "finish_reason": "tool_calls"
16  }]
17}

1response = client.chat.completions.create(
2    model="openai/gpt-4o",
3    messages=[
4        {"role": "system", "content": "Output JSON only."},
5        {"role": "user", "content": "List 3 capitals."}
6    ],
7    response_format={"type": "json_object"},
8)
9
10import json
11data = json.loads(response.choices[0].message.content)

1response = client.chat.completions.create(
2    model="openai/gpt-4o",
3    messages=[
4        {"role": "user", "content": "Extract: Alice is 30 years old."}
5    ],
6    response_format={
7        "type": "json_schema",
8        "json_schema": {
9            "name": "person",
10            "strict": True,
11            "schema": {
12                "type": "object",
13                "properties": {
14                    "name": {"type": "string"},
15                    "age": {"type": "integer"}
16                },
17                "required": ["name", "age"],
18                "additionalProperties": False
19            }
20        }
21    }
22)

1{
2  "type": "json_schema",
3  "json_schema": {
4    "name": "analysis",
5    "strict": true,
6    "schema": {
7      "type": "object",
8      "properties": {
9        "sentiment": {
10          "type": "string",
11          "enum": ["positive", "negative", "neutral"]
12        },
13        "score": { "type": "number" },
14        "keywords": {
15          "type": "array",
16          "items": { "type": "string" }
17        }
18      },
19      "required": ["sentiment", "score", "keywords"],
20      "additionalProperties": false
21    }
22  }
23}

1response = client.chat.completions.create(
2    model="openai/gpt-4o",
3    messages=[
4        {
5            "role": "user",
6            "content": [
7                {"type": "text", "text": "What is in this image?"},
8                {
9                    "type": "image_url",
10                    "image_url": {
11                        "url": "https://example.com/cat.jpg"
12                    }
13                }
14            ]
15        }
16    ],
17)

1import base64
2
3with open("cat.jpg", "rb") as f:
4    b64 = base64.b64encode(f.read()).decode()
5
6response = client.chat.completions.create(
7    model="openai/gpt-4o",
8    messages=[{
9        "role": "user",
10        "content": [
11            {"type": "text", "text": "Describe this."},
12            {
13                "type": "image_url",
14                "image_url": {
15                    "url": f"data:image/jpeg;base64,{b64}"
16                }
17            }
18        ]
19    }]
20)

1{
2  "messages": [{
3    "role": "user",
4    "content": [
5      { "type": "text", "text": "Compare these two images." },
6      { "type": "image_url",
7        "image_url": { "url": "https://example.com/a.png" }},
8      { "type": "image_url",
9        "image_url": { "url": "https://example.com/b.png" }}
10    ]
11  }]
12}

1response = client.chat.completions.create(
2    model="openai/o1",
3    messages=[
4        {"role": "user", "content": "Prove that sqrt(2) is irrational."}
5    ],
6    extra_body={
7        "reasoning": {
8            "effort": "high",
9            "exclude": False
10        }
11    }
12)
13
14print(response.choices[0].message.reasoning)
15print(response.choices[0].message.content)

1{
2  "model": "anthropic/claude-opus-4",
3  "messages": [...],
4  "reasoning": {
5    "max_tokens": 4096,
6    "exclude": false
7  }
8}

1{
2  "choices": [{
3    "message": {
4      "role": "assistant",
5      "reasoning": "First, let me consider...",
6      "content": "The answer is..."
7    }
8  }],
9  "usage": {
10    "prompt_tokens": 25,
11    "completion_tokens": 142,
12    "reasoning_tokens": 1024,
13    "total_tokens": 1191
14  }
15}

1{
2  "model": "anthropic/claude-sonnet-4",
3  "messages": [
4    {
5      "role": "system",
6      "content": [{
7        "type": "text",
8        "text": "Very long system prompt...",
9        "cache_control": { "type": "ephemeral" }
10      }]
11    },
12    { "role": "user", "content": "Question 1" }
13  ]
14}

1{
2  "usage": {
3    "prompt_tokens": 1523,
4    "completion_tokens": 87,
5    "total_tokens": 1610,
6    "prompt_tokens_details": {
7      "cached_tokens": 1400
8    },
9    "cache_creation_input_tokens": 0,
10    "cache_read_input_tokens": 1400
11  }
12}

1# OpenAI and DeepSeek cache automatically.
2# Just reuse the same prompt prefix across requests.
3for question in questions:
4    response = client.chat.completions.create(
5        model="openai/gpt-4o",
6        messages=[
7            {"role": "system", "content": LONG_SYSTEM_PROMPT},
8            {"role": "user", "content": question}
9        ],
10    )

1response = client.chat.completions.create(
2    model="openai/gpt-4o:online",
3    messages=[
4        {"role": "user", "content": "Latest news on AI?"}
5    ],
6)
7
8for citation in response.choices[0].message.annotations:
9    print(citation["url_citation"]["url"])

1{
2  "model": "openai/gpt-4o",
3  "messages": [...],
4  "plugins": [{
5    "id": "web",
6    "max_results": 5,
7    "search_prompt": "Search for recent news about:"
8  }]
9}

1{
2  "choices": [{
3    "message": {
4      "role": "assistant",
5      "content": "...",
6      "annotations": [
7        {
8          "type": "url_citation",
9          "url_citation": {
10            "url": "https://example.com/article",
11            "title": "Article title",
12            "content": "Snippet excerpt..."
13          }
14        }
15      ]
16    }
17  }]
18}

1response = client.embeddings.create(
2    model="openai/text-embedding-3-small",
3    input="The quick brown fox jumps over the lazy dog",
4)
5
6embedding = response.data[0].embedding
7print(f"Dimensions: {len(embedding)}")

1response = client.embeddings.create(
2    model="openai/text-embedding-3-small",
3    input=[
4        "First document text",
5        "Second document text",
6        "Third document text",
7    ],
8)
9
10for item in response.data:
11    print(f"[{item.index}] dims={len(item.embedding)}")

1import numpy as np
2
3def cosine_similarity(a, b):
4    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))
5
6# Embed the query
7query_resp = client.embeddings.create(
8    model="openai/text-embedding-3-small",
9    input="How to deploy a web app?",
10)
11query_vec = query_resp.data[0].embedding
12
13# Compare against stored document embeddings
14for doc in documents:
15    score = cosine_similarity(query_vec, doc["embedding"])
16    print(f"{score:.4f} — {doc['title']}")

1response = client.chat.completions.create(
2    model="openai/gpt-4o",
3    messages=[
4        {
5            "role": "system",
6            "content": "You are a helpful assistant."
7        },
8        {
9            "role": "user",
10            "content": "What is the capital of France?"
11        }
12    ],
13    temperature=0.7,
14    max_tokens=256,
15    extra_body={
16        "provider": {
17            "order": ["openai", "azure"],
18            "allow_fallbacks": True,
19        }
20    },
21)

1{
2  "id": "chatcmpl-abc123",
3  "object": "chat.completion",
4  "created": 1700000000,
5  "model": "openai/gpt-4o",
6  "choices": [
7    {
8      "index": 0,
9      "message": {
10        "role": "assistant",
11        "content": "The capital of France is Paris."
12      },
13      "finish_reason": "stop"
14    }
15  ],
16  "usage": {
17    "prompt_tokens": 25,
18    "completion_tokens": 8,
19    "total_tokens": 33
20  }
21}

1response = client.completions.create(
2    model="openai/gpt-3.5-turbo-instruct",
3    prompt="Once upon a time,",
4    max_tokens=128,
5    temperature=0.8,
6)
7
8print(response.choices[0].text)

1{
2  "id": "cmpl-abc123",
3  "object": "text_completion",
4  "created": 1700000000,
5  "model": "openai/gpt-3.5-turbo-instruct",
6  "choices": [{
7    "text": " there was a brave knight...",
8    "index": 0,
9    "finish_reason": "length"
10  }],
11  "usage": {
12    "prompt_tokens": 5,
13    "completion_tokens": 128,
14    "total_tokens": 133
15  }
16}

1curl http://148.153.38.18:3010/v1/models \
2  -H "Authorization: Bearer $MYROUTER_API_KEY"

1{
2  "object": "list",
3  "data": [
4    {
5      "id": "openai/gpt-4o",
6      "name": "GPT-4o",
7      "created": 1700000000,
8      "description": "Most capable GPT-4 model...",
9      "context_length": 128000,
10      "pricing": {
11        "prompt": "0.0000025",
12        "completion": "0.00001",
13        "request": "0",
14        "image": "0.003613"
15      },
16      "architecture": {
17        "tokenizer": "GPT",
18        "instruct_type": "chatml",
19        "input_modalities": ["text", "image"],
20        "output_modalities": ["text"]
21      },
22      "top_provider": {
23        "context_length": 128000,
24        "max_completion_tokens": 16384,
25        "is_moderated": true
26      },
27      "supported_parameters": [
28        "temperature", "top_p", "max_tokens",
29        "tools", "response_format", "seed"
30      ]
31    },
32    {
33      "id": "anthropic/claude-sonnet-4",
34      "name": "Claude Sonnet 4",
35      "created": 1700000000,
36      "context_length": 200000,
37      "pricing": {
38        "prompt": "0.000003",
39        "completion": "0.000015"
40      },
41      "architecture": {
42        "tokenizer": "Claude",
43        "input_modalities": ["text", "image"],
44        "output_modalities": ["text"]
45      }
46    }
47  ]
48}

1curl http://148.153.38.18:3010/v1/models/openai/gpt-4o/endpoints \
2  -H "Authorization: Bearer $MYROUTER_API_KEY"

1{
2  "data": {
3    "id": "openai/gpt-4o",
4    "name": "GPT-4o",
5    "endpoints": [
6      {
7        "provider_name": "OpenAI",
8        "model_id": "openai/gpt-4o",
9        "context_length": 128000,
10        "max_completion_tokens": 16384,
11        "pricing": {
12          "prompt": "0.0000025",
13          "completion": "0.00001"
14        },
15        "quantization": "fp16",
16        "supported_parameters": [
17          "temperature", "top_p", "tools"
18        ],
19        "latency_last_30m": {
20          "p50": 0.45,
21          "p75": 0.62,
22          "p90": 0.91,
23          "p99": 1.85
24        },
25        "throughput_last_30m": {
26          "p50": 85,
27          "p75": 72,
28          "p90": 55,
29          "p99": 32
30        },
31        "uptime_last_30m": 99.8,
32        "status": 0
33      },
34      {
35        "provider_name": "Azure",
36        "model_id": "openai/gpt-4o",
37        "context_length": 128000,
38        "pricing": {
39          "prompt": "0.0000027",
40          "completion": "0.000011"
41        },
42        "quantization": "fp16"
43      }
44    ]
45  }
46}

1curl http://148.153.38.18:3010/v1/providers \
2  -H "Authorization: Bearer $MYROUTER_API_KEY"

1{
2  "data": [
3    {
4      "name": "OpenAI",
5      "slug": "openai",
6      "headquarters": "US",
7      "datacenters": ["US", "IE"],
8      "privacy_policy_url": "https://openai.com/privacy",
9      "terms_of_service_url": "https://openai.com/terms",
10      "status_page_url": "https://status.openai.com"
11    },
12    {
13      "name": "Anthropic",
14      "slug": "anthropic",
15      "headquarters": "US",
16      "datacenters": ["US"],
17      "privacy_policy_url": "https://anthropic.com/privacy"
18    },
19    {
20      "name": "Google",
21      "slug": "google",
22      "headquarters": "US",
23      "datacenters": ["US", "EU", "APAC"]
24    },
25    {
26      "name": "DeepSeek",
27      "slug": "deepseek",
28      "headquarters": "CN",
29      "datacenters": ["CN", "US"]
30    }
31  ]
32}

1curl "http://148.153.38.18:3010/v1/generation?id=gen-abc123" \
2  -H "Authorization: Bearer $MYROUTER_API_KEY"

1{
2  "data": {
3    "id": "gen-abc123",
4    "model": "openai/gpt-4o",
5    "provider": "openai",
6    "created_at": "2026-04-07T10:00:00Z",
7    "tokens_prompt": 1523,
8    "tokens_completion": 87,
9    "native_tokens_prompt": 1512,
10    "native_tokens_completion": 89,
11    "cache_discount": 0.72,
12    "total_cost": 0.00234,
13    "latency_ms": 1840,
14    "finish_reason": "stop",
15    "streamed": true
16  }
17}

1curl http://148.153.38.18:3010/v1/credits \
2  -H "Authorization: Bearer $MYROUTER_API_KEY"

1{
2  "data": {
3    "total_credits": 100.00,
4    "total_usage": 23.45,
5    "rate_limit": {
6      "requests": 600,
7      "interval": "1m"
8    },
9    "is_free_tier": false
10  }
11}

1response = client.images.generate(
2    model="black-forest-labs/flux-1.1-pro",
3    prompt="A cyberpunk cat in neon lights",
4    size="1024x1024",
5    n=1,
6)
7
8print(response.data[0].url)

1{
2  "created": 1700000000,
3  "data": [
4    {
5      "url": "https://cdn.myrouter.ai/img/abc.png",
6      "revised_prompt": "A cyberpunk cat under neon lights..."
7    }
8  ]
9}

1response = client.audio.speech.create(
2    model="openai/tts-1-hd",
3    voice="alloy",
4    input="The quick brown fox jumps over the lazy dog.",
5    response_format="mp3",
6    speed=1.0,
7)
8
9response.stream_to_file("output.mp3")

1with open("audio.mp3", "rb") as f:
2    response = client.audio.transcriptions.create(
3        model="openai/whisper-1",
4        file=f,
5        language="en",
6        response_format="json",
7        temperature=0,
8    )
9
10print(response.text)

1{
2  "task": "transcribe",
3  "language": "english",
4  "duration": 12.5,
5  "text": "The quick brown fox jumps over the lazy dog.",
6  "segments": [
7    {
8      "id": 0,
9      "start": 0.0,
10      "end": 3.2,
11      "text": "The quick brown fox",
12      "avg_logprob": -0.23
13    }
14  ]
15}

1response = client.embeddings.create(
2    model="openai/text-embedding-3-small",
3    input="The quick brown fox jumps over the lazy dog",
4    encoding_format="float",
5)
6
7print(response.data[0].embedding[:5])
8# [0.0023, -0.0091, 0.0152, ...]

1{
2  "object": "list",
3  "data": [
4    {
5      "object": "embedding",
6      "index": 0,
7      "embedding": [0.0023, -0.0091, 0.0152, ...]
8    }
9  ],
10  "model": "openai/text-embedding-3-small",
11  "usage": {
12    "prompt_tokens": 9,
13    "total_tokens": 9
14  }
15}

1import requests
2
3response = requests.post(
4    "http://148.153.38.18:3010/v1/rerank",
5    headers={"Authorization": "Bearer $MYROUTER_API_KEY"},
6    json={
7        "model": "cohere/rerank-v3.5",
8        "query": "What is the capital of France?",
9        "documents": [
10            "Paris is the capital of France.",
11            "Berlin is in Germany.",
12            "Tokyo is the capital of Japan.",
13        ],
14        "top_n": 2,
15        "return_documents": True,
16    },
17)
18print(response.json())

1{
2  "id": "rerank-abc123",
3  "results": [
4    {
5      "index": 0,
6      "relevance_score": 0.98,
7      "document": { "text": "Paris is the capital of France." }
8    },
9    {
10      "index": 2,
11      "relevance_score": 0.12,
12      "document": { "text": "Tokyo is the capital of Japan." }
13    }
14  ],
15  "meta": {
16    "billed_units": { "search_units": 1 }
17  }
18}

1from openai import OpenAI
2
3client = OpenAI(
4    base_url="http://148.153.38.18:3010/v1",
5    api_key="$MYROUTER_API_KEY",
6)

1import json
2from openai import OpenAI
3
4client = OpenAI(
5    base_url="http://148.153.38.18:3010/v1",
6    api_key="$MYROUTER_API_KEY",
7)
8
9tools = [{
10    "type": "function",
11    "function": {
12        "name": "get_weather",
13        "description": "Get current weather for a city",
14        "parameters": {
15            "type": "object",
16            "properties": {
17                "city": {"type": "string", "description": "City name"},
18                "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]},
19            },
20            "required": ["city"],
21        },
22    },
23}]
24
25def get_weather(city: str, unit: str = "celsius"):
26    return {"city": city, "temp": 22, "unit": unit, "condition": "Sunny"}
27
28messages = [{"role": "user", "content": "What's the weather in Tokyo?"}]
29
30resp = client.chat.completions.create(
31    model="openai/gpt-4o",
32    messages=messages,
33    tools=tools,
34    tool_choice="auto",
35)
36
37msg = resp.choices[0].message
38messages.append(msg)
39
40for call in msg.tool_calls or []:
41    args = json.loads(call.function.arguments)
42    result = get_weather(**args)
43    messages.append({
44        "role": "tool",
45        "tool_call_id": call.id,
46        "content": json.dumps(result),
47    })
48
49final = client.chat.completions.create(
50    model="openai/gpt-4o",
51    messages=messages,
52    tools=tools,
53)
54print(final.choices[0].message.content)

1from langchain_openai import ChatOpenAI
2
3llm = ChatOpenAI(
4    model="openai/gpt-4o",
5    base_url="http://148.153.38.18:3010/v1",
6    api_key="$MYROUTER_API_KEY",
7)

1from langchain_core.tools import tool
2from langchain_openai import ChatOpenAI
3
4@tool
5def get_weather(city: str, unit: str = "celsius") -> dict:
6    """Get current weather for a city."""
7    return {"city": city, "temp": 22, "unit": unit, "condition": "Sunny"}
8
9llm = ChatOpenAI(
10    model="openai/gpt-4o",
11    base_url="http://148.153.38.18:3010/v1",
12    api_key="$MYROUTER_API_KEY",
13)
14
15llm_with_tools = llm.bind_tools([get_weather])
16messages = [("user", "What's the weather in Tokyo?")]
17
18ai_msg = llm_with_tools.invoke(messages)
19messages.append(ai_msg)
20
21for call in ai_msg.tool_calls:
22    tool_msg = get_weather.invoke(call)
23    messages.append(tool_msg)
24
25final = llm_with_tools.invoke(messages)
26print(final.content)

1import { createOpenAI } from "@ai-sdk/openai";
2import { generateText } from "ai";
3
4const myrouter = createOpenAI({
5  baseURL: "http://148.153.38.18:3010/v1",
6  apiKey: process.env.MYROUTER_API_KEY,
7});
8
9const { text } = await generateText({
10  model: myrouter("openai/gpt-4o"),
11  prompt: "Hello",
12});

1import { createOpenAI } from "@ai-sdk/openai";
2import { generateText, tool } from "ai";
3import { z } from "zod";
4
5const myrouter = createOpenAI({
6  baseURL: "http://148.153.38.18:3010/v1",
7  apiKey: process.env.MYROUTER_API_KEY,
8});
9
10const { text, toolResults } = await generateText({
11  model: myrouter("openai/gpt-4o"),
12  maxSteps: 5, // multi-turn tool loop
13  prompt: "What's the weather in Tokyo?",
14  tools: {
15    get_weather: tool({
16      description: "Get current weather for a city",
17      parameters: z.object({
18        city: z.string().describe("City name"),
19        unit: z.enum(["celsius", "fahrenheit"]).optional(),
20      }),
21      execute: async ({ city, unit = "celsius" }) => ({
22        city,
23        temp: 22,
24        unit,
25        condition: "Sunny",
26      }),
27    }),
28  },
29});
30
31console.log(text);

1from llama_index.llms.openai_like import OpenAILike
2
3llm = OpenAILike(
4    model="openai/gpt-4o",
5    api_base="http://148.153.38.18:3010/v1",
6    api_key="$MYROUTER_API_KEY",
7    is_chat_model=True,
8    is_function_calling_model=True,
9)

1from llama_index.core.tools import FunctionTool
2from llama_index.core.agent import ReActAgent
3from llama_index.llms.openai_like import OpenAILike
4
5def get_weather(city: str, unit: str = "celsius") -> dict:
6    """Get current weather for a city."""
7    return {"city": city, "temp": 22, "unit": unit, "condition": "Sunny"}
8
9weather_tool = FunctionTool.from_defaults(fn=get_weather)
10
11llm = OpenAILike(
12    model="openai/gpt-4o",
13    api_base="http://148.153.38.18:3010/v1",
14    api_key="$MYROUTER_API_KEY",
15    is_chat_model=True,
16    is_function_calling_model=True,
17)
18
19agent = ReActAgent.from_tools([weather_tool], llm=llm, verbose=True)
20response = agent.chat("What's the weather in Tokyo?")
21print(response)

1{
2  "env": {
3    "ANTHROPIC_BASE_URL": "http://148.153.38.18:3010",
4    "ANTHROPIC_AUTH_TOKEN": "sk-myrouter-...",
5    "ANTHROPIC_MODEL": "anthropic/claude-sonnet-4-5",
6    "ANTHROPIC_SMALL_FAST_MODEL": "anthropic/claude-haiku-4-5"
7  }
8}

1{
2  "env": {
3    "ANTHROPIC_BASE_URL": "http://148.153.38.18:3010",
4    "ANTHROPIC_AUTH_TOKEN": "sk-myrouter-...",
5    "ANTHROPIC_MODEL": "deepseek/deepseek-v3",
6    "ANTHROPIC_SMALL_FAST_MODEL": "anthropic/claude-haiku-4-5"
7  }
8}

1# save the JSON above, then just launch
2claude
3
4# verify the active endpoint
5claude config list | grep ANTHROPIC_BASE_URL

1Cursor Settings → Models
2
31. Scroll to "OpenAI API Key"
42. Paste your MyRouter key:    sk-myrouter-...
53. Click "Override OpenAI Base URL"
64. Enter:                      http://148.153.38.18:3010/v1
75. Click "Verify"
86. Under "Model Names", click "+ Add model"
9   and add any MyRouter model id, e.g.:
10     - openai/gpt-4o
11     - anthropic/claude-sonnet-4-5
12     - deepseek/deepseek-v3
137. Enable the new model in the Models list.

1# In Cursor chat (⌘L / Ctrl+L)
2# pick the custom model from the model picker,
3# then send any prompt — a response confirms the
4# key and base URL are wired up correctly.
5
6> Explain this function in one sentence.

1{
2  "$schema": "https://opencode.ai/config.json",
3  "provider": {
4    "myrouter": {
5      "npm": "@ai-sdk/openai-compatible",
6      "name": "MyRouter",
7      "options": {
8        "baseURL": "http://148.153.38.18:3010/v1",
9        "apiKey": "{env:MYROUTER_API_KEY}"
10      },
11      "models": {
12        "openai/gpt-4o": { "name": "GPT-4o" },
13        "anthropic/claude-sonnet-4-5": { "name": "Claude Sonnet 4.5" },
14        "deepseek/deepseek-v3": { "name": "DeepSeek V3" }
15      }
16    }
17  }
18}

1export MYROUTER_API_KEY="sk-myrouter-..."
2
3# place opencode.json in project root or ~/.config/opencode/
4cd your-project
5opencode
6
7# pick myrouter/<model-id> in the model picker

1// openai/gpt-4o:
2//   input:  $2.50 / 1M tokens
3//   output: $10.00 / 1M tokens
4//
5// Request uses 1,500 input tokens and 500 output tokens:
6const cost =
7  (1500 / 1_000_000) * 2.50 +   // = $0.00375
8  (500  / 1_000_000) * 10.00;   // = $0.005
9// total: $0.00875

1curl https://api.myrouter.ai/v1/credits \
2  -H "Authorization: Bearer $MYROUTER_API_KEY"

1{
2  "model": "openai/gpt-4o",
3  "messages": [...],
4  "provider": {
5    "data_collection": "deny"
6  }
7}

1// Dashboard setting:
2//   Privacy > Enable zero-data-retention mode
3//
4// All logs are dropped immediately.
5// Generation stats endpoint will return 404.