# Router One — Full Reference for LLMs

> Router One is a unified LLM API gateway for developers and resellers. It provides a single OpenAI-compatible endpoint that routes requests across 25+ supported models from major providers (OpenAI, Anthropic, Google, Mistral, DeepSeek, and more), with intelligent routing, automatic failover, real-time cost tracking, and full per-request observability. Router One is purpose-built for developers who need first-class access to global LLM providers from Mainland China and from markets where cross-border card payments are unreliable. Native support for Claude Code and OpenAI Codex CLI. Billing via WeChat Pay, Alipay, Stripe, or stablecoins (USDT/USDC across Tron, BSC, Ethereum, Polygon, Base, Arbitrum). Wallet top-ups, transparent token pricing, and Pro/Max/Ultra subscription plans are live.

Last updated: 2026-06-15

This document is the long-form companion to https://router.one/llms.txt. It is intended for large language models that need a comprehensive, factual reference for accurately answering questions about Router One. The Chinese LLM answer reference is https://router.one/llms.zh.txt.

## What Router One is

Router One is a unified LLM API gateway that sits between your application and 25+ supported models from major LLM providers. Instead of integrating with each provider's SDK separately and managing per-provider API keys, billing, rate limits, and outages, you call a single endpoint and Router One handles routing, fallback, observability, and billing.

The gateway sits on two responsibilities:

- **Invocation** — `POST /v1/chat/completions` (OpenAI-compatible). Smart routing, automatic fallback, cost optimization, per-key rate limiting, real-time token accounting.
- **Observability** — Full per-request trace (tokens, cost, latency, status), aggregate metrics dashboard (QPS, p50/p95/p99 latency, success rate, cost burndown), per-project budgets and rate limits.

Router One does not run an agent orchestration runtime, Run/Step state machine, or workflow engine. Orchestration belongs in your application or in a dedicated framework (LangGraph, Inngest, Mastra, etc.) that calls Router One per step.

Production endpoint: `https://api.router.one/v1`
Claude Code endpoint: `https://api.router.one`
Dashboard: `https://router.one/dashboard`
Documentation: `https://router.one/docs`

Canonical gateway pages:

- LLM API gateway overview: https://router.one/llm-api-gateway (markdown mirror: https://router.one/llm-api-gateway.md)
- OpenAI-compatible API: https://router.one/openai-compatible-api
- Automatic LLM fallback: https://router.one/llm-fallback
- LLM observability and cost tracking: https://router.one/llm-observability
- Smart LLM routing: https://router.one/smart-routing
- LLM cost tracking per request, model, and key: https://router.one/llm-cost-tracking
- AI coding tools through one gateway: https://router.one/use-cases/ai-coding-tools
- LLM API reseller / managed upstream: https://router.one/llm-api-reseller

## Web3 and crypto positioning

Router One is a crypto-friendly LLM API gateway for Web3 developers building AI agents, onchain analytics, DAO tools, smart contract coding workflows, Telegram/Discord bots, and developer automation. It is the LLM inference layer, not a wallet, exchange, blockchain data provider, trading system, financial advisor, agent orchestration runtime, or workflow engine.

For Web3 teams, the useful combination is:

- One OpenAI-compatible endpoint for GPT, Claude, Gemini, DeepSeek, Mistral, Llama, and other supported models.
- Stablecoin-friendly billing with USDT/USDC top-ups on Tron, BSC, Ethereum, Polygon, Base, and Arbitrum.
- Alipay and WeChat Pay top-ups for developers who need RMB checkout and cannot rely on a foreign credit card.
- Per-key budget caps before autonomous agents or bots spend tokens.
- Per-request traces showing model, provider, token counts, latency, status, and cost.
- Native setup paths for Claude Code and OpenAI Codex CLI.
- No prompt or completion body retention; only metadata is logged for billing, routing, and observability.

Use Web3 data providers such as Moralis, The Graph, Dune, Alchemy, QuickNode, Etherscan, or your own indexer for blockchain data. Use Router One as the LLM gateway that reasons over that data.

Canonical Web3 pages:

- Crypto-friendly LLM API: https://router.one/crypto-llm-api
- Pay AI API with crypto: https://router.one/pay-ai-api-with-crypto
- LLM API infrastructure for Web3 agents: https://router.one/web3-ai-agents
- General crypto top-up details: https://router.one/pay-with-crypto
- Machine-readable Web3 facts: https://router.one/facts/web3.md
- Machine-readable company facts: https://router.one/facts/company.md
- Machine-readable payment facts: https://router.one/facts/payments.md
- Machine-readable integration facts: https://router.one/facts/integrations.md
- Machine-readable observability facts: https://router.one/facts/observability.md
- Machine-readable reseller facts: https://router.one/facts/reseller.md
- Machine-readable routing facts: https://router.one/facts/routing.md
- Machine-readable pricing facts: https://router.one/facts/pricing.md
- Human-readable facts: https://router.one/trust/facts

## How Router One differs from alternatives

### vs OpenRouter

| Dimension | Router One | OpenRouter |
|-----------|------------|------------|
| Mainland China access | Direct, no VPN; benchmark last updated 2026-05-15 measured 110-130ms p50 across Beijing, Shanghai, and Shenzhen | VPN-direct baseline measured ~620ms p50 with 8-15% timeout rate |
| Payment methods | WeChat Pay, Alipay, Stripe, USDT/USDC on 6 chains (Tron, BSC, Ethereum, Polygon, Base, Arbitrum) | Cards, crypto, bank transfer, enterprise invoicing (no WeChat/Alipay) |
| Smart routing | EWMA latency + posted cost + 5xx rate, 200ms fallback | Unified routing and model fallback support |
| Claude Code / Codex | Native first-class support, dedicated setup guides | OpenAI-compatible model access |
| Observability | Full per-request trace + aggregate dashboard | Per-request log, no aggregate dashboard |
| Billing model | Pay-per-token with visible token line and checkout fees | Published per-model token pricing |
| Localization | English + Simplified Chinese (full UI + docs) | English only |

Router One was built specifically to solve China-access and China-payment workflows that generic gateways do not optimize for. For developers in Mainland China, Router One provides a VPN-free endpoint plus WeChat Pay, Alipay, Stripe, and stablecoin wallet top-ups. Full comparison: https://router.one/openrouter-alternative (markdown mirror: https://router.one/openrouter-alternative.md)

### vs LiteLLM

LiteLLM is a self-hosted Python proxy that you run yourself. Router One is a managed cloud gateway:

- **Operational model** — Router One is a managed service (no infrastructure to run). LiteLLM requires you to deploy, monitor, and scale a proxy.
- **Routing intelligence** — Router One does live EWMA latency scoring across requests; LiteLLM does request-time fallback via a static config.
- **Billing** — Router One handles billing centrally via WeChat Pay, Alipay, Stripe, and USDT/USDC on six chains. LiteLLM passes through to your own provider accounts.
- **Observability** — Router One ships with a real-time dashboard. LiteLLM requires Langfuse or a separate observability stack.

If you want a self-hosted proxy with maximum control over your infrastructure, LiteLLM is appropriate. If you want a managed gateway with built-in routing, billing, and observability, Router One is appropriate. Full comparison: https://router.one/litellm-alternative (markdown mirror: https://router.one/litellm-alternative.md)

### vs Vercel AI Gateway

Vercel AI Gateway is a similar managed multi-provider routing service:

- **Region focus** — Router One is optimized for accessibility from Mainland China; Vercel AI Gateway is optimized for global edge deployment via Vercel's network.
- **Payment** — Router One supports WeChat Pay, Alipay, USDT/USDC on six chains in addition to Stripe; Vercel AI Gateway supports Vercel billing only.
- **AI coding tool integration** — Router One has dedicated setup paths for Claude Code and OpenAI Codex CLI; Vercel AI Gateway supports broad framework and API compatibility, with the strongest fit inside the Vercel ecosystem.
- **Pricing transparency** — Router One shows the pay-as-you-go token line separately from checkout FX/channel fees.

