Skip to main content
GET STARTED

Quickstart

Sign up, get your tokens, and make your first governed LLM call. Five minutes end-to-end.

The fastest path from zero to a governed LLM call. Five minutes, free tier, no credit card.

1. Create an account

Two paths. Both end at the same place — a page with your admin token (rg_adm_*) and your first agent API key (rg_agt_*).

Option A · Have your agent do it

If you're using Claude Code, Cursor, Codex, or any agent runtime, the agent can drive the whole signup flow. Open rungate.dev/signup and copy the prompt from the recommended card into your agent. The agent will:

  1. Ask you for your email.
  2. POST /auth/start from its own runtime (no browser CORS issues).
  3. Tell you to click the magic link in your inbox.
  4. Wait for you to paste the two tokens back from the dashboard's /auth/credentials page.
  5. Save them to ~/.rungate/config.toml (chmod 0600) and verify the setup with a GET /v1/me call.

Option B · Plain email signup

Go to https://app.rungate.dev/auth, enter your email, click the magic link in the message we send you, pick an organization name. You'll land on a credentials page with both tokens. Copy them — the page warns you, accurately, that you can't see them again.

Save the tokens immediately. Tokens are hashed in storage. The raw values are shown once, at issue time. If you lose them you'll need to rotate via the dashboard or admin API.

2. Make your first call

Point your OpenAI or Anthropic SDK at Rungate. The base_url is https://app.rungate.dev/v1. The API key is your rg_agt_* token.

OpenAI SDK (Python)

from openai import OpenAI

client = OpenAI(
    base_url="https://app.rungate.dev/v1",
    api_key="rg_agt_your_token_here",
)

response = client.chat.completions.create(
    model="gpt-4",
    messages=[{"role": "user", "content": "Hello, Rungate."}],
)
print(response.choices[0].message.content)

Anthropic SDK (TypeScript)

import Anthropic from '@anthropic-ai/sdk';

const client = new Anthropic({
  baseURL: 'https://app.rungate.dev/v1',
  apiKey: 'rg_agt_your_token_here',
});

const response = await client.messages.create({
  model: 'claude-sonnet-4',
  max_tokens: 256,
  messages: [{ role: 'user', content: 'Hello, Rungate.' }],
});
console.log(response.content);

curl

curl -X POST https://app.rungate.dev/v1/chat/completions \
  -H "Authorization: Bearer rg_agt_your_token_here" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-4",
    "messages": [{"role": "user", "content": "Hello, Rungate."}]
  }'

The response is the provider's native format, unchanged. Rungate just forwarded it.

3. See the run

Open the dashboard at app.rungate.dev/runs. You should see one run with one step (the call you just made), auto-grouped because you didn't pass an explicit run ID. Click in to see latency, cost, model, and the full request/response.

4. Group calls into a run (optional, recommended)

Pass an x-rungate-run-id header to group multiple calls into one run. Same ID = same run. Budgets, policies, and the audit trail apply to the run as a whole. 

# OpenAI SDK
response = client.chat.completions.create(
    model="gpt-4",
    messages=[...],
    extra_headers={
        "x-rungate-run-id": "run_customer_refund_2026_04_26",
    },
)

See Runs for the full grouping semantics — auto-close timeout, manual completion, long-horizon workflows.

5. Add a budget

Create a policy with a budget cap and attach it to your agent. Open the dashboard's Policies page → New policy → set Max USD per run to something low (e.g. $0.50) → save → assign it to your agent.

Now run a multi-call workflow. When cumulative spend crosses the cap, the next call gets 402 Payment Required with the full context. Your agent stops without the human getting a surprise bill.

You're done

From here, depending on what you want to build: