Tous les modèles et outils Sataves, avec une seule clé API

Aperçu

• Chat et agents : POST /v1/chat/completions et /v1/responses (formats OpenAI) et POST /v1/messages (format Anthropic) avec outils (function calling), entrée d'image et streaming ; ainsi que /v1/audio/speech et /v1/audio/transcriptions pour la voix.
• Services AI Studio : Génération d'images et de vidéos, synthèse vocale, transcription audio, OCR, résumés, traduction, réécriture, musique et embeddings.
• Outils et tâches : Téléchargement par lien, traduction et doublage vidéo, sous-titres, conversion de formats, outils d'image et de police, outils réseau et recherche.
• Civitai et Hugging Face : Résolvez les ressources Civitai prises en charge et les Hugging Face Spaces ; l'exécution nécessite des vérifications d'accès et de compatibilité.
• Information: Modèles, disponibilité, tarifs, statut, solde et utilisation par clé — le tout via l'API.

Chaque requête API est débitée de votre solde exactement comme la même tâche sur le site. Il n'y a aucun abonnement ni frais distinct pour l'API.

Compatibilité et limites

Les tutoriels sont des exemples d'intégration et ne garantissent pas la compatibilité de chaque version du SDK. max_output_tokens est le plafond effectif de l'API ; provider_max_output_tokens correspond à la capacité du modèle. Les requêtes dépassant le plafond de l'API renvoient une erreur 400.

/v1/status reports API/catalog availability; it does not test live provider health or provider credit.

Les tarifs des modèles appliquent la politique actuelle en USD. tiers et adjustments détaillent les tranches d'utilisation, les frais, les remises et les limites. Les autres services nécessitent leur propre devis. La retenue pour les requêtes textuelles prend en compte les entrées, les outils, les médias et la sortie maximale ; les réservations non utilisées sont libérées.

purchase_outcome_unknown signifie que l'achat du numéro n'est pas résolu. Ne réessayez pas avec une nouvelle clé : la réservation est maintenue jusqu'à la réconciliation. Réutilisez la même Idempotency-Key pour récupérer une commande enregistrée ; contactez l'assistance si le résultat auprès du fournisseur reste inconnu.

Démarrage rapide

1. Connectez-vous et créez une clé sous Compte → Clés API. La clé ne s'affiche qu'une seule fois.
2. Placez-la dans la variable d'environnement SATAVES_API_KEY (jamais dans du code côté navigateur ou un dépôt public).
3. Envoyez votre première requête :

export SATAVES_API_KEY="sk-sat-..."

curl https://sataveslabs.com/v1/chat/completions \
  -H "Authorization: Bearer $SATAVES_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openai/gpt-4.1-mini",
    "messages": [{"role": "user", "content": "Write a haiku about the sea."}]
  }'

Consultez les modèles disponibles (aucune clé requise) :

# Every model (public, no key needed)
curl https://sataveslabs.com/v1/models

# Only one kind: chat, ocr, image, video, tts, transcribe, embedding, music
curl "https://sataveslabs.com/v1/models?type=image"

# One model
curl https://sataveslabs.com/v1/models/anthropic/claude-sonnet-4.5

Authentification et portées

Envoyez la clé dans l'un des deux en-têtes :

# OpenAI style (all endpoints)
Authorization: Bearer sk-sat-...

# Anthropic style (also accepted everywhere)
x-api-key: sk-sat-...

Choisissez les portées d'une clé lors de sa création ; toute requête sortant de ce cadre reçoit un code 403. Les paramètres du compte, la connexion, le rechargement du portefeuille, le support et l'administration ne sont pas accessibles avec une clé d'API. L'achat de numéros virtuels requiert la portée numbers. Une clé ne peut pas créer d'autres clés. Les clés sont acceptées dans les en-têtes, jamais dans les cookies de session ou les jetons d'URL.

Les clés peuvent expirer, être révoquées à tout moment et indiquent la date de leur dernière utilisation. Les comptes administrateur ne peuvent pas créer de clés d'API.

Chat — compatible OpenAI

POST /v1/chat/completions

Les requêtes et les réponses utilisent le format Chat Completions, avec n'importe quel modèle de chat issu de /v1/models. Paramètres pris en charge :

• model, messages (system, developer, user, assistant, tool)
• tools, tool_choice (auto, none, required, fonction nommée)
• stream, stream_options.include_usage
• temperature, max_tokens / max_completion_tokens, reasoning_effort
• Contenu multipartie : text, image_url (https ou data:), file (PDF)

Non pris en charge : response_format json_object/json_schema (rejeté avec une erreur 400 — utilisez tools pour les sorties structurées ; dans LangChain, passez method="function_calling") et n supérieur à 1. stop, top_p, seed et logprobs sont ignorés.

Les réponses en streaming arrivent sous forme de Server-Sent Events :

curl https://sataveslabs.com/v1/chat/completions \
  -H "Authorization: Bearer $SATAVES_API_KEY" -H "Content-Type: application/json" \
  -N -d '{
    "model": "anthropic/claude-sonnet-4.5",
    "stream": true,
    "stream_options": {"include_usage": true},
    "messages": [{"role": "user", "content": "Explain RAG in two sentences."}]
  }'

Pendant la génération d'une réponse en streaming, le serveur envoie des commentaires keep-alive ; le texte arrive ensuite par fragments dès que le modèle a répondu. Les réponses sans streaming indiquent le montant facturé dans billing et dans les en-têtes X-Api-Charged-*. Les frais du streaming apparaissent dans /v1/usage une fois le traitement terminé ; les en-têtes de streaming ne peuvent pas contenir le montant final.

Image en entrée pour les modèles de vision :

client.chat.completions.create(
    model="anthropic/claude-sonnet-4.5",
    messages=[{"role": "user", "content": [
        {"type": "text", "text": "What is in this picture?"},
        {"type": "image_url", "image_url": {"url": "https://example.com/photo.jpg"}},
    ]}],
)

POST /v1/responses prend en charge les entrées texte/image sans état et les outils function/custom exécutés côté client, y compris les appels parallèles. Envoyez l'historique complet avec store=false. Les outils hébergés tels que web_search sont ignorés ; les réponses stockées et l'état de conversation côté serveur ne sont pas disponibles.

# pip install openai
reply = client.responses.create(
    model="anthropic/claude-sonnet-4.5",
    store=False,
    instructions="You are a concise assistant.",
    input="Explain what a motion graphic is.",
)
print(reply.output_text)
# For tool loops, send the full input history plus output items and function_call_output.
# Stored conversations, previous_response_id and hosted tools are unavailable.

Messages — compatible Anthropic

POST /v1/messages · POST /v1/messages/count_tokens

Prend en charge system, les blocs text, image, document, tool_use et tool_result, les outils avec input_schema, tool_choice, thinking et le streaming d'événements. N'importe quel modèle de chat — Claude ou autre — fonctionne ici. Les SDK Anthropic prennent l'URL de base sans /v1.

curl https://sataveslabs.com/v1/messages \
  -H "x-api-key: $SATAVES_API_KEY" \
  -H "anthropic-version: 2023-06-01" -H "Content-Type: application/json" \
  -d '{
    "model": "anthropic/claude-sonnet-4.5",
    "max_tokens": 1024,
    "system": "You are a concise assistant.",
    "messages": [{"role": "user", "content": "Name three uses of embeddings."}]
  }'

Outils pour agents et SDK

Utilisez nos modèles dans les outils de développement et les frameworks d'agents. Remplacez sk-sat-... par votre clé ; choisissez un modèle de chat doté de la prise en charge des outils dans la liste des modèles. Les versions des clients diffèrent ; les formats réseau des SDK sont testés, mais chaque environnement de bureau requiert encore sa propre vérification d'intégration.

export ANTHROPIC_BASE_URL="https://sataveslabs.com"
export ANTHROPIC_AUTH_TOKEN="sk-sat-..."
# Any chat model from /v1/models works, Claude or not:
export ANTHROPIC_MODEL="anthropic/claude-sonnet-4.5"
export ANTHROPIC_DEFAULT_SONNET_MODEL="anthropic/claude-sonnet-4.5"
export ANTHROPIC_DEFAULT_HAIKU_MODEL="anthropic/claude-haiku-4.5"
export ANTHROPIC_SMALL_FAST_MODEL="anthropic/claude-haiku-4.5"   # older Claude Code versions
claude

# ~/.codex/config.toml
model = "qwen/qwen3-coder"
model_provider = "sataves"

[model_providers.sataves]
name = "Sataves"
base_url = "https://sataveslabs.com/v1"
env_key = "SATAVES_API_KEY"
wire_api = "responses"

Base URL:  https://sataveslabs.com/v1
API Key:   sk-sat-...
Model ID:  anthropic/claude-sonnet-4.5
Supports images: on (for vision models)

models:
  - name: Claude Sonnet (Sataves)
    provider: openai
    model: anthropic/claude-sonnet-4.5
    apiBase: https://sataveslabs.com/v1
    apiKey: ${{ secrets.SATAVES_API_KEY }}
    roles: [chat, edit, apply]
  - name: Embeddings (Sataves)
    provider: openai
    model: openai/text-embedding-3-small
    apiBase: https://sataveslabs.com/v1
    apiKey: ${{ secrets.SATAVES_API_KEY }}
    roles: [embed]

export OPENAI_API_BASE="https://sataveslabs.com/v1"
export OPENAI_API_KEY="sk-sat-..."
aider --model openai/anthropic/claude-sonnet-4.5

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "sataves": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Sataves",
      "options": { "baseURL": "https://sataveslabs.com/v1", "apiKey": "{env:SATAVES_API_KEY}" },
      "models": {
        "anthropic/claude-sonnet-4.5": { "name": "Claude Sonnet 4.5" },
        "qwen/qwen3-coder": { "name": "Qwen3 Coder" }
      }
    }
  }
}

# pip install langchain-openai
from langchain_openai import ChatOpenAI, OpenAIEmbeddings

llm = ChatOpenAI(base_url="https://sataveslabs.com/v1", api_key="sk-sat-...", model="anthropic/claude-sonnet-4.5")
embeddings = OpenAIEmbeddings(base_url="https://sataveslabs.com/v1", api_key="sk-sat-...",
                              model="openai/text-embedding-3-small", check_embedding_ctx_length=False)
print(llm.invoke("One sentence about Persian poetry.").content)

import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
import { generateText } from "ai";

const sataves = createOpenAICompatible({
  name: "sataves", baseURL: "https://sataveslabs.com/v1", apiKey: process.env.SATAVES_API_KEY,
});
const { text } = await generateText({ model: sataves("anthropic/claude-sonnet-4.5"), prompt: "Hello!" });

import json, os
from openai import OpenAI

client = OpenAI(base_url="https://sataveslabs.com/v1", api_key=os.environ["SATAVES_API_KEY"])

tools = [{
    "type": "function",
    "function": {
        "name": "get_weather",
        "description": "Current weather for a city",
        "parameters": {
            "type": "object",
            "properties": {"city": {"type": "string"}},
            "required": ["city"],
        },
    },
}]

def get_weather(city):
    return {"city": city, "temperature_c": 21, "sky": "clear"}

messages = [{"role": "user", "content": "Should I take an umbrella in Tehran today?"}]
while True:
    reply = client.chat.completions.create(model="anthropic/claude-sonnet-4.5", messages=messages, tools=tools)
    message = reply.choices[0].message
    messages.append(message.model_dump(exclude_none=True))
    if not message.tool_calls:
        print(message.content)
        break
    for call in message.tool_calls:
        result = get_weather(**json.loads(call.function.arguments))
        messages.append({"role": "tool", "tool_call_id": call.id, "content": json.dumps(result)})

Embeddings

POST /v1/embeddings

Jusqu'à 100 entrées par requête ; dimensions facultatif, et encoding_format float ou base64 (valeur par défaut du SDK officiel d'OpenAI).

curl https://sataveslabs.com/v1/embeddings \
  -H "Authorization: Bearer $SATAVES_API_KEY" -H "Content-Type: application/json" \
  -d '{"model": "openai/text-embedding-3-small", "input": ["first text", "second text"]}'

Services AI Studio

Les services AI Studio correspondent aux points de terminaison du site sous /api et acceptent la même clé ainsi que les mêmes identifiants de modèles que /v1/models. Les réponses adoptent le format {ok, data}.

Génération d'images (avec devis)

La génération d'images et de vidéos commence par un devis : le prix exact et le plafond de dépenses sont fixés avant toute facturation.

# 1) Ask for a price quote (nothing is charged)
curl https://sataveslabs.com/api/ai/generation/quote -H "Authorization: Bearer $SATAVES_API_KEY" -H "Content-Type: application/json" -d '{
  "service": "ai:image", "model": "openai/gpt-image-1",
  "prompt": "A lighthouse at dawn, watercolor", "size": "1024x1024", "output_count": 1
}'
# -> {"ok": true, "data": {"quote_id": "...", "estimated_usd_micros": ..., "maximum_authorized_usd_micros": ...}}

# 2) Confirm it (add "accept_cost_estimate": true when the quote says requires_cost_estimate_acceptance)
curl -X POST https://sataveslabs.com/api/ai/generation/quotes/QUOTE_ID/confirm -H "Authorization: Bearer $SATAVES_API_KEY" -H "Content-Type: application/json" -d '{}'

# 3) Generate with the same parameters and the quote id
curl https://sataveslabs.com/api/ai/image -H "Authorization: Bearer $SATAVES_API_KEY" -H "Content-Type: application/json" -d '{
  "model": "openai/gpt-image-1", "prompt": "A lighthouse at dawn, watercolor",
  "size": "1024x1024", "output_count": 1, "quote_id": "QUOTE_ID"
}'
# -> {"ok": true, "data": {"image_url": "/api/ai/images/.../file", "billing": {...}}}

AI Color Studio

With the ai scope, upload a PNG, JPEG or WebP to POST /api/ai/color/assets (multipart file). Use its id as source. Choose mode colorize or recolor, with optional target, instructions, palette (hex colors) and reference asset id. Upload a mask with kind=mask: white selects the edited region; black preserves the original pixels. Mask dimensions must match the source.

