Onboarding Guide — GetWrangler

Before You Begin

What You Need

A GetWrangler account — sign up at app.getwrangler.ai
A GetWrangler bearer token — issued automatically when your account is created
Your existing LLM integration — any application already calling an OpenAI-compatible API
An Abacus AI API key (recommended) — for full-fidelity routing; trial mode works without one

* GetWrangler provides access to major frontier models (Claude, GPT-4o, Gemini) via a client-owned Abacus.ai account, plus native direct endpoint support for Anthropic, OpenAI, and Google APIs via vault-stored keys and custom endpoints.

Two ways to start

Trial mode — your account starts immediately using GetWrangler's operator credentials. You see routing behavior and savings projections right away, but responses use a free model (Gemini Flash) and are rate-limited at 10,000 requests.

Full evaluation (recommended) — add your Abacus AI API key in your dashboard. Real-world response quality, no rate limits beyond your Abacus plan, and an accurate savings baseline using your actual model costs.

Model Coverage

Supported Models

What's available

GetWrangler routes through Abacus AI, which covers the major frontier models — Claude (Anthropic), GPT-4o (OpenAI), and Gemini (Google). These models handle roughly 90% of enterprise workloads, and you use them with the same model names you already have in your code. No model-name remapping required.

Known gaps

Fine-tuned and custom models — not currently routable via Abacus; requires a direct endpoint
Newest model releases — there is occasionally a brief lag before newly released models are available through Abacus
Some advanced API features — a small number of provider-specific capabilities may not be available through the proxy layer

Native endpoint support

For teams with fine-tuned model investments or existing direct endpoint integrations, GetWrangler supports native endpoints for Anthropic, OpenAI, and Google APIs directly. Register up to 5 custom endpoints per account, each with a vault-stored API key and your own contracted pricing rates. Click Save and Test to verify the connection — verified endpoints show a 🔓 icon, unverified or failed ones show 🔒. This lets teams apply GetWrangler's cost optimization and governance to their existing infrastructure without switching providers.

Current positioning: GetWrangler delivers cost optimization and governance that direct provider endpoints don't provide. Whether you route through Abacus for major frontier models or register your own endpoint directly, you get those benefits today.

Connecting Claude Code or Codex CLI

Claude Code and Codex CLI connect directly to your own Anthropic or OpenAI account through GetWrangler, giving you usage tracking and billing attribution without changing how either tool behaves.

1. Add your key — In your dashboard, open the Endpoints & Integrations panel (the same panel used for custom endpoints). You'll see fixed rows for Claude Code and Codex CLI — paste in your own Anthropic API key or OpenAI API key and click Save, then Test to confirm the connection.
2. Point Claude Code at GetWrangler — set ANTHROPIC_BASE_URL=https://api.getwrangler.ai and ANTHROPIC_AUTH_TOKEN=<your GetWrangler bearer token>. Use ANTHROPIC_AUTH_TOKEN, not ANTHROPIC_API_KEY — the latter sends a different auth header that GetWrangler won't recognize, so the connection will fail.
3. Point Codex CLI at GetWrangler — add a custom model provider to ~/.codex/config.toml:
model_provider = "getwrangler" [model_providers.getwrangler] name = "GetWrangler" base_url = "https://api.getwrangler.ai/v1" env_key = "OPENAI_API_KEY" wire_api = "responses"
then set OPENAI_API_KEY=<your GetWrangler bearer token> in your environment.

Tracking only, not cost optimization: connecting either tool this way tracks and bills your usage but does not reduce your existing Anthropic/OpenAI costs — GetWrangler forwards the request to your own account unmodified, by design. An opt-in toggle to enable tier-routing savings on this traffic is planned but not yet built.

Key Architecture

Understanding Your Two Keys

Admin — entered once

Your Abacus API Key

Obtained from your Abacus.ai account
Entered once in your dashboard under Settings → API Configuration
Stored in an encrypted vault — never visible after entry
Used by GetWrangler server-side to route requests upstream
Your developers never use or see this key

Developers — one per team

GetWrangler API Tokens

Created in your dashboard under Tokens → Create New Token
Replace your Abacus API key in application code
One token per team (e.g. Engineering, Data Science, QA) gives per-team spend visibility
If a token is compromised, deactivate it instantly without affecting other teams

If you're currently on OpenAI directly — minimal change

Before

client = OpenAI(
    api_key="sk-your-openai-key",
)

After

client = OpenAI(
    api_key="gw_your_token_here",
    base_url="https://api.getwrangler.ai/v1",
)

Model names, request format, and response format are unchanged — just add base_url and swap the key. GetWrangler is fully OpenAI-compatible.