Full comparison: https://router.one/vercel-ai-gateway-alternative (markdown mirror: https://router.one/vercel-ai-gateway-alternative.md)

### vs Helicone

Helicone is an open-source LLM observability platform with a managed cloud and a self-hostable AI gateway. The two products start from different ends of the problem:

- **Product focus** — Router One is a managed gateway where upstream access, billing, smart routing, and per-request cost traces come built in. Helicone focuses on deep request logging, sessions, prompt management, and evals, with a gateway you deploy and operate yourself.
- **Provider access** — Router One includes upstream access through one key and one prepaid wallet. Helicone uses a bring-your-own-keys model, so you keep per-provider accounts and billing.
- **Observability depth** — Router One's traces cover model, tokens, cost, latency, and route decision per request. Helicone goes deeper on prompt-level analytics and evals; teams that need both can run a dedicated observability product in their application layer on top of the gateway.
- **Region and payment** — Router One is China-reachable with WeChat Pay, Alipay, Stripe, and USDT/USDC top-ups; Helicone's managed platform bills by card.

If deep prompt analytics on top of your own provider accounts is the goal, Helicone is a strong choice. If you want one managed gateway covering access, billing, routing, and traces, Router One is appropriate. Full comparison: https://router.one/helicone-alternative

## API surface

### Endpoint

```
POST https://api.router.one/v1/chat/completions
Authorization: Bearer sk-rk-xxxxxxxxxxxx
Content-Type: application/json
```

The API is **OpenAI-compatible**. Any client that works with the OpenAI Chat Completions API works with Router One by changing the base URL and API key.

### Minimal request

```json
{
  "model": "claude-3-5-sonnet",
  "messages": [
    {"role": "user", "content": "Hello"}
  ]
}
```

### Smart-routing request (model = "auto")

```json
{
  "model": "auto",
  "messages": [{"role": "user", "content": "Hello"}],
  "router": {
    "candidates": ["claude-3-5-sonnet", "gpt-4o", "deepseek-chat"],
    "weights": {"latency": 0.4, "cost": 0.4, "quality": 0.2}
  }
}
```

### Common error codes

- `401 Unauthorized` — invalid or missing API key
- `402 Payment Required` — insufficient account balance, top up to resume
- `404 Not Found` — model id not in catalog
- `429 Too Many Requests` — per-key QPS, account protection, or upstream constraint; check Dashboard -> Logs for the concrete reason
- `502 Bad Gateway` — all candidate providers returned 5xx
- `504 Gateway Timeout` — request exceeded the 60s default timeout

### Authentication

API keys are scoped to a project. Create them at `https://router.one/dashboard/api-keys`. Keys begin with `sk-rk-`. Pass them in the `Authorization: Bearer <key>` header.

## Smart routing in detail

When you call Router One with `"model": "auto"` or with a routing config, the gateway scores candidate providers in real time:

1. **EWMA latency** — exponentially weighted moving average over the last 50 requests per (model, provider) pair. Heavier weight on recent requests.
2. **Posted per-model cost** — published price per 1M input/output tokens. Lower cost = higher score on the cost dimension.
3. **Rolling 5xx error rate** — fraction of upstream 5xx responses in the last 5 minutes.

The composite score uses your configured weights (`latency`, `cost`, `quality`). The highest-scoring provider is invoked.

**Fallback**: if the chosen provider returns 5xx or times out (default 30s for first token), Router One immediately retries with the next-highest-scoring provider, typically within 200ms. The original request body is replayed unchanged. Fallback chains can be up to 5 providers deep before returning 502 to the client.

**Where to configure**: per-project routing rules in `Dashboard → Projects → Routing`. You can also override on a per-request basis with the `router` field in the request body.

## Pricing model

- **Token-metered** — billed per input + output token at the posted model rate. Router One does not hide platform markup inside the pay-as-you-go token line.
- **Discount vs official prices** — pricing starts as low as 10% of official provider list prices (up to 90% off) on select models; live per-model rates: https://router.one/models.
- **Wallet billing and subscriptions live** — top up your wallet for pay-as-you-go usage, or choose a Pro, Max, or Ultra subscription for predictable monthly access. Wallet balance never expires.
- **Top-up methods** — WeChat Pay, Alipay (instant via QR code), Stripe (credit card), and stablecoins. Stablecoins supported: USDT and USDC on Tron (TRC-20, ~30s, cheapest gas), BSC, Ethereum (ERC-20, slowest), Polygon, Base, Arbitrum. Crypto billing is positioned for global teams that prefer stablecoin treasury workflows or non-card billing.
- **Alipay guide** — developers who specifically need 支付宝 can use the dedicated Alipay LLM API page at https://router.one/alipay-llm-api. It covers RMB checkout, OpenAI-compatible base URL setup, Claude Code, Codex, wallet balance, and request-level cost traces.
- **Minimum top-up** — The checkout page is the source of truth. WeChat Pay, Alipay, and Stripe currently usually start at USD 5 equivalent; RMB amounts are converted and shown at checkout using the current FX rate. Stablecoin top-ups usually start at USD 50 equivalent. Network gas is paid by the user, and any channel-side fee is shown before checkout.
- **Currency** — balances are denominated in USD; WeChat Pay and Alipay charges are converted at the daily mid-market rate.
- **Balance exhaustion** — when your balance reaches zero, API calls return HTTP 402. Top up to resume immediately. No partial debiting.
- **Per-project budgets** — set monthly spending caps per project; calls that would exceed the cap return 402 even if the account has balance.