Send the settings to POST /api/ai/color/quote; pricing uses the existing USD image policy and markup. Submit the returned id to POST /api/ai/color/generate, with accept_cost_estimate=true when required by the quote. Repeating that id retrieves the existing request without dispatching again. Check GET /api/ai/color/runs/{id} and GET /api/ai/color/runs for status and history. Assets and results belong to the authenticated account.

Génération de vidéo (asynchrone)

# Quote and confirm exactly like images, with "service": "ai:video"
curl https://sataveslabs.com/api/ai/generation/quote -H "Authorization: Bearer $SATAVES_API_KEY" -H "Content-Type: application/json" -d '{
  "service": "ai:video", "model": "google/veo-3.1-fast", "prompt": "Drone shot over a desert at sunset",
  "size": "1280x720", "aspect_ratio": "16:9", "duration_seconds": 8
}'
curl -X POST https://sataveslabs.com/api/ai/generation/quotes/QUOTE_ID/confirm -H "Authorization: Bearer $SATAVES_API_KEY" -H "Content-Type: application/json" -d '{}'

curl https://sataveslabs.com/api/ai/video -H "Authorization: Bearer $SATAVES_API_KEY" -H "Content-Type: application/json" -d '{
  "model": "google/veo-3.1-fast", "prompt": "Drone shot over a desert at sunset",
  "size": "1280x720", "aspect_ratio": "16:9", "duration_seconds": 8, "quote_id": "QUOTE_ID"
}'
# -> {"data": {"task_id": "...", "status": "processing"}}

# Poll, then download
curl https://sataveslabs.com/api/ai/video/status/TASK_ID -H "Authorization: Bearer $SATAVES_API_KEY"
curl -o video.mp4 https://sataveslabs.com/api/ai/video/content/TASK_ID -H "Authorization: Bearer $SATAVES_API_KEY"

Synthèse vocale et transcription — compatibles OpenAI

POST /v1/audio/speech · POST /v1/audio/transcriptions

Fonctionne avec le SDK officiel d'OpenAI. La synthèse vocale est renvoyée dans le format audio du modèle (vous pouvez demander mp3, wav ou ogg) ; la transcription renvoie du json, text ou verbose_json.

# OpenAI-compatible: the response body is the audio file
curl https://sataveslabs.com/v1/audio/speech -H "Authorization: Bearer $SATAVES_API_KEY" -H "Content-Type: application/json" \
  -d '{"model": "gemini-2.5-flash-tts", "input": "Hello from Sataves!", "voice": "Kore"}' -o hello.wav

curl https://sataveslabs.com/v1/audio/transcriptions -H "Authorization: Bearer $SATAVES_API_KEY" \
  -F "file=@meeting.mp3" -F "model=whisper-1" -F "response_format=json"

Synthèse vocale, transcription et OCR avec toutes les options

# Text to speech: list voices, then synthesize
curl "https://sataveslabs.com/api/ai/tts/model-voices?model=gemini-2.5-flash-tts" -H "Authorization: Bearer $SATAVES_API_KEY"
curl https://sataveslabs.com/api/ai/tts -H "Authorization: Bearer $SATAVES_API_KEY" -H "Content-Type: application/json" \
  -d '{"model": "gemini-2.5-flash-tts", "text": "Hello from Sataves!", "voice": "Kore"}'
# -> {"data": {"audio_b64": "...", "format": "audio/wav", "audio_url": "/api/ai/audio/..."}}

# Speech to text (multipart upload)
curl https://sataveslabs.com/api/ai/transcribe -H "Authorization: Bearer $SATAVES_API_KEY" \
  -F "file=@meeting.mp3" -F "model=whisper-1"
# -> {"ok": true, "data": {"text": "...", "billing": {...}}}

# OCR on an image or PDF (any vision-capable model)
curl https://sataveslabs.com/api/ai/ocr -H "Authorization: Bearer $SATAVES_API_KEY" -F "file=@invoice.pdf" -F "model=anthropic/claude-sonnet-4.5"

Résumés, traduction et réécriture

curl https://sataveslabs.com/api/ai/summarize -H "Authorization: Bearer $SATAVES_API_KEY" -H "Content-Type: application/json" \
  -d '{"text": "...long text...", "model": "openai/gpt-4.1-mini", "format": "key_points"}'

curl https://sataveslabs.com/api/ai/translate -H "Authorization: Bearer $SATAVES_API_KEY" -H "Content-Type: application/json" \
  -d '{"text": "Good morning", "target": "Persian"}'

curl https://sataveslabs.com/api/ai/rewrite -H "Authorization: Bearer $SATAVES_API_KEY" -H "Content-Type: application/json" \
  -d '{"text": "...", "model": "openai/gpt-4.1-mini"}'

Musique

# Music is generated into a private studio project
curl https://sataveslabs.com/api/studio/projects -H "Authorization: Bearer $SATAVES_API_KEY" -H "Content-Type: application/json" \
  -d '{"title": "API music", "manifest": {"schema_version": 1, "assets": []}}'
# -> {"ok": true, "project": {"id": "PROJECT_ID", ...}}

curl https://sataveslabs.com/api/studio/projects/PROJECT_ID/creative/music -H "Authorization: Bearer $SATAVES_API_KEY" -H "Content-Type: application/json" \
  -d '{"model": "google/lyria-3-clip-preview", "prompt": "Calm lo-fi beat with soft piano", "instrumental": true}'

# The new track appears in the project's media bin
curl https://sataveslabs.com/api/studio/projects/PROJECT_ID/assets -H "Authorization: Bearer $SATAVES_API_KEY"

Verrouillage du prix (facultatif)

Pour les services de texte, la synthèse vocale, l'OCR et la génération Studio, vous pouvez d'abord verrouiller le prix ; sans cela, la requête est tout de même exécutée et facturée sur la base de la consommation réelle.

# Optional for text services, TTS, OCR and studio generation: lock the price first
curl https://sataveslabs.com/api/credits/studio/quote -H "Authorization: Bearer $SATAVES_API_KEY" -H "Content-Type: application/json" \
  -d '{"path": "/ai/tts", "payload": {"model": "gemini-2.5-flash-tts", "text": "Hello", "voice": "Kore"}}'
curl -X POST https://sataveslabs.com/api/credits/studio/quotes/QUOTE_ID/confirm -H "Authorization: Bearer $SATAVES_API_KEY"

# Send the identical request with the quote headers
curl https://sataveslabs.com/api/ai/tts -H "Authorization: Bearer $SATAVES_API_KEY" -H "Content-Type: application/json" \
  -H "X-Studio-Request: 1" -H "X-Studio-Quote-Id: QUOTE_ID" \
  -d '{"model": "gemini-2.5-flash-tts", "text": "Hello", "voice": "Kore"}'

Certains modèles s'entraînent sur leurs entrées ; la liste des modèles les signale par requires_training_consent. Envoyez "training_consent": true pour pouvoir les utiliser.

Motion design : créer et télécharger un GIF

import os, time, requests
root = "https://sataveslabs.com"
headers = {"Authorization": "Bearer " + os.environ["SATAVES_API_KEY"]}
def call(method, path, **kwargs):
    response = requests.request(method, root + path, headers=headers, timeout=300, **kwargs)
    response.raise_for_status()
    return response.json()["data"]
spec = {
    "mode": "template", "title": "Ideas in motion", "subtitle": "Your brand, animated",
    "primary": "#8b5cf6", "secondary": "#f472b6", "aspect": "16:9",
    "seconds": 4, "position": "bottom"
}
quote = call("POST", "/api/ai/motion/quote", json=spec)
# Local template is free. For mode=ai, review the returned quote then explicitly confirm it:
# call("POST", "/api/ai/generation/quotes/" + quote["quote"]["quote_id"] + "/confirm",
#      json={"accept_cost_estimate": True})
run = call("POST", "/api/ai/motion/generate", json={"id": quote["id"]})
while run["state"] not in ("completed", "failed", "render_failed", "uncertain"):
    time.sleep(5)
    run = call("GET", "/api/ai/motion/runs/" + run["id"])
if run["state"] == "completed":
    gif = requests.get(root + run["outputs"]["gif"], headers=headers, timeout=60)
    gif.raise_for_status()
    open("motion.gif", "wb").write(gif.content)
# An uncertain submission must never be blindly retried. Retry only local rendering when appropriate.

Outils du site et tâches d'arrière-plan

Les outils du site (conversion de format, compression, outils pour images et PDF, polices, QR codes, réseau et recherche) et les tâches longues (traduction et doublage vidéo, sous-titres, téléchargements) sont disponibles avec les portées tools et jobs. La référence complète des points de terminaison répertorie l'ensemble des chemins et des entrées.

# Long tasks (video translation, subtitles, downloads, conversions) run as jobs
curl https://sataveslabs.com/api/jobs -H "Authorization: Bearer $SATAVES_API_KEY"                      # your jobs
curl https://sataveslabs.com/api/jobs/JOB_ID -H "Authorization: Bearer $SATAVES_API_KEY"               # status and progress
curl -o result.zip https://sataveslabs.com/api/jobs/JOB_ID/file -H "Authorization: Bearer $SATAVES_API_KEY"

