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

# Quickstart

This guide gets you from zero to a working API call. By the end you'll have:

* A RouterLink account and API key
* A successful chat completion against any supported model
* A budget set on your key so you can't overspend

## 1. Create an API key

<Steps>
  <Step title="Sign in">
    Visit [routerlink.ai](https://routerlink.ai) and sign in with email or Google.
  </Step>

  <Step title="Top up credits">
    Open **Settings → Billing** and add credits.
  </Step>

  <Step title="Generate a key">
    Go to [**API Keys**](https://routerlink.ai/settings/api-keys) **→ Create key**. Copy the key (it starts with `sk-` and is shown only once).
  </Step>
</Steps>

## 2. Make your first request (OpenAI-compatible)

<Tip>
  Replace `<ROUTERLINK_API_KEY>` with your [RouterLink Key](https://routerlink.ai/settings/api-keys).
</Tip>

For available `model` options, please check the [**Model Gallery**](https://routerlink.ai/models). Simply copy and paste the model name to use it.

<Tabs>
  <Tab title="Curl">
    ```bash theme={null}
    curl https://router-link.world3.ai/api/v1/chat/completions \
      -H "Authorization: Bearer <ROUTERLINK_API_KEY>" \                                                                                                                    
      -H "Content-Type: application/json" \
      -d '{                                                                                                                                                                
        "model": "world3-router-north-america/openai/gpt-5.3-codex",                                 
        "messages": [                                                                                                                                                      
          {"role": "user", "content": "Say hello in one short sentence."}
        ]                                                                                                                                                                  
      }'                                                        
    ```
  </Tab>

  <Tab title="Python">
    ```python theme={null}
    from openai import OpenAI                                                                                                                                              
                                                                
    client = OpenAI(
        base_url="https://router-link.world3.ai/api/v1",
        api_key="<ROUTERLINK_API_KEY>",                                                                                                                                    
    )
                                                                                                                                                                           
    resp = client.chat.completions.create(                      
        model="world3-router-north-america/openai/gpt-5.3-codex",
        messages=[{"role": "user", "content": "Say hello in one short sentence."}],                                                                                        
    )
    print(resp.choices[0].message.content)                                                                                                                                 
    ```
  </Tab>

  <Tab title="Node.js">
    ```ts theme={null}
    import OpenAI from "openai";
                                                                                                                                                                           
    const client = new OpenAI({                                 
      baseURL: "https://router-link.world3.ai/api/v1",
      apiKey: process.env.ROUTERLINK_API_KEY,                                                                                                                              
    });
                                                                                                                                                                           
    const resp = await client.chat.completions.create({         
      model: "world3-router-north-america/openai/gpt-5.3-codex",
      messages: [{ role: "user", content: "Say hello in one short sentence." }],                                                                                           
    });
    console.log(resp.choices[0].message.content);                                                                                                                          
    ```
  </Tab>
</Tabs>

## 3. Use the native Anthropic SDK

RouterLink exposes an Anthropic-compatible Messages endpoint, so any official [Anthropic client SDK](https://platform.claude.com/docs/en/api/client-sdks) works by overriding `base_url` (and pointing `api_key` at your RouterLink key).

<Tip>
  Base URL: `https://router-link.world3.ai/api` — the SDK appends `/v1/messages` automatically. Make sure to replace `<ROUTERLINK_API_KEY>` with your API key from [RouterLink](https://routerlink.ai/settings/api-keys).
</Tip>

<Tabs>
  <Tab title="Curl">
    ```bash theme={null}
    curl https://router-link.world3.ai/api/v1/messages \
      -H "x-api-key: <ROUTERLINK_API_KEY>" \
      -H "Content-Type: application/json" \                                                                                                                                
      -H "anthropic-version: 2023-06-01" \
      -d '{                                                                                                                                                                
        "model": "anthropic/claude-opus-4-6",                                                                                                                                        
        "max_tokens": 1024,
        "messages": [                                                                                                                                                      
          {"role": "user", "content": "Say hello in one short sentence."}
        ]
      }'                                                                                                                                                                   
    ```
  </Tab>

  <Tab title="Python ">
    ```bash theme={null}
    pip install anthropic
    ```

    ```python theme={null}
    import anthropic                                            

    client = anthropic.Anthropic(
        base_url="https://router-link.world3.ai/api",
        api_key="<ROUTERLINK_API_KEY>",
    )                                                                                                                                                                      

    message = client.messages.create(                                                                                                                                      
        model="anthropic/claude-opus-4-6",                                
        max_tokens=1024,
        messages=[{"role": "user", "content": "Say hello in one short sentence."}],
    )                                                                                                                                                                      
    print(message.content[0].text)
    ```
  </Tab>

  <Tab title="Node.js">
    ```bash theme={null}
    npm install @anthropic-ai/sdk
    ```

    ```ts theme={null}
    import Anthropic from "@anthropic-ai/sdk";                  

    const client = new Anthropic({
      baseURL: "https://router-link.world3.ai/api",
      apiKey: process.env.ROUTERLINK_API_KEY,                                                                                                                              
    });
                                                                                                                                                                           
    const message = await client.messages.create({              
      model: "anthropic/claude-opus-4-6",
      max_tokens: 1024,                                                                                                                                                    
      messages: [{ role: "user", content: "Say hello in one short sentence." }],
    });                                                                                                                                                                    
    console.log(message.content);                               
    ```
  </Tab>
</Tabs>

Other official SDKs (Java, Go, Ruby, C#, PHP) work the same way — set the SDK's base URL to `https://router-link.world3.ai/api` and pass your RouterLink key.

## 4. Watch your spend

Open [**Settings → Logs**](https://routerlink.ai/settings/logs) and **Settings → Usage** to see request volume, latency, and cost broken down by model and key.

## Initiate requests through a third-party client

Already using Claude Code, Codex, or another tool that speaks the Anthropic or OpenAI API? Point it at RouterLink and bring your own key — see the [Integration Guides](https://docs.routerlink.ai/basics/claude-code) for end-to-end setup.