Rate Limit Headers

import "dotenv/config";

const API_KEY = process.env.SWARMS_API_KEY;
const BASE_URL = "https://api.swarms.world";

if (!API_KEY) {
  throw new Error("SWARMS_API_KEY is not set");
}

const response = await fetch(`${BASE_URL}/v1/agent/completions`, {
  method: "POST",
  headers: {
    "x-api-key": API_KEY,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    agent_config: {
      agent_name: "test",
      model_name: "gpt-4o-mini",
      system_prompt: "You are helpful.",
      max_loops: 1,
    },
    task: "Say hello.",
  }),
});

// Read rate limit headers
const remaining = parseInt(response.headers.get("X-RateLimit-Remaining-Minute") ?? "0");
const limit = parseInt(response.headers.get("X-RateLimit-Limit-Minute") ?? "0");
const tier = response.headers.get("X-RateLimit-Tier");

console.log(`Tier: ${tier} | ${remaining}/${limit} requests remaining this minute`);

use std::env;
use reqwest::blocking::Client;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = env::var("SWARMS_API_KEY")
        .expect("SWARMS_API_KEY environment variable is required");

    let client = Client::new();

    let response = client
        .post("https://api.swarms.world/v1/agent/completions")
        .header("x-api-key", &api_key)
        .header("Content-Type", "application/json")
        .body(r#"{
            "agent_config": {
                "agent_name": "test",
                "model_name": "gpt-4o-mini",
                "system_prompt": "You are helpful.",
                "max_loops": 1
            },
            "task": "Say hello."
        }"#)
        .send()?;

    // Read rate limit headers
    let remaining = response.headers()
        .get("X-RateLimit-Remaining-Minute")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("0");
    let limit = response.headers()
        .get("X-RateLimit-Limit-Minute")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("0");
    let tier = response.headers()
        .get("X-RateLimit-Tier")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("unknown");

    println!("Tier: {} | {}/{} requests remaining this minute", tier, remaining, limit);

    Ok(())
}

package main

import (
    "fmt"
    "log"
    "net/http"
    "os"
    "strings"
)

func main() {
    apiKey := os.Getenv("SWARMS_API_KEY")
    if apiKey == "" {
        log.Fatal("SWARMS_API_KEY environment variable is required")
    }

    body := strings.NewReader(`{
        "agent_config": {
            "agent_name": "test",
            "model_name": "gpt-4o-mini",
            "system_prompt": "You are helpful.",
            "max_loops": 1
        },
        "task": "Say hello."
    }`)

    req, err := http.NewRequest("POST", "https://api.swarms.world/v1/agent/completions", body)
    if err != nil {
        log.Fatal(err)
    }

    req.Header.Set("x-api-key", apiKey)
    req.Header.Set("Content-Type", "application/json")

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        log.Fatal(err)
    }
    defer resp.Body.Close()

    // Read rate limit headers
    remaining := resp.Header.Get("X-RateLimit-Remaining-Minute")
    limit := resp.Header.Get("X-RateLimit-Limit-Minute")
    tier := resp.Header.Get("X-RateLimit-Tier")

    fmt.Printf("Tier: %s | %s/%s requests remaining this minute\n", tier, remaining, limit)
}

# The -i flag prints response headers
curl -i -X POST https://api.swarms.world/v1/agent/completions \
  -H "x-api-key: $SWARMS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "agent_config": {
      "agent_name": "test",
      "model_name": "gpt-4o-mini",
      "system_prompt": "You are helpful.",
      "max_loops": 1
    },
    "task": "Say hello."
  }'

async function callWithRetry(
  url: string,
  headers: Record<string, string>,
  payload: object,
  maxRetries = 3
): Promise<Response> {
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    const response = await fetch(url, {
      method: "POST",
      headers,
      body: JSON.stringify(payload),
    });

    if (response.status === 429) {
      const retryAfter = parseInt(response.headers.get("Retry-After") ?? "60");
      console.log(`Rate limited. Retrying in ${retryAfter}s...`);
      await new Promise((resolve) => setTimeout(resolve, retryAfter * 1000));
      continue;
    }

    return response;
  }

  throw new Error("Max retries exceeded");
}

use reqwest::blocking::{Client, Response};
use std::thread;
use std::time::Duration;

fn call_with_retry(
    client: &Client,
    url: &str,
    api_key: &str,
    body: &str,
    max_retries: u32,
) -> Result<Response, Box<dyn std::error::Error>> {
    for _ in 0..max_retries {
        let response = client
            .post(url)
            .header("x-api-key", api_key)
            .header("Content-Type", "application/json")
            .body(body.to_string())
            .send()?;

        if response.status().as_u16() == 429 {
            let retry_after: u64 = response.headers()
                .get("Retry-After")
                .and_then(|v| v.to_str().ok())
                .and_then(|v| v.parse().ok())
                .unwrap_or(60);
            println!("Rate limited. Retrying in {}s...", retry_after);
            thread::sleep(Duration::from_secs(retry_after));
            continue;
        }

        return Ok(response);
    }

    Err("Max retries exceeded".into())
}

package main

import (
    "fmt"
    "net/http"
    "strconv"
    "strings"
    "time"
)

func callWithRetry(url, apiKey, body string, maxRetries int) (*http.Response, error) {
    for attempt := 0; attempt < maxRetries; attempt++ {
        req, err := http.NewRequest("POST", url, strings.NewReader(body))
        if err != nil {
            return nil, err
        }
        req.Header.Set("x-api-key", apiKey)
        req.Header.Set("Content-Type", "application/json")

        resp, err := http.DefaultClient.Do(req)
        if err != nil {
            return nil, err
        }

        if resp.StatusCode == 429 {
            retryAfter, _ := strconv.Atoi(resp.Header.Get("Retry-After"))
            if retryAfter == 0 {
                retryAfter = 60
            }
            fmt.Printf("Rate limited. Retrying in %ds...\n", retryAfter)
            resp.Body.Close()
            time.Sleep(time.Duration(retryAfter) * time.Second)
            continue
        }

        return resp, nil
    }

    return nil, fmt.Errorf("max retries exceeded")
}