# Download from a link
curl https://sataveslabs.com/api/downloads/formats -H "Authorization: Bearer $SATAVES_API_KEY" -H "Content-Type: application/json" -d '{"url": "https://www.youtube.com/watch?v=..."}'
curl https://sataveslabs.com/api/downloads/jobs -H "Authorization: Bearer $SATAVES_API_KEY" -H "Content-Type: application/json" -d '{"url": "https://www.youtube.com/watch?v=...", "fmt": "best"}'
curl https://sataveslabs.com/api/downloads/jobs/JOB_ID -H "Authorization: Bearer $SATAVES_API_KEY"
curl -o video.mp4 https://sataveslabs.com/api/downloads/jobs/JOB_ID/file -H "Authorization: Bearer $SATAVES_API_KEY"

Media and image conversion

Discover targets and limits with GET /api/convert/formats. Send multipart/form-data fields file and target to POST /api/convert/media or POST /api/images/convert; a successful response is the output file. For background processing, use the existing tools job flow with media_convert or img_convert.

Video animation exports are silent: input at most 60 seconds, output up to 960px wide at 12 fps. Image conversions to GIF, WebP or PNG/APNG preserve animation timing and looping; other targets save the first frame. Error responses are JSON; always inspect the response Content-Type.

Civitai et Hugging Face

Les ressources sélectionnées sont répertoriées sur /v1/hub/catalog. Résolvez les modèles Civitai et les Spaces Hugging Face pris en charge par URL, puis vérifiez la compatibilité et l'accès avant de démarrer une tâche d'arrière-plan. Les ressources indexées ne sont pas garanties exécutables ; les dépôts de modèles autonomes Hugging Face ne sont pas des Spaces.

# Discover featured resources; this does not run inference
curl https://sataveslabs.com/v1/hub/catalog

# Resolve a supported resource and review availability first
curl https://sataveslabs.com/api/ai/hub/resolve -H "Authorization: Bearer $SATAVES_API_KEY" -H "Content-Type: application/json" -d '{"url":"https://civitai.com/models/4201"}'

# Save the exact Civitai inputs you intend to submit
printf '%s' '{"model_name":"MODEL_NAME","model_urn":"VERIFIED_AIR_URN","prompt":"portrait, soft light"}' > civitai-input.json
curl https://sataveslabs.com/api/ai/hub/civitai/estimate -H "Authorization: Bearer $SATAVES_API_KEY" -H "Content-Type: application/json" -d @civitai-input.json
# Review quote_id, estimated_micros, maximum_micros, expires_at and can_start.
# Amounts are micro-USD: 1000000 = $1. A quote reserves nothing yet.
# After approving the displayed price, set SATAVES_HUB_QUOTE_ID to that quote_id.
# jq is required. Keep the quoted inputs unchanged; reuse the retry key after a timeout.
jq --arg q "$SATAVES_HUB_QUOTE_ID" '. + {quote_id:$q,accept_cost_estimate:true,idempotency_key:"civitai-001"}' civitai-input.json > civitai-run.json
curl https://sataveslabs.com/api/ai/hub/civitai/runs -H "Authorization: Bearer $SATAVES_API_KEY" -H "Content-Type: application/json" -d @civitai-run.json

# Hugging Face: discover the real endpoint, parameter names and schema hash
curl https://sataveslabs.com/api/ai/hub/research/discover -H "Authorization: Bearer $SATAVES_API_KEY" -H "Content-Type: application/json" -d '{"kind":"space","repo_id":"SPACE_OWNER/SPACE_NAME"}'
printf '%s' '{"kind":"space","repo_id":"SPACE_OWNER/SPACE_NAME","endpoint":"ENDPOINT_FROM_DISCOVER","values":{"INPUT_NAME_FROM_DISCOVER":"a red fox"},"options":{},"schema_hash":"SCHEMA_HASH_FROM_DISCOVER","consent":true}' > space-input.json
curl https://sataveslabs.com/api/ai/hub/research/quote -H "Authorization: Bearer $SATAVES_API_KEY" -H "Content-Type: application/json" -d @space-input.json
# Review this quote, then set SATAVES_HUB_QUOTE_ID to its quote_id.
jq --arg q "$SATAVES_HUB_QUOTE_ID" '. + {quote_id:$q,accept_cost_estimate:true,idempotency_key:"space-001"}' space-input.json > space-run.json
curl https://sataveslabs.com/api/ai/hub/research/runs -H "Authorization: Bearer $SATAVES_API_KEY" -H "Content-Type: application/json" -d @space-run.json

# Poll and download using the same account/key
curl https://sataveslabs.com/api/jobs/JOB_ID -H "Authorization: Bearer $SATAVES_API_KEY"
curl -O https://sataveslabs.com/api/ai/hub/runs/JOB_ID/files/FILE_NAME -H "Authorization: Bearer $SATAVES_API_KEY"
# Final result.billing reports charged_micros, refunded_micros,
# price_estimated and cost_basis. Async API usage updates after settlement.

Managed Space execution

Check GET /api/ai/hub/research/execution-options?repo_id=OWNER/SPACE for approved routes. execution_mode="host" uses the original host, with Sataves credentials only for an approved exact repository. "managed" starts a reviewed private copy on approved CPU/GPU hardware and pauses it after execution. Keep the same execution_mode in discover, quote and runs.