If you're currently on Anthropic directly — requires an SDK swap

Before

client = anthropic.Anthropic(
    api_key="sk-ant-your-key",
)
response = client.messages.create(
    model="claude-sonnet-5",
    max_tokens=1024,
    messages=[...],
)

After

client = openai.OpenAI(
    api_key="gw_your_token_here",
    base_url="https://api.getwrangler.ai/v1",
)
response = client.chat.completions.create(
    model="claude-sonnet-5",
    messages=[...],
)

This is not a minimal change. Moving from Anthropic's native SDK to GetWrangler's OpenAI-compatible endpoint means swapping the client library and the method call shape (messages.create → chat.completions.create), not just the base URL and key.

Step-by-Step Setup

Integrating GetWrangler

1

Sign in and get your bearer token

Log in to app.getwrangler.ai. Navigate to the Tokens section of your dashboard. Your initial token is listed there. Copy it — you will use it in the next step.
2

Change your API base URL

Swap your LLM provider's endpoint for the GetWrangler proxy. This is the only URL change you need to make.

# Before OPENAI_BASE_URL=https://api.openai.com/v1 # After OPENAI_BASE_URL=https://api.getwrangler.ai/v1

Everything else — model names, request format, response format — stays the same. GetWrangler is fully OpenAI-compatible.
3

Set your bearer token

Replace your LLM provider's API key with your GetWrangler bearer token. In most SDKs this is the api_key or OPENAI_API_KEY environment variable.

# Environment variable OPENAI_API_KEY=gw_your_token_here # Or as an HTTP header Authorization: Bearer gw_your_token_here
4

Verify the integration

Send a test request to confirm traffic is flowing through GetWrangler.

curl -X POST https://api.getwrangler.ai/v1/chat/completions \ -H "Authorization: Bearer gw_your_token_here" \ -H "Content-Type: application/json" \ -d '{"model":"claude-3-5-sonnet-20241022","messages":[{"role":"user","content":"ping"}]}'

You should receive a normal chat completion response. Your dashboard at app.getwrangler.ai will show the request within a few seconds.
5

Shadow mode begins automatically

For 14 days, all requests pass through to your provider unchanged. GetWrangler observes your traffic, builds your baseline, and projects achievable savings — visible in your dashboard in real time. No action required.
6

Add a payment method and activate live routing

When you are ready, add a payment method in your dashboard and flip the switch to activate live routing. GetWrangler begins routing through deterministic handlers, semantic cache, and the tier router. Your application receives identical responses — faster and cheaper.

View plan options and pricing →

SDK Examples

Configuring Your SDK

Python (openai SDK)

import openai

client = openai.OpenAI(
    api_key="gw_your_token_here",
    base_url="https://api.getwrangler.ai/v1",
)

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

Node.js (openai SDK)

import OpenAI from 'openai';

const client = new OpenAI({
  apiKey: 'gw_your_token_here',
  baseURL: 'https://api.getwrangler.ai/v1',
});

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

LangChain (Python)

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model="claude-3-5-sonnet-20241022",
    openai_api_key="gw_your_token_here",
    openai_api_base="https://api.getwrangler.ai/v1",
)

Token Management

Managing API Tokens

Why use multiple tokens?

Separate tokens for each application, team, or pipeline give you per-token spend visibility, independent daily thresholds, and named attribution in your dashboard — so you know exactly which service is spending what.

production-api — your customer-facing application
data-pipeline — nightly batch processing jobs
eng-sandbox — engineering experiments and testing
analytics-team — data science workloads

Creating additional tokens

Log in to app.getwrangler.ai and navigate to the Tokens section of your dashboard. Click Create New Token, give it a label (e.g. 'production-api' or 'data-pipeline'), and optionally set a daily spend threshold. Your new token is active immediately and can be used in any application following the same setup steps above.

Your token is shown only once at creation time. Copy it immediately and store it in your secrets manager or environment variables — it cannot be retrieved again.

Model preference — optional, advanced

Every new token defaults to GetWrangler chooses — no model preference. This is the maximum savings setting and the recommended default for most teams. GetWrangler selects the least-cost eligible model for each LLM-tier request automatically.

Model preference is an optional override for teams that require a specific model. To set one, click the arrow (▸) next to any active token in your dashboard Tokens section to expand the model preference selector. You do not need to configure this during basic onboarding.

Tip: Start with the default. You can add a model preference at any time without any code changes in your application.

Per-token daily thresholds

Set a daily dollar limit on any token. When spending crosses the threshold, GetWrangler sends an alert email to the named contact for that token. Requests continue unaffected — thresholds are alert triggers, not blockers.

Set threshold — click the Daily Limit value in the Tokens table to edit it inline
Remove threshold — clear the field and save to remove the limit
Alert frequency — one email per token per day, regardless of how far over threshold

Deactivating a token

Click Deactivate on any token in your dashboard. The token stops working immediately. Historical spend data associated with the token is preserved. To issue a replacement, create a new token and update your application's configuration.

Per-Call Control

Advanced Routing

By default, GetWrangler picks your model automatically. If you want per-call control — useful for multi-step pipelines like document summarization, where some calls need a cheap model and others need your strongest model — set your token's Model Preference to Let each call decide in the dashboard, then control routing per request.

Explicit model per call

Name the exact model you want for this call. GetWrangler executes it directly — no substitution.

response = client.chat.completions.create(
    model="claude-haiku-4-5-20251001",
    messages=[...]
)
# Executes exactly this model for this call.

Auto-route with a cost ceiling

Prefix the model with getwrangler-auto: to let GetWrangler pick the best fit for the task, but never anything pricier than the named model. Savings are measured against that model's price.

response = client.chat.completions.create(
    model="getwrangler-auto:claude-haiku-4-5-20251001",
    messages=[...]
)
# GetWrangler picks the best fit, but never anything pricier than the
# named model. Savings are measured against that model's price.

Example: a summarization pipeline

A common pattern — cheap model for per-section summaries, a stronger model for the final synthesis, both on one token, no need for multiple API keys.

# Same client, same token — "Let each call decide" set once in the dashboard.

# Step 1: summarize each section with a cheap, capped model.
section_summaries = []
for section in document_sections:
    resp = client.chat.completions.create(
        model="getwrangler-auto:claude-haiku-4-5-20251001",
        messages=[{"role": "user", "content": f"Summarize: {section}"}],
    )
    section_summaries.append(resp.choices[0].message.content)

# Step 2: synthesize the final summary with a stronger model.
final = client.chat.completions.create(
    model="claude-sonnet-4-6",
    messages=[{"role": "user", "content": f"Combine into one summary: {section_summaries}"}],
)

Need more headroom for the final step? Swap in claude-opus-4-8 as the synthesis model — a stronger, higher-cost option for calls where synthesis quality matters more than per-call cost.

Note: "getwrangler-auto" alone, with no anchor model, is not valid — auto-routing always requires a cost ceiling. This request returns a 400:

{
  "error": {
    "message": "Auto-routing requires an anchor model. Use \"getwrangler-auto:<model-id>\" instead of a bare \"getwrangler-auto\" (e.g. \"getwrangler-auto:claude-haiku-4-5-20251001\").",
    "type": "auto_route_anchor_required",
    "code": 400
  }
}

Token in Code

Using Your Token in Code

Your GetWrangler token replaces your Abacus API key in your application code. Point your client at the GetWrangler endpoint and use your token as the API key.

Python

from openai import OpenAI

client = OpenAI(
    api_key="gw_your_token_here",
    base_url="https://api.getwrangler.ai/v1"
)

response = client.chat.completions.create(
    model="route-llm",
    messages=[{"role": "user", "content": "Your prompt here"}]
)

Node.js

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: "gw_your_token_here",
  baseURL: "https://api.getwrangler.ai/v1"
});

const response = await client.chat.completions.create({
  model: "route-llm",
  messages: [{ role: "user", content: "Your prompt here" }]
});

Notes

Use route-llm as the model to let GetWrangler choose the least-cost option automatically — this is the recommended default
To use a specific model, replace route-llm with any model ID from your token settings (e.g. claude-sonnet-4-6)
Hard model preference — if your token has a hard model preference set, the model parameter is overridden automatically
One token per team gives you per-team spend visibility in your dashboard

What to Expect

After Integration

Your dashboard

Within minutes of your first request, your dashboard at app.getwrangler.ai shows:

Savings summary — projected savings based on observed traffic
Routing breakdown — how your requests would be classified
Usage by token — spend attribution per API token
Spend velocity — current burn rate and monthly projection

Shadow mode (first 14 days)

All requests pass through to your provider unchanged. GetWrangler observes, classifies, and projects — but does not alter any request. You see exactly what live routing will deliver before committing to it.

Going live

Add a payment method and activate live routing from your dashboard. No code changes required. Your application receives the same responses — GetWrangler handles routing transparently.

View Pricing →

Need Help?

Resources

Help & Documentation — getwrangler.ai/help
How GetWrangler Works — getwrangler.ai/how-it-works
Savings Guide — getwrangler.ai/savings-guide
Governance Guide — getwrangler.ai/governance-guide
Email support — support@getwrangler.ai