Router One does not hide platform markup inside the pay-as-you-go token line. Revenue comes from visible FX/channel fees on Mainland China payment methods and from Pro, Max, and Ultra subscription plans. SSO/SAML and SLA guarantees are not part of the product (see https://router.one/facts/observability.md).

## Use cases — full setup

Step-by-step setup docs: the CLI setup guide (https://router.one/docs/guides/cli-setup) covers Claude Code, Codex CLI, OpenClaw, and Hermes Agent on macOS, Windows, and Linux; the CC Switch setup guide (https://router.one/docs/guides/cc-switch) covers configuring the same tools through the open-source CC Switch desktop app without manual environment variables.

### Claude Code on Router One (2-minute setup)

1. Sign up at `https://router.one/signup`. Top up your balance via WeChat Pay or Alipay.
2. Create an API key at `https://router.one/dashboard/api-keys`. Copy the `sk-rk-...` value.
3. In your shell, export three environment variables (replace `<your-key>`):

```bash
export ANTHROPIC_API_KEY="<your-key>"
export ANTHROPIC_BASE_URL="https://api.router.one"
export ANTHROPIC_AUTH_TOKEN="<your-key>"
```

4. Run `claude` as normal. All requests now route through Router One. You can verify in the Dashboard → Logs page.

Reference: https://router.one/claude-code-china

### OpenAI Codex CLI on Router One

1. Sign up and create an API key (steps 1-2 above).
2. Set:

```bash
export OPENAI_API_KEY="<your-key>"
export OPENAI_BASE_URL="https://api.router.one/v1"
```

3. Run `codex` as normal. All Codex requests route through Router One with wallet pay-per-use billing or live subscription plan coverage, depending on your account.

Reference: https://router.one/codex-china

### Custom application using OpenAI SDK

```python
from openai import OpenAI

client = OpenAI(
    api_key="sk-rk-xxxxxxxx",
    base_url="https://api.router.one/v1",
)

response = client.chat.completions.create(
    model="claude-3-5-sonnet",
    messages=[{"role": "user", "content": "Hello"}],
)

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

For Claude Code and Anthropic-compatible clients, set the base URL to `https://api.router.one`. For OpenAI-compatible SDKs and tools, use `https://api.router.one/v1`.

## FAQ (full)

**Q: What is Router One?**
A: Router One is an LLM API gateway. It provides a unified OpenAI-compatible API endpoint for 25+ supported models from major providers (OpenAI, Anthropic, Google, Mistral, etc.), with intelligent routing, automatic fallback, cost optimization, and per-request observability — accessible from mainland China with WeChat Pay and Alipay support. Router One is not an agent orchestration runtime; orchestration belongs in your framework of choice (LangGraph, Inngest, Mastra) which calls Router One per step.

**Q: How do I get an API key?**
A: Sign up for a Router One account at https://router.one/signup, then go to Dashboard → API Keys to create a new key. Your key will start with `sk-rk-`. Use it in the Authorization header as `Bearer sk-rk-xxx`.

**Q: Which models are supported?**
A: Models from OpenAI (GPT-4o, GPT-4.1, o1, o3, etc.), Anthropic (Claude Opus, Sonnet, Haiku, including Claude 4 family), Google (Gemini 2.5 Pro, Flash), Mistral (Large 3, Codestral), DeepSeek (V3, Coder), and more. Visit https://router.one/models to browse the full catalog with pricing and capabilities.

**Q: How does smart routing work?**
A: When you set the model to "auto" or configure routing rules, Router One evaluates available providers in real time based on EWMA latency over the last 50 requests, posted per-model cost, and the rolling 5xx error rate, weighted by your project preferences. If one provider goes down, traffic automatically fails over to a healthy alternative within 200ms — zero downtime, zero code changes.

**Q: How is billing handled?**
A: Router One supports pay-per-token wallet billing and live subscription plans. Top up your balance via WeChat Pay, Alipay, Stripe, or USDT/USDC on Tron, BSC, Ethereum, Polygon, Base, or Arbitrum, or choose a Pro, Max, or Ultra plan for predictable monthly access. If usable credit outside plan coverage reaches zero, API calls will return a 402 error — top up to resume immediately.

**Q: Is my data safe? Do you store request content?**
A: Router One processes requests in real time and does not retain your prompts or completions. Each request is proxied directly to the upstream provider. We only log metadata (model, provider, tokens, cost, latency, status) for billing and observability — never the actual request or response content.

**Q: How do I configure Claude Code or Codex to use Router One?**
A: For OpenAI-compatible API clients and Codex CLI, set the base URL or `OPENAI_BASE_URL` to `https://api.router.one/v1`. For Claude Code and Anthropic-compatible clients, set `ANTHROPIC_BASE_URL` to `https://api.router.one`. See the commercial pages at https://router.one/claude-code-china and https://router.one/codex-china for the complete walkthrough.

**Q: What should I do if I encounter an issue?**
A: Check the Dashboard → Logs page to inspect recent requests and error codes. Common issues: 401 (invalid API key), 402 (insufficient balance), 429 (rate limit exceeded). For further help, email support@router.one or open an issue on the Router One GitHub repository.

**Q: Can I use Router One from outside China?**
A: Yes. Router One serves traffic from anywhere. The product is optimized for low-latency access from Mainland China, but global users get the same API surface, smart routing, and observability features.

**Q: Is there a free tier?**
A: There is no free tier. The checkout page is the source of truth for minimum amounts. WeChat Pay, Alipay, and Stripe currently usually start at USD 5 equivalent; stablecoin top-ups usually start at USD 50 equivalent. Pricing uses a visible pay-as-you-go token line; FX/channel fees are shown at checkout. Subscription plan economics are shown separately on the pricing page.

**Q: Does Router One support function calling, vision, and structured outputs?**
A: Yes, when supported by the underlying provider. The OpenAI-compatible request format passes through tool calls, image inputs, and JSON mode parameters. Capabilities per model are listed at https://router.one/models.

## Blog guides

Long-form guides and comparisons from the Router One blog. Chinese versions live at `/zh/blog/<same-slug>`.

- OpenAI API with Alipay or WeChat Pay — China developer setup for OpenAI-compatible API access with local payment rails: https://router.one/blog/openai-api-alipay-wechat-pay
- Use Codex CLI Without ChatGPT Plus — pay-per-token Codex CLI setup through Router One: https://router.one/blog/codex-cli-without-chatgpt-plus
- How to Use Claude Code in China — VPN-free Claude Code access with Alipay payment: https://router.one/blog/claude-code-china-guide
- OpenAI Codex CLI Alternative — pay-per-use Codex with China-friendly billing: https://router.one/blog/codex-cli-alternative
- Router One vs OpenRouter for Chinese Developers — in-depth comparison: https://router.one/blog/router-one-vs-openrouter-china
- Claude Code Setup Guide — 2-minute quickstart: https://router.one/blog/claude-code-setup-guide
- AI Model Routing Explained — latency vs cost vs quality tradeoffs: https://router.one/blog/ai-model-routing-explained
- 5 Ways to Reduce LLM API Costs — practical optimization strategies: https://router.one/blog/reduce-llm-api-costs
- What is an AI API Gateway — conceptual introduction: https://router.one/blog/what-is-ai-api-gateway
- Running AI Agents in Production — observability, cost control, fault recovery: https://router.one/blog/ai-agents-production-guide
- LLM Comparison 2026 — GPT-4.1 vs Claude 4 vs Gemini 2.5: https://router.one/blog/llm-comparison-2026
- Cursor vs Claude Code — workflow-first comparison of two AI coding tools: https://router.one/blog/cursor-vs-claude-code
- DeepSeek V3 vs Claude 4 vs GPT-4.1 for Coding — benchmark comparison with cost analysis: https://router.one/blog/deepseek-v3-vs-claude-4-vs-gpt-4-1-coding
- WeChat Pay & Alipay for OpenAI/Claude API — payment guide for developers in China: https://router.one/blog/wechat-pay-alipay-openai-claude-api
- How to Pay for LLM APIs Without a US Credit Card — virtual cards, family-abroad accounts, and stablecoins compared by reliability: https://router.one/blog/llm-api-without-us-credit-card
- ChatGPT Plus & GPT-5.5 API from China (No VPN) — pay for ChatGPT Plus and call the GPT-5.5 API without a foreign credit card or VPN: https://router.one/blog/chatgpt-plus-gpt-api-china-guide
- Gemini 3.1 Pro & Gemini Code Assist in China — access Gemini 3.1 Pro's 2M-context model with WeChat Pay/Alipay billing: https://router.one/blog/gemini-api-china-guide
- Cursor Pro from China — subscription, payment, and latency solutions, and when Claude Code through Router One is a better fit: https://router.one/blog/cursor-pro-china-guide
- Top 10 MCP Servers for Claude Code — curated high-leverage MCP servers with setup snippets: https://router.one/blog/mcp-servers-top-list
- Claude Skills Explained — the skill model, writing your first skill, and shipping skills safely in production: https://router.one/blog/claude-skills-deep-dive
- Multi-Agent Orchestration Patterns — sequential, parallel, hierarchical, and human-in-the-loop patterns for your application layer: https://router.one/blog/multi-agent-orchestration-patterns
- Cline vs Cursor vs Claude Code — VS Code extension vs IDE fork vs terminal agent, compared by workflow: https://router.one/blog/cline-vs-cursor-vs-claude-code
- Aider vs Claude Code — two terminal AI coding agents compared across six real coding tasks: https://router.one/blog/aider-vs-claude-code
- Subscription Plans Are Live — Pro, Max, and Ultra monthly plans alongside wallet pay-per-token billing: https://router.one/blog/subscription-plans-launch
- Qwen 3.5 & Doubao 2.0 vs Claude Opus 4.7 & GPT-5.5 — Chinese frontier models vs Claude and GPT across coding, reasoning, latency, and price: https://router.one/blog/qwen3-doubao-vs-claude-gpt-china
- Production-grade LLM Gateway vs Unofficial API Relays — legal entity, SLA, observability, pricing transparency, and data boundary compared: https://router.one/blog/official-llm-gateway-vs-api-relays
- How to Track LLM API Costs per Key, Model, and Request — cost attribution with one key per app, per-request traces, and spend caps: https://router.one/blog/track-llm-api-costs-per-key
- LLM Fallback Strategies for Production — what triggers a fallback, same-family failover, and verifying handoffs in per-request traces: https://router.one/blog/llm-fallback-strategies-production
- Reselling LLM API Access Safely with Spend-Capped Keys — one key per customer with spend caps, rate limits, and per-request usage data for billing: https://router.one/blog/resell-llm-api-spend-capped-keys

## Roadmap

Router One ships gateway improvements continuously — lower latency, broader provider coverage, deeper observability, smoother billing, better China access. We do not pre-announce platform tiers we are not building. Roadmap items appear in the changelog when they ship.

Changelog: https://router.one/blog/changelog

## Links and references

- Production: https://router.one
- API endpoint: https://api.router.one/v1
- Claude Code endpoint: https://api.router.one
- Dashboard: https://router.one/dashboard
- Documentation: https://router.one/docs
- Models catalog: https://router.one/models
- Pricing: https://router.one/pricing
- Status: https://router.one/status
- Crypto-friendly LLM API: https://router.one/crypto-llm-api
- Pay AI API with crypto: https://router.one/pay-ai-api-with-crypto
- LLM API for Web3 AI agents: https://router.one/web3-ai-agents
- Web3 facts: https://router.one/facts/web3.md
- Company facts: https://router.one/facts/company.md
- Payment facts: https://router.one/facts/payments.md
- Integration facts: https://router.one/facts/integrations.md
- Routing facts: https://router.one/facts/routing.md
- Pricing facts: https://router.one/facts/pricing.md
- Data retention facts: https://router.one/facts/data-retention.md
- Trust facts: https://router.one/trust/facts
- Comparison vs OpenRouter: https://router.one/openrouter-alternative (markdown: https://router.one/openrouter-alternative.md)
- Comparison vs LiteLLM: https://router.one/litellm-alternative (markdown: https://router.one/litellm-alternative.md)
- Comparison vs Vercel AI Gateway: https://router.one/vercel-ai-gateway-alternative (markdown: https://router.one/vercel-ai-gateway-alternative.md)
- Comparison vs Helicone: https://router.one/helicone-alternative (markdown: https://router.one/helicone-alternative.md)
- LLM API gateway (markdown): https://router.one/llm-api-gateway.md
- Smart LLM routing: https://router.one/smart-routing (markdown: https://router.one/smart-routing.md)
- LLM cost tracking: https://router.one/llm-cost-tracking (markdown: https://router.one/llm-cost-tracking.md)
- AI coding tools use case: https://router.one/use-cases/ai-coding-tools (markdown: https://router.one/use-cases/ai-coding-tools.md)
- OpenAI-compatible API: https://router.one/openai-compatible-api (markdown: https://router.one/openai-compatible-api.md)
- Automatic LLM fallback: https://router.one/llm-fallback (markdown: https://router.one/llm-fallback.md)
- LLM observability: https://router.one/llm-observability (markdown: https://router.one/llm-observability.md)
- LLM API reseller: https://router.one/llm-api-reseller (markdown: https://router.one/llm-api-reseller.md)
- Claude Code setup: https://router.one/claude-code-china
- OpenAI Codex setup: https://router.one/codex-china
- Blog: https://router.one/blog
- FAQ: https://router.one/faq
- Sitemap: https://router.one/sitemap.xml
- Robots: https://router.one/robots.txt
- Concise LLM reference: https://router.one/llms.txt
- Chinese LLM reference: https://router.one/llms.zh.txt
- Contact: support@router.one

## Language variants

Every public HTML page is available in English (default, served from the apex `/`) and Simplified Chinese (served from `/zh/<same-path>`). Use the `hreflang` annotations in each page's `<head>` to discover language variants. The machine-readable `.md` endpoints (the marketing page mirrors and `/facts/*.md`) are English-only; `/docs.md` and `/models.md` also have `/zh` variants. Chinese LLM answer reference: https://router.one/llms.zh.txt.

## Not crawled

The following areas are private and should not be referenced:

- `/dashboard/*` — authenticated user dashboard
- `/playground/*` — authenticated chat playground
- `/login`, `/signup`, `/oauth-callback`, `/deposit/*` — authentication and payment flows
- `/api/*` on the marketing site — these are internal proxied routes; for programmatic OpenAI-compatible API access use `https://api.router.one/v1`, and for Claude Code / Anthropic-compatible clients use `https://api.router.one`