The embedded native interface uses the visitor’s browser account, independently sur server billing. API runs require reserved USD credit; compute charges are estimates with the existing pricing markup. ZeroGPU quota, queues, provider credit, licenses, external secrets and source review can block execution. For hf_source_changed_review_required or hf_execution_plan_changed_requote, recheck compatibility and obtain a new quote before retrying.

Points de terminaison du Hub et déroulement de l'exécution

Utilisez une clé dotée de la portée hub ; activez également jobs pour le suivi des tâches et account pour le solde et la consommation. Les exécutions requièrent un compte vérifié.

Pour les Spaces, utilisez kind: space et obtenez repo_id, le nom de l'endpoint, les entrées ainsi que le schema_hash de cet endpoint auprès de discover. consent accepte les conditions de la ressource. Si son schéma change, redécouvrez et vérifiez les entrées. Un Space en veille ou sans API compatible peut ne pas s'exécuter ; prepare suit la disponibilité sous la forme d'une tâche d'arrière-plan.

Tarification, plafonds de coût et nouvelles tentatives

Quote every run with the exact inputs. quote_id is bound to the account, resource, endpoint and settings, and expires. estimated_micros is the expected charge; maximum_micros is the customer's authorized limit. One million micro-USD equals $1. Submit quote_id and accept_cost_estimate: true when accepting an estimated price. Changed inputs require a new quote.

After execution, verified usage or the accepted estimate determines the charge; unused reserved funds are released. Public Spaces are not automatically free. Queue and HTTP waiting time are not GPU usage meters. Customer charges never exceed the approved limit. The final result identifies billing.price_estimated and billing.cost_basis.

Vérifiez les politiques tarifaires actuelles dans /v1/pricing sous open-ai-hub et open-ai-hub:research. Un Space public ne garantit pas une exécution perpétuellement gratuite. Les frais d'arrière-plan peuvent être réglés après l'envoi ; un montant nul dans l'entrée initiale de /v1/usage ne garantit pas une exécution gratuite. Rapprochez les frais finaux avec les résultats de la tâche et le grand livre du compte.

202 signifie acceptée, et non génération réussie. Conservez l'idempotency_key du corps lors d'une nouvelle tentative pour le même envoi, enregistrez l'ID de tâche et interrogez l'état avec un délai. Résolvez les erreurs d'accès, de modification de schéma ou d'indisponibilité de ressource avant de renvoyer la requête ; les entrées téléversées doivent appartenir au même compte.

Numéros virtuels & SMS

Créez une clé dotée de la portée numbers ; les clés existantes ne reçoivent pas automatiquement cette nouvelle autorisation. Parcourez les services et les offres pour connaître les pays, les opérateurs et les stocks, puis confirmez le prix de vente du site Web lors de l'achat. Les commandes et les SMS appartiennent au compte associé à la clé.

Pour acheter, envoyez platform, pid et sid de l'offre choisie. Avec USD_CREDIT, price doit être égal à price_usd_micros (1 USD = 1 000 000 micros). Avec TOMAN, price correspond au montant en tomans de l'offre. Un solde suffisant est requis et le prix est revérifié lors de l'achat.

L'en-tête Idempotency-Key est obligatoire pour les achats (8 à 128 caractères : lettres, chiffres, _, ., : ou -). Réessayez une requête interrompue avec la même clé et le même corps pour éviter les numéros et débits en double. Réutiliser une clé avec un corps différent renvoie une erreur 409. En cas de purchase_in_progress ou purchase_outcome_unknown, inspectez vos commandes ; n'achetez pas à l'aveugle avec une nouvelle clé.

import os, time, requests
root = "https://sataveslabs.com"
headers = {"Authorization": "Bearer " + os.environ["SATAVES_API_KEY"]}
def call(method, path, **kwargs):
    request_headers = kwargs.pop("headers", headers)
    r = requests.request(method, root + path, headers=request_headers, timeout=60, **kwargs)
    r.raise_for_status()
    result = r.json()
    if not result["ok"]:
        raise RuntimeError(result["data"].get("error", "request_failed"))
    return result["data"]

offers = call("GET", "/api/numbers/offers", params={"platform": "telegram"})
if offers.get("partial") or not offers["items"]:
    raise RuntimeError("Catalog warming or out of stock; retry browsing later")
offer = offers["items"][0]  # Select the country/operator you actually want.
assert offer["billing_currency"] == "USD_CREDIT"
price = offer["price_usd_micros"]
# Set a deliberate budget before running. This example buys a real number.
assert price <= int(os.environ["MAX_NUMBER_PRICE_MICROS"])
# Save this unique purchase id; reuse it and the SAME body on network retries.
purchase_id = os.environ["NUMBER_PURCHASE_ID"]  # e.g. telegram-order-20261025-001
body = {"pid": offer["pid"], "sid": offer["sid"], "platform": "telegram", "price": price}
purchase = call("POST", "/api/numbers/purchase", json=body,
                headers={**headers, "Idempotency-Key": purchase_id})
