This site provides OpenAI-compatible, Anthropic (Claude)-compatible, Google and OpenRouter relay APIs, plus site-native utility APIs (Google Search / News, chat, credits) and an MCP server. Usage is billed to your account credits; failed calls are never charged.

Get started in three steps:

1. Create an API key on the Developer API Key page.
2. Choose the Base URL that matches the SDK or tool you use (see "Base URLs" below).
3. Send a request with the key in the Authorization: Bearer YOUR_API_KEY header, for example:

curl https://www.myai168.com/en/api/openai/v1/chat/completions \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"gpt-6.1-sol","messages":[{"role":"user","content":"Hello"}]}'

A successful call returns the standard OpenAI JSON: the reply text is in choices[0].message.content, and the response headers carry the points charged (X-Cost-Points) and your remaining balance (X-Credits-Remaining).

The same call in Python (install the package first with pip install requests):

import requests

r = requests.post(
    "https://www.myai168.com/en/api/openai/v1/chat/completions",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"model": "gpt-6.1-sol", "messages": [{"role": "user", "content": "Hello"}]},
    timeout=600,
)
r.raise_for_status()
print(r.json()["choices"][0]["message"]["content"])
print("cost:", r.headers.get("X-Cost-Points"), "remaining:", r.headers.get("X-Credits-Remaining"))

List the models each relay accepts with GET https://www.myai168.com/en/api/openai/v1/models or GET https://www.myai168.com/en/api/anthropic/v1/models — the returned list is exactly what the relay accepts; other models are rejected with No pricing info! Please use other models!.

Each relay page includes official SDK examples (for example OpenAI ChatGPT API); CLI tools such as Claude Code and Codex have step-by-step guides under "CLI & Agent Guides" in the Developer Center.

REST calls (curl, requests) use the Base URL plus the endpoint path, for example https://www.myai168.com/en/api/anthropic/v1/messages. Official SDKs add the version path themselves, so the Anthropic and Google SDKs take a shorter base URL — a wrong base URL is the most common cause of 404 errors.

To use the image, speech and video generation modules enabled on this site, call the site-native chat endpoint instead — see MYAI168 Chat API Guide.

Create an API key on the Developer API Key page, then send it with every request:

• Authorization: Bearer YOUR_API_KEY — works on all endpoints (recommended).
• x-api-key: YOUR_API_KEY — also accepted on Anthropic (Claude) endpoints (SDK compatible).
• x-goog-api-key: YOUR_API_KEY — also accepted on Google endpoints (SDK compatible).
• X-Dev-Key: YOUR_API_KEY — also accepted on the site-native Google Search / News, chat and MCP endpoints.

Never place API keys in URL query strings — URLs are recorded in access logs and browser history. Endpoints do not accept keys via query parameters.

Chat Completions, Responses, Anthropic Messages and Gemini streamGenerateContent support streaming. Send "stream": true (or use the streaming endpoint) and read the response as Server-Sent Events (data: {JSON} lines). With curl, add -N (--no-buffer) to see tokens as they arrive.

Each relay keeps its vendor's own event format: OpenAI Chat Completions sends data: chunks and ends with data: [DONE]; the Responses API and Anthropic Messages send named events (response.output_text.delta and content_block_delta carry the text); Gemini sends plain data: chunks. Each relay page shows a full sample.

Prefer streaming for long outputs or high reasoning effort: the relay waits up to about 10 minutes for the model, and a non-streaming call returns nothing until the whole reply is ready.

Usage is billed to your account credits. Non-streaming relay responses include X-Cost-Points (points charged for this call) and X-Credits-Remaining (your balance after the call). Streaming responses cannot carry these headers; instead, after the final event (e.g. data: [DONE]) the stream ends with SSE comment lines carrying the same information:

: cost=12
: credits-remaining=34567

Comment lines (starting with :) are skipped by spec-compliant SSE parsers and official SDKs, so they never affect compatibility; Google Gemini streaming does not send them. Read them from the raw stream if you want per-call charges. You can always query GET https://www.myai168.com/en/api/user/get_credits. Failed calls are never charged.

Error responses are JSON with the message in error.message. No error is ever charged.

How to handle them: for 400 / 404 / 405 fix the request (retrying will not help); for 401 check the key and its credit limit; for 402 top up; for 429 and 5xx wait and retry with increasing delays (for example 2, 4, then 8 seconds).

• Keep keys on the server: never put an API key in web pages, mobile apps or public repositories — call the API from your own backend.
• Use one key per application and set a credit limit on each key (Developer API Key page), so a runaway program cannot drain the account; delete a leaked key right away.
• Set a client timeout of about 600 seconds for non-streaming calls, or use streaming for long outputs.
• Check why a reply ended (finish_reason / stop_reason / finishReason) before using it — a reply cut off at the token limit looks like a normal one.
• Model ids must match the /models list exactly; refresh the list from time to time, because vendors retire models.
• Reasoning (thinking) tokens count as output: leave room in the output limit, and lower the reasoning effort for simple tasks to save credits.
• Track spending with the X-Cost-Points and X-Credits-Remaining response headers, or query GET https://www.myai168.com/en/api/user/get_credits at any time.