curl https://spiderssense.com/v1/key \
  -H "Authorization: Bearer sk-uno-YOUR_KEY"

{
  "data": {
    "id": 1050907,
    "name": "new",
    "key_prefix": "sk-uno-a1da6",
    "is_active": true,
    "is_expired": false,
    "balance": "$31.22",
    "balance_micro": 31221741,
    "spent": "$18.78",
    "spent_micro": 18778259,
    "usage": {
      "input_tokens": 89167860,
      "output_tokens": 637428,
      "cached_tokens": 63619449,
      "requests": 719
    },
    "last_used_at": "2026-07-06T15:51:55.000Z",
    "created_at": "2026-06-30T18:31:17.000Z",
    "expires_at": null
  }
}

curl https://spiderssense.com/v1/messages/count_tokens \
  -H "Authorization: Bearer sk-uno-YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-opus-4.8",
    "system": "You are a scientist",
    "messages": [{ "role": "user", "content": "Hello, Claude" }]
  }'

from anthropic import Anthropic

client = Anthropic(
    base_url="https://spiderssense.com",
    api_key="sk-uno-YOUR_KEY",
)
response = client.messages.count_tokens(
    model="claude-opus-4.8",
    system="You are a scientist",
    messages=[{"role": "user", "content": "Hello, Claude"}],
)
print(response.json())

{ "input_tokens": 15 }

curl https://spiderssense.com/v1/chat/completions \
  -H "Authorization: Bearer sk-uno-YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openai/gpt-image-2",
    "messages": [
      { "role": "user", "content": "A red fox in a snowy forest, cinematic" }
    ],
    "modalities": ["image", "text"]
  }' \
  --max-time 180 \
  -o image.json

{
  "choices": [
    {
      "message": {
        "content": "",
        "images": [
          {
            "image_url": {
              "url": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAA…"
            }
          }
        ]
      }
    }
  ],
  "usage": {
    "prompt_tokens": 14,
    "completion_tokens": 229,
    "completion_tokens_details": { "image_tokens": 1 },
    "cost": 0.04
  }
}

# pull the data URL, strip the prefix, decode to a PNG
jq -r '.choices[0].message.images[0].image_url.url' image.json \
  | sed 's/^data:image\/png;base64,//' \
  | base64 -d > image.png

# encode the source image as a data URL
IMG_B64=$(base64 -w 0 source.png)

curl https://spiderssense.com/v1/chat/completions \
  -H "Authorization: Bearer sk-uno-YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d "{
    \"model\": \"openai/gpt-image-2\",
    \"messages\": [{
      \"role\": \"user\",
      \"content\": [
        { \"type\": \"text\", \"text\": \"Replace the red car with a blue car\" },
        { \"type\": \"image_url\", \"image_url\": { \"url\": \"data:image/png;base64,$IMG_B64\" } }
      ]
    }],
    \"modalities\": [\"image\", \"text\"]
  }" \
  --max-time 180 \
  -o image.json

import base64
from openai import OpenAI

client = OpenAI(
    base_url="https://spiderssense.com/v1",
    api_key="sk-uno-YOUR_KEY",
    timeout=180.0,
)

source = base64.b64encode(open("source.png", "rb").read()).decode()
data_url = f"data:image/png;base64,{source}"

resp = client.chat.completions.create(
    model="openai/gpt-image-2",
    messages=[{
        "role": "user",
        "content": [
            {
                "type": "text",
                "text": "Replace the red car with a blue car; keep the background",
            },
            {
                "type": "image_url",
                "image_url": {"url": data_url},
            },
        ],
    }],
    extra_body={"modalities": ["image", "text"]},
)

result_url = resp.choices[0].message.images[0]["image_url"]["url"]
result = base64.b64decode(result_url.split(",", 1)[1])
open("edited.png", "wb").write(result)
print(f"saved edited.png ({len(result)} bytes)")

import base64
from openai import OpenAI

client = OpenAI(
    base_url="https://spiderssense.com/v1",
    api_key="sk-uno-YOUR_KEY",
    timeout=180.0,
)
resp = client.chat.completions.create(
    model="openai/gpt-image-2",
    messages=[{"role": "user", "content": "A red fox in a snowy forest, cinematic"}],
    extra_body={"modalities": ["image", "text"]},
)
url = resp.choices[0].message.images[0]["image_url"]["url"]
b64 = url.split(",", 1)[1]
open("image.png", "wb").write(base64.b64decode(b64))
print("saved image.png")

curl https://spiderssense.com/v1/images/generations \
  -H "Authorization: Bearer sk-uno-YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "IMAGE_MODEL_FROM_CATALOG",
    "prompt": "A glass observatory above a bioluminescent forest",
    "n": 1,
    "response_format": "b64_json"
  }' \
  --max-time 300 \
  -o generated-image.json

jq -r '.data[0].b64_json' generated-image.json | base64 -d > generated-image.png

import base64
from openai import OpenAI

client = OpenAI(
    base_url="https://spiderssense.com/v1",
    api_key="sk-uno-YOUR_KEY",
    timeout=300.0,
)
response = client.images.generate(
    model="IMAGE_MODEL_FROM_CATALOG",
    prompt="A glass observatory above a bioluminescent forest",
    n=1,
    response_format="b64_json",
)
image = base64.b64decode(response.data[0].b64_json)
open("generated-image.png", "wb").write(image)
print(f"saved generated-image.png ({len(image)} bytes)")