key = purchase["order"]["key"]
for _ in range(60):
    status = call("GET", "/api/numbers/orders/" + key + "/status")
    if status.get("code") or status["state"] in ("completed", "canceled", "banned"):
        print(status)  # code, sms text/sender, expiry and state when available
        break
    time.sleep(5)
# Actions, when appropriate (each can be refused by the provider):
# call("POST", "/api/numbers/orders/" + key + "/finish")
# call("POST", "/api/numbers/orders/" + key + "/cancel")
# call("POST", "/api/numbers/orders/" + key + "/ban")

Interrogez le statut toutes les 5 secondes. L'annulation ou le bannissement avant réception d'un code ne peut donner lieu à un remboursement qu'après confirmation du fournisseur ; pending signifie que la confirmation est toujours en attente. La finalisation ne donne droit à aucun remboursement. Vérifiez également les résultats ok:false. Les erreurs d'API incluent 402 solde insuffisant, 404 commande introuvable/non possédée, 409 changement de prix/code déjà reçu et 503 confirmation du fournisseur indisponible.

La couverture actuelle concerne les numéros d'activation à usage unique. Les locations longue durée, le rachat payant d'un numéro spécifique et les paramètres de compte en amont ne sont pas exposés. L'ancienne route repeat renvoie repeat_not_supported ; interrogez status pour obtenir des SMS supplémentaires. Les frais liés aux nouveaux achats apparaissent dans les en-têtes X-Api-Charged-* et l'utilisation de l'API ; relancer un achat n'engendre aucuns nouveaux frais.

Modèles & tarifs catalogue

Ce tableau est lu en direct depuis GET /v1/models. Les prix sont en USD : tokens par million, les autres unités selon l'intitulé. Les modèles avec pricing.free n'ont aucun coût d'utilisation. Le montant exact de chaque requête est renvoyé dans sa réponse.

Chargement des données en direct…

Tarifs des services & facturation

• Un plafond de dépense est réservé avant chaque requête ; ensuite, seule la consommation réelle est facturée et le reste de la retenue est libéré.
• Les échecs confirmés libèrent les retenues inutilisées. Un achat de numéro au résultat incertain conserve sa retenue jusqu'à régularisation ; ne lancez pas un autre achat. Si un client se déconnecte après le début de la génération, le travail effectué peut toujours être facturé ; vérifiez le grand livre avant de réessayer.
• Un montant facturé ne dépasse jamais le plafond confirmé.

Chargement des données en direct…

Compte, solde & consommation

curl https://sataveslabs.com/v1/account -H "Authorization: Bearer $SATAVES_API_KEY"     # balance, this key, rate limits
curl "https://sataveslabs.com/v1/usage?days=7&key=current" -H "Authorization: Bearer $SATAVES_API_KEY"   # requests and charges
curl https://sataveslabs.com/v1/pricing                     # price list (public)
curl https://sataveslabs.com/v1/status                      # API status and model counts (public)

/v1/usage lists keyed requests and the charges reported by those requests; key can be all, current or a key id. Background work can settle later, so zero in a request log does not mean a job is free. Use the account ledger and job billing for final charges.

Référence complète des points de terminaison

Chaque point de terminaison qu'une clé API peut appeler, avec son scope. Les entrées et sorties exactes se trouvent dans le document OpenAPI : /v1/openapi.json

Chargement des données en direct…

Erreurs & limites de débit

// /v1/chat/completions, /v1/embeddings and other /v1 endpoints (OpenAI shape)
{"error": {"message": "Your balance is too low for this request.", "type": "insufficient_quota", "code": "insufficient_balance"}}

// /v1/messages (Anthropic shape)
{"type": "error", "error": {"type": "billing_error", "message": "Your balance is too low for this request."}}

// /api/... website endpoints
{"ok": false, "error": "generation_quote_required", "detail": "generation_quote_required"}

La limite de débit par défaut est de 120 requêtes par minute sur /v1 (vos limites exactes se trouvent dans /v1/account). Réessayez les réponses 429 avec un intervalle exponentiel.

Données & sécurité des clés

• Nous ne proposons pas de modèles dont les fournisseurs s'entraînent sur vos requêtes, à l'exception des modèles marqués requires_training_consent, qui ne s'exécutent que si cette requête y consent.
• Conservez les clés uniquement sur vos serveurs — jamais dans des applications mobiles ou du code côté navigateur.
• Utilisez une clé distincte avec les scopes minimaux pour chaque application, et révoquez immédiatement toute clé compromise.