Usage Report

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

const headers = {
    "x-api-key": API_KEY,
    "Content-Type": "application/json"
};

async function getUsageReport(period = "month") {
    try {
        const response = await fetch(
            `${BASE_URL}/v1/usage/report?period=${period}`,
            { method: "GET", headers }
        );

        if (!response.ok) {
            throw new Error(`HTTP error! status: ${response.status}`);
        }

        const data = await response.json();
        console.log(`Period: ${data.period}`);
        console.log(`Range: ${data.start_date} to ${data.end_date}`);
        console.log(`Days with activity: ${data.results.length}\n`);

        for (const day of data.results) {
            console.log(
                `  ${day.day}: ` +
                `cost=$${day.total_cost.toFixed(4)}, ` +
                `in=${day.input_tokens.toLocaleString()}, ` +
                `out=${day.output_tokens.toLocaleString()}, ` +
                `reqs=${day.request_count}`
            );
        }

        return data;
    } catch (error) {
        console.error("Error fetching usage report:", error);
        return null;
    }
}

getUsageReport("week");

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");
}

interface UsageReportDay {
  day: string;
  total_cost: number;
  input_tokens: number;
  output_tokens: number;
  request_count: number;
}

interface UsageReportOutput {
  results: UsageReportDay[];
  period: string;
  start_date: string;
  end_date: string;
  timestamp: string;
}

async function getUsageReport(
  period: string = "month"
): Promise<UsageReportOutput | null> {
  const res = await fetch(
    `${BASE_URL}/v1/usage/report?period=${period}`,
    {
      method: "GET",
      headers: {
        "x-api-key": API_KEY,
        "Content-Type": "application/json",
      },
    }
  );

  if (!res.ok) {
    const text = await res.text();
    throw new Error(`HTTP ${res.status}: ${text}`);
  }

  const data = (await res.json()) as UsageReportOutput;
  console.log(`Period: ${data.period}`);
  console.log(`Range: ${data.start_date} to ${data.end_date}`);
  console.log(`Days with activity: ${data.results.length}\n`);

  for (const day of data.results) {
    console.log(
      `  ${day.day}: cost=$${day.total_cost.toFixed(4)}, ` +
      `in=${day.input_tokens.toLocaleString()}, ` +
      `out=${day.output_tokens.toLocaleString()}, ` +
      `reqs=${day.request_count}`
    );
  }

  return data;
}

void getUsageReport("week").catch(console.error);

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

#[derive(Debug, Deserialize)]
struct UsageReportDay {
    day: String,
    total_cost: f64,
    input_tokens: u64,
    output_tokens: u64,
    request_count: u64,
}

#[derive(Debug, Deserialize)]
struct UsageReportOutput {
    results: Vec<UsageReportDay>,
    period: String,
    start_date: String,
    end_date: String,
    timestamp: String,
}

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
        .get("https://api.swarms.world/v1/usage/report?period=week")
        .header("x-api-key", &api_key)
        .header("Content-Type", "application/json")
        .send()?;

    let data: UsageReportOutput = response.json()?;

    println!("Period: {}", data.period);
    println!("Range: {} to {}", data.start_date, data.end_date);
    println!("Days with activity: {}\n", data.results.len());

    for day in &data.results {
        println!(
            "  {}: cost=${:.4}, in={}, out={}, reqs={}",
            day.day, day.total_cost, day.input_tokens,
            day.output_tokens, day.request_count,
        );
    }

    Ok(())
}

package main

import (
    "encoding/json"
    "fmt"
    "log"
    "net/http"
    "os"
)

type UsageReportDay struct {
    Day          string  `json:"day"`
    TotalCost    float64 `json:"total_cost"`
    InputTokens  int     `json:"input_tokens"`
    OutputTokens int     `json:"output_tokens"`
    RequestCount int     `json:"request_count"`
}

type UsageReportOutput struct {
    Results   []UsageReportDay `json:"results"`
    Period    string           `json:"period"`
    StartDate string           `json:"start_date"`
    EndDate   string           `json:"end_date"`
    Timestamp string           `json:"timestamp"`
}

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

    req, err := http.NewRequest("GET", "https://api.swarms.world/v1/usage/report?period=week", nil)
    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()

    var data UsageReportOutput
    if err := json.NewDecoder(resp.Body).Decode(&data); err != nil {
        log.Fatal(err)
    }

    fmt.Printf("Period: %s\n", data.Period)
    fmt.Printf("Range: %s to %s\n", data.StartDate, data.EndDate)
    fmt.Printf("Days with activity: %d\n\n", len(data.Results))

    for _, day := range data.Results {
        fmt.Printf("  %s: cost=$%.4f, in=%d, out=%d, reqs=%d\n",
            day.Day, day.TotalCost, day.InputTokens,
            day.OutputTokens, day.RequestCount,
        )
    }
}

# Last 30 days (default)
curl -X GET "https://api.swarms.world/v1/usage/report" \
  -H "x-api-key: $SWARMS_API_KEY"

# Last 7 days
curl -X GET "https://api.swarms.world/v1/usage/report?period=week" \
  -H "x-api-key: $SWARMS_API_KEY"

# Custom date range
curl -X GET "https://api.swarms.world/v1/usage/report?start_date=2026-03-01&end_date=2026-03-31" \
  -H "x-api-key: $SWARMS_API_KEY"