curl https://api.withperf.pro/v1/chat \
  -H "Authorization: Bearer pk_test_your_key_here" \
  -H "Content-Type: application/json" \
  -d '{
    "messages": [
      {
        "role": "user",
        "content": "What are the three primary colors?"
      }
    ]
  }'

{
  "model_used": "gpt-4o-mini",
  "output": "The three primary colors are red, blue, and yellow.",
  "billing": {
    "cost_usd": 0.00012
  },
  "tokens": {
    "input": 15,
    "output": 12,
    "total": 27
  },
  "metadata": {
    "task_type": "general",
    "latency_ms": 234,
    "routing_reason": "Optimal for simple queries"
  }
}

curl https://api.withperf.pro/v1/chat \
  -H "Authorization: Bearer pk_test_your_key_here" \
  -H "Content-Type: application/json" \
  -d '{
    "messages": [
      {
        "role": "user",
        "content": "Write a comprehensive analysis of climate change impacts..."
      }
    ],
    "max_cost_per_call": 0.005
  }'

curl https://api.withperf.pro/v1/chat/stream \
  -H "Authorization: Bearer pk_test_your_key_here" \
  -H "Content-Type: application/json" \
  -d '{
    "messages": [
      {
        "role": "user",
        "content": "Explain quantum computing"
      }
    ]
  }'

data: {"chunk": "Quantum", "done": false}

data: {"chunk": " computing", "done": false}

data: {"chunk": " uses", "done": false}

data: {"model_used": "claude-sonnet-4-5", "billing": {...}, "done": true}

import requests

url = "https://api.withperf.pro/v1/chat"
headers = {
    "Authorization": "Bearer pk_test_your_key_here",
    "Content-Type": "application/json"
}
payload = {
    "messages": [
        {"role": "user", "content": "Hello, world!"}
    ],
    "max_cost_per_call": 0.01
}

response = requests.post(url, json=payload, headers=headers)
data = response.json()

print(f"Response: {data['output']}")
print(f"Cost: ${data['billing']['cost_usd']:.5f}")
print(f"Model: {data['model_used']}")

const response = await fetch('https://api.withperf.pro/v1/chat', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer pk_test_your_key_here',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    messages: [
      { role: 'user', content: 'Hello, world!' }
    ],
    max_cost_per_call: 0.01
  })
});

const data = await response.json();
console.log('Response:', data.output);
console.log('Cost: $', data.billing.cost_usd);
console.log('Model:', data.model_used);

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "net/http"
)

type Message struct {
    Role    string `json:"role"`
    Content string `json:"content"`
}

type Request struct {
    Messages       []Message `json:"messages"`
    MaxCostPerCall float64   `json:"max_cost_per_call"`
}

func main() {
    req := Request{
        Messages: []Message{
            {Role: "user", Content: "Hello, world!"},
        },
        MaxCostPerCall: 0.01,
    }

    jsonData, _ := json.Marshal(req)

    httpReq, _ := http.NewRequest("POST",
        "https://api.withperf.pro/v1/chat",
        bytes.NewBuffer(jsonData))

    httpReq.Header.Set("Authorization", "Bearer pk_test_your_key_here")
    httpReq.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, _ := client.Do(httpReq)
    defer resp.Body.Close()

    var result map[string]interface{}
    json.NewDecoder(resp.Body).Decode(&result)

    fmt.Println("Response:", result["output"])
    fmt.Println("Cost:", result["billing"].(map[string]interface{})["cost_usd"])
}

# Data Extraction - uses efficient models
{
  "messages": [{"role": "user", "content": "Extract email and phone from: John Doe [email protected] 555-1234"}]
}

# Complex Reasoning - uses powerful models
{
  "messages": [{"role": "user", "content": "Solve this logic puzzle: If all A are B..."}]
}

# Code Generation - uses code-specialized models
{
  "messages": [{"role": "user", "content": "Write a binary search in Python"}]
}

{
  "messages": [
    {"role": "user", "content": "What is photosynthesis?"},
    {"role": "assistant", "content": "Photosynthesis is..."},
    {"role": "user", "content": "How does it relate to cellular respiration?"}
  ]
}

{
  "messages": [
    {
      "role": "user",
      "content": "Extract structured data from: 'John Smith, 35 years old, lives in NYC'\n\nReturn JSON with name, age, location"
    }
  ],
  "response_format": "json"
}

try:
    response = requests.post(url, json=payload, headers=headers)
    response.raise_for_status()
    data = response.json()
except requests.exceptions.HTTPError as e:
    if response.status_code == 429:
        print("Rate limit exceeded. Retry after:",
              response.headers.get('Retry-After'))
    elif response.status_code == 401:
        print("Invalid API key")
    elif response.status_code == 400:
        print("Invalid request:", response.json())
    else:
        print("Error:", e)