> ## Documentation Index
> Fetch the complete documentation index at: https://docs.arouter.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# FAQ

> Frequently asked questions about ARouter — authentication, billing, models, rate limits, and more.

## Getting Started

<AccordionGroup>
  <Accordion title="What is ARouter?">
    ARouter is a unified API gateway that gives you access to the world's leading AI models — from OpenAI, Anthropic, Google, DeepSeek, xAI, and more — through a single, OpenAI-compatible API.

    You manage one API key, one billing account, and one integration. ARouter handles routing, authentication, failover, and usage tracking transparently.
  </Accordion>

  <Accordion title="How do I get started?">
    1. Create an account at [https://api.arouter.ai](https://api.arouter.ai)
    2. Generate an API key in the Dashboard
    3. Set your base URL to `https://api.arouter.ai/v1` in any OpenAI-compatible client
    4. Send your first request

    See the [Quickstart](/en/quickstart) for a step-by-step guide.
  </Accordion>

  <Accordion title="How do I get support?">
    * **GitHub Issues**: [github.com/arouter-ai](https://github.com/arouter-ai)
    * **Email**: Check the Dashboard for contact information
    * **Documentation**: You're here!
  </Accordion>
</AccordionGroup>

## Billing

<AccordionGroup>
  <Accordion title="How am I billed?">
    ARouter uses a credit-based system. You pre-purchase credits and they are consumed per request based on token usage.

    You can view your balance and transaction history in the [Dashboard](https://arouter.ai/billing) or via the [API](/en/guides/billing-and-credits).
  </Accordion>

  <Accordion title="How does ARouter price requests?">
    ARouter passes through the upstream provider's published inference rates. A platform fee is charged when you purchase credits.

    Token counts are exactly as reported by the upstream provider and reflected in the `usage` field of every response.
  </Accordion>

  <Accordion title="Do credits expire?">
    Unused credits may expire one year after purchase in accordance with the billing terms.
  </Accordion>

  <Accordion title="What is the refund policy?">
    Refunds for unused credits can be requested within 24 hours of purchase. After that window, unused credits become non-refundable.

    Platform fees are non-refundable, and crypto payments are not refundable.
  </Accordion>

  <Accordion title="Does BYOK have a fee?">
    Yes. There is a free monthly allowance first, and usage beyond that allowance incurs a small ARouter platform fee while inference is billed through your own provider key.
  </Accordion>

  <Accordion title="How do I check my balance?">
    Via API:

    ```bash theme={null}
    curl https://api.arouter.ai/api/v1/balance \
      -H "Authorization: Bearer lr_live_xxxx"
    ```

    Or in the Dashboard at [https://arouter.ai/billing](https://arouter.ai/billing).
  </Accordion>

  <Accordion title="My credits have not appeared yet. What should I do?">
    If you completed a purchase and the balance did not update immediately, allow some time for payment settlement.

    If the charge succeeded and the credits still do not appear, contact support through the Dashboard with the purchase details so the payment can be traced.
  </Accordion>

  <Accordion title="What payment methods are accepted?">
    ARouter supports card-based credit purchases in the Dashboard and crypto-native top-ups for supported payment flows such as x402.
  </Accordion>

  <Accordion title="Is there a free tier?">
    If your account includes free credits or promotional usage, those requests are best treated as testing capacity rather than production capacity. Account-level and plan-level limits still apply.
  </Accordion>
</AccordionGroup>

## Models

<AccordionGroup>
  <Accordion title="What models are supported?">
    ARouter supports models from OpenAI, Anthropic, Google, DeepSeek, xAI, Mistral, Meta, Qwen, MiniMax, Groq, Kimi, Cohere, NVIDIA, and Dashscope.

    Use `GET /v1/models` to see the full list available to your account:

    ```bash theme={null}
    curl https://api.arouter.ai/v1/models \
      -H "Authorization: Bearer lr_live_xxxx"
    ```

    See [Models](/en/models) and [Providers](/en/providers) for details.
  </Accordion>

  <Accordion title="How do I specify which model to use?">
    Use the `provider/model` format in the `model` field:

    * `openai/gpt-5.4`
    * `anthropic/claude-sonnet-4.6`
    * `google/gemini-2.5-flash`
    * `deepseek/deepseek-v3.2`

    See [Model Routing](/en/model-routing) for the full reference.
  </Accordion>

  <Accordion title="Can ARouter automatically select the best model?">
    Yes. Set `model` to `"auto"` and ARouter's routing service will pick the best available model for your request:

    ```json theme={null}
    {
      "model": "auto",
      "messages": [{ "role": "user", "content": "Hello!" }]
    }
    ```

    The response always includes a `model` field showing which model was actually used. See [Model Routing — Auto Routing](/en/model-routing#auto-routing) for details.
  </Accordion>

  <Accordion title="Can I provide multiple candidate models?">
    Yes. Use the `models` array together with `route`:

    ```json theme={null}
    {
      "models": ["anthropic/claude-opus-4.5", "openai/gpt-5.4"],
      "route": "fallback",
      "messages": [...]
    }
    ```

    ARouter evaluates the models in order and returns the first successful result. See [Model Routing](/en/model-routing) for details.
  </Accordion>
</AccordionGroup>

## API Technical

<AccordionGroup>
  <Accordion title="How do I authenticate?">
    ARouter supports three authentication methods:

    * **Bearer token**: `Authorization: Bearer lr_live_xxxx` (OpenAI SDK, fetch)
    * **API Key header**: `X-Api-Key: lr_live_xxxx` (Anthropic SDK)
    * **Query parameter**: `?key=lr_live_xxxx` (Gemini SDK)

    See the [Authentication Guide](/en/authentication) for detailed setup with each SDK.
  </Accordion>

  <Accordion title="What are the rate limits?">
    Rate limits are applied per API key and can be configured in the Dashboard. Default limits depend on your plan.

    Rate limit headers are included in every response:

    * `X-RateLimit-Limit`
    * `X-RateLimit-Remaining`
    * `X-RateLimit-Reset`

    See the [API Reference](/en/api-reference/introduction) for details.
  </Accordion>

  <Accordion title="Which endpoints are available?">
    ARouter exposes:

    * `/v1/chat/completions` — OpenAI-compatible chat
    * `/v1/embeddings` — OpenAI-compatible embeddings
    * `/v1/models` — List available models
    * `/v1/messages` — Anthropic native
    * `/v1beta/models/{model}:generateContent` — Gemini native
    * `/api/v1/balance` — Account balance
    * `/api/v1/transactions` — Transaction history
    * `/api/v1/keys` — API key management
    * `/{provider}/{path}` — Provider proxy

    See the [API Reference](/en/api-reference/introduction) for the full list.
  </Accordion>

  <Accordion title="What input formats are supported?">
    ARouter supports:

    * **Text**: All models
    * **Images**: Vision-capable models (URL or base64)
    * **PDFs**: Anthropic Claude and Google Gemini

    See [Multimodal](/en/guides/features/multimodal) for details.
  </Accordion>

  <Accordion title="Does ARouter support streaming?">
    Yes. Set `stream: true` in your request. ARouter supports Server-Sent Events (SSE) streaming for all providers.

    See [Streaming](/en/guides/streaming) for the full guide including SSE format, error handling, and cancellation.
  </Accordion>

  <Accordion title="Which SDKs are supported?">
    ARouter is compatible with:

    * **Python**: OpenAI SDK (`pip install openai`)
    * **Node.js / TypeScript**: OpenAI SDK (`npm install openai`)
    * **Go**: ARouter Go SDK (`go get github.com/arouter-ai/arouter-go`)
    * **Anthropic SDK**: Python and Node.js
    * **Google Gemini SDK**: Python
    * **Any HTTP client**: via cURL, fetch, etc.

    See the [SDKs](/en/sdks/overview) section for setup guides.
  </Accordion>
</AccordionGroup>

## Privacy & Data

<AccordionGroup>
  <Accordion title="Does ARouter store my prompts?">
    ARouter does not store prompt content by default. Request bodies are forwarded to the upstream provider and not retained by ARouter.

    Usage metadata (token counts, model, timestamp, cost) is stored for billing and analytics purposes.

    See [Data Collection](/en/guides/privacy/data-collection) for the full policy.
  </Accordion>

  <Accordion title="Which providers see my data?">
    Only the upstream provider handling your specific request sees your prompt content. The provider you select via the `model` field processes your request. ARouter acts as a transparent proxy.

    See [Provider Logging](/en/guides/privacy/provider-logging) for details on upstream provider data policies.
  </Accordion>

  <Accordion title="Can I prevent providers from training on my data?">
    Use `provider.data_collection: "deny"` to restrict routing to providers that do not use request data for model training:

    ```json theme={null}
    {
      "model": "anthropic/claude-sonnet-4.6",
      "provider": {"data_collection": "deny"}
    }
    ```

    Or use `provider.zdr: true` for Zero Data Retention enforcement. See [Provider Routing — Data Collection Policy](/en/provider-routing#data-collection-policy).
  </Accordion>

  <Accordion title="Does ARouter support Zero Data Retention (ZDR)?">
    Yes. Set `provider.zdr: true` in your request to restrict routing to providers with Zero Data Retention agreements. See [Provider Routing](/en/provider-routing#zero-data-retention-zdr).
  </Accordion>
</AccordionGroup>

## Models & Providers

<AccordionGroup>
  <Accordion title="What are model variants like :nitro, :floor, and :free?">
    You can append suffixes to any model ID to change routing behavior:

    * `:nitro` — route to the highest-throughput instance
    * `:floor` — route to the lowest-cost instance
    * `:free` — use the free-tier instance (rate limits apply)
    * `:thinking` — enable extended chain-of-thought reasoning
    * `:extended` — use the version with a larger context window

    ```json theme={null}
    {"model": "openai/gpt-5.4:nitro"}
    ```

    See [Model Variants](/en/guides/features/model-variants) for the full reference.
  </Accordion>

  <Accordion title="Does ARouter support images and PDFs?">
    Yes. Pass image URLs or base64-encoded images in the `content` array alongside text. PDFs are supported by Anthropic Claude and Google Gemini.

    ```json theme={null}
    {
      "model": "openai/gpt-5.4",
      "messages": [{
        "role": "user",
        "content": [
          {"type": "text", "text": "What's in this image?"},
          {"type": "image_url", "image_url": {"url": "https://..."}}
        ]
      }]
    }
    ```

    See [Multimodal](/en/guides/features/multimodal) for examples.
  </Accordion>

  <Accordion title="Does ARouter support tool calling?">
    Yes. ARouter supports tool/function calling for all major providers using the OpenAI tool calling standard. Pass `tools` and `tool_choice` in your request.

    See [Tool Calling](/en/guides/features/tool-calling) for the full guide.
  </Accordion>

  <Accordion title="Does ARouter support structured outputs / JSON mode?">
    Yes. Use `response_format: {"type": "json_object"}` for valid JSON output, or `response_format: {"type": "json_schema", "json_schema": {...}}` for schema-enforced output.

    See [Structured Outputs](/en/guides/features/structured-outputs) for details.
  </Accordion>

  <Accordion title="Does ARouter support prompt caching?">
    Yes. Prompt caching is supported automatically for OpenAI, DeepSeek, xAI, and Groq models. For Anthropic, use `cache_control` blocks for explicit caching. Google Gemini supports both automatic and explicit caching.

    See [Prompt Caching](/en/guides/features/prompt-caching) for the full guide.
  </Accordion>
</AccordionGroup>

## Account Management

<AccordionGroup>
  <Accordion title="Can I set spending limits on API keys?">
    Yes. When creating or updating an API key, set a `spending_limit` to cap how much that key can spend:

    ```bash theme={null}
    curl -X POST https://api.arouter.ai/v1/keys \
      -H "Authorization: Bearer lr_live_xxxx" \
      -d '{"name": "production", "spending_limit": 100.00}'
    ```

    See [Key Management](/en/guides/key-management) for details.
  </Accordion>

  <Accordion title="How do I restrict which providers a key can access?">
    Set `allowed_providers` when creating a key:

    ```json theme={null}
    {
      "name": "openai-only-key",
      "allowed_providers": ["openai", "anthropic"]
    }
    ```

    See [Key Management](/en/guides/key-management) for details.
  </Accordion>

  <Accordion title="Can I have multiple API keys?">
    Yes. You can create multiple API keys for different environments, services, or use cases. Each key has independent spending limits, provider restrictions, and usage tracking.

    Manage keys in the [Dashboard](https://arouter.ai/keys) or via the [Key Management API](/en/api-reference/keys/create-key).
  </Accordion>

  <Accordion title="Can I track usage per user in my application?">
    Yes. Pass a `user` field in each request with an opaque identifier for your end user. Usage is then available per user in the Activity Export.

    ```json theme={null}
    {"model": "openai/gpt-5.4", "user": "user_12345", "messages": [...]}
    ```

    See [User Tracking](/en/guides/administration/user-tracking) for details.
  </Accordion>

  <Accordion title="Can multiple people share an account?">
    Yes. Use [Organization Management](/en/guides/administration/organization-management) to create a shared organization, invite team members, manage shared credits, and control permissions.
  </Accordion>
</AccordionGroup>