{
  "created": 1783593159,
  "model": "IMAGE_MODEL_FROM_CATALOG",
  "data": [
    {
      "b64_json": "iVBORw0KGgoAAAANSUhEUgAA…",
      "revised_prompt": "A glass observatory above a bioluminescent forest"
    }
  ]
}

# 1) Submit a job. This returns HTTP 202 immediately.
JOB_ID=$(curl -sS https://spiderssense.com/v1/videos/generations \
  -H "Authorization: Bearer sk-uno-YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "kling-v3-t2v",
    "prompt": "waves crashing on a rocky shore at sunset",
    "duration_seconds": 8,
    "aspect_ratio": "16:9"
  }' | jq -r '.id')

# 2) Poll with the same bearer key until completed or failed.
while true; do
  RESULT=$(curl -sS "https://spiderssense.com/v1/videos/generations/$JOB_ID" \
    -H "Authorization: Bearer sk-uno-YOUR_KEY")
  STATUS=$(printf '%s' "$RESULT" | jq -r '.status')
  [ "$STATUS" = "completed" ] && break
  [ "$STATUS" = "failed" ] && { printf '%s\n' "$RESULT"; exit 1; }
  sleep 5
done

# 3) The signed URL is temporary. Download the video immediately.
URL=$(printf '%s' "$RESULT" | jq -r '.url')
curl -L "$URL" -o video.mp4

import time
import httpx

base_url = "https://spiderssense.com"
headers = {"Authorization": "Bearer sk-uno-YOUR_KEY"}

with httpx.Client(timeout=60.0) as client:
    response = client.post(
        f"{base_url}/v1/videos/generations",
        headers=headers,
        json={
            "model": "Wan-AI/Wan2.6-T2V",
            "prompt": "a red apple on a wooden table, cinematic close-up",
            "duration_seconds": 8,
            "aspect_ratio": "16:9",
        },
    )
    response.raise_for_status()
    job = response.json()  # HTTP 202: {"id": ..., "status": ...}

    while job["status"] in {"queued", "running"}:
        time.sleep(5)
        response = client.get(
            f"{base_url}/v1/videos/generations/{job['id']}",
            headers=headers,
        )
        response.raise_for_status()
        job = response.json()

    if job["status"] == "failed":
        raise RuntimeError(f"Video generation failed: {job}")

    # The completed URL is signed and temporary, so download it now.
    video = client.get(job["url"])
    video.raise_for_status()
    open("video.mp4", "wb").write(video.content)
    print(f"saved video.mp4 ({job['duration_seconds']} s); URL expires {job['expires_at']}")

curl https://spiderssense.com/v1/videos/generations \
  -H "Authorization: Bearer sk-uno-YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "google/veo-3.1-1080p-audio",
    "prompt": "waves crashing on a rocky shore at sunset, cinematic slow motion",
    "duration_seconds": 8,
    "aspect_ratio": "16:9"
  }' \
  --max-time 300 \
  -o video.json

{
  "created": 1783593159,
  "model": "google/veo-3.1-1080p-audio",
  "data": [
    {
      "b64_json": "AAAAIGZ0eXBpc29tAAACAG…",  // full mp4 in base64
      "mime_type": "video/mp4",
      "resolution": "1080p",
      "duration_seconds": 8
    }
  ],
  "usage": { "video_seconds": 8 }
}

# decode the base64 payload to a playable mp4
jq -r '.data[0].b64_json' video.json | base64 -d > video.mp4

# or in one shot, streaming with python
python -c "
import json, base64, sys
d = json.load(open('video.json'))
open('video.mp4','wb').write(base64.b64decode(d['data'][0]['b64_json']))
"

# Encode the first and optional last frames.
FIRST_B64=$(base64 -w 0 first.png)
LAST_B64=$(base64 -w 0 last.png)

# Omit last_frame for first-frame-only generation.
curl https://spiderssense.com/v1/videos/generations \
  -H "Authorization: Bearer sk-uno-YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d "{
    \"model\": \"google/veo-3.1-1080p-audio\",
    \"prompt\": \"the person smiles and turns to look at the camera\",
    \"duration_seconds\": 8,
    \"image\": {
      \"b64_json\": \"$FIRST_B64\",
      \"mime_type\": \"image/png\"
    },
    \"last_frame\": {
      \"b64_json\": \"$LAST_B64\",
      \"mime_type\": \"image/png\"
    }
  }" \
  --max-time 300 \
  -o video.json

import base64, httpx

client = httpx.Client(timeout=300.0)
resp = client.post(
    "https://spiderssense.com/v1/videos/generations",
    headers={"Authorization": "Bearer sk-uno-YOUR_KEY"},
    json={
        "model": "google/veo-3.1-1080p-audio",
        "prompt": "a red apple on a wooden table, cinematic close-up",
        "duration_seconds": 4,
    },
)
data = resp.json()
mp4 = base64.b64decode(data["data"][0]["b64_json"])
open("video.mp4", "wb").write(mp4)
print(f"saved {len(mp4)} bytes, billed {data['usage']['video_seconds']} s")