Quickstart

from openai import OpenAI

client = OpenAI(
    api_key="sk-your-api-key",
    base_url="https://api.tokspan.com/v1",  # ← OpenAI-compatible base URL
)

response = client.chat.completions.create(
    model="MODEL_NAME",  # Replace MODEL_NAME with any model from the catalog
    messages=[{"role": "user", "content": "Hello!"}],
)

print(response.choices[0].message.content)

from anthropic import Anthropic

client = Anthropic(
    api_key="sk-your-api-key",
    base_url="https://api.tokspan.com",  # ← Native Anthropic base URL (host root; SDK appends /v1/messages)
)

response = client.messages.create(
    model="MODEL_NAME",  # Replace MODEL_NAME with any Claude model from the catalog
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hello!"}],
)

print(response.content[0].text)

"""
Doubao Seedance video generation - Python example.

Video generation is asynchronous: submit a task, poll it, then download the
result. Requires `pip install requests`.
"""

import time
from typing import Any, Dict, Optional

import requests

# ---------------------------------------------------------------------------
# Configuration
# ---------------------------------------------------------------------------
# Site origin only - no trailing slash and no "/v1/videos" (the paths below are
# appended by the code, e.g. f"{BASE_URL}/v1/videos").
BASE_URL = "https://api.tokspan.com"
API_KEY = "YOUR_API_KEY"               # user token from Console -> Tokens
MODEL = "volcengine/doubao-seedance-2-5-v2"

PROMPT = "A ginger cat walking through a sunlit garden, cinematic, shallow depth of field"
SECONDS = 5             # 1-3600; upstream default is about 10s
RESOLUTION = "1080p"    # 480p / 720p / 1080p / 4k; upstream default is 720p
IMAGE_URL = None        # reference image URL for image-to-video; None = text-to-video

POLL_INTERVAL = 10      # seconds between status checks
POLL_TIMEOUT = 15 * 60  # give up after this many seconds

# A trailing slash would produce "https://host//v1/videos", which the gateway
# answers with its HTML front page (HTTP 200), so normalize it away.
BASE_URL = BASE_URL.rstrip("/")

# Available models, with list price per 1M tokens (billed on actual usage):
#   volcengine/doubao-seedance-2-5-v2            $10.19   best quality
#   volcengine/doubao-seedance-2-0-260128         $6.00
#   volcengine/doubao-seedance-2-0-fast-260128    $4.35   fastest, cheapest


def _headers() -> Dict[str, str]:
    """Auth header. `requests` sets Content-Type automatically for json= bodies."""
    return {"Authorization": f"Bearer {API_KEY}"}


def _check(resp: requests.Response, action: str) -> None:
    """Raise a readable error for any non-2xx response.

    Error codes you may hit:
        pre_consume_token_quota_failed  token balance below the pre-charge
        model_not_found                 no channel serves this model
        get_channel_failed              channel selection failed
        fail_to_fetch_task              upstream error (details inside `message`)
    """
    if resp.ok:
        return
    try:
        body = resp.json()
    except ValueError:
        body = {"message": resp.text[:200]}
    err = body.get("error", body) if isinstance(body, dict) else {"message": str(body)}
    raise RuntimeError(
        f"{action} failed: HTTP {resp.status_code} "
        f"[{err.get('code', '')}] {err.get('message', '')}"
    )


def create_video(
    prompt: str,
    model: str = MODEL,
    seconds: Optional[int] = None,
    resolution: Optional[str] = None,
    image_url: Optional[str] = None,
) -> str:
    """Submit a generation task and return its task id."""
    payload: Dict[str, Any] = {"model": model, "prompt": prompt}
    if seconds is not None:
        payload["seconds"] = seconds
    if resolution is not None:
        payload["resolution"] = resolution
    if image_url:
        payload["input_reference"] = image_url   # "image" is an accepted alias

    resp = requests.post(f"{BASE_URL}/v1/videos", headers=_headers(), json=payload, timeout=60)
    _check(resp, "Submit")

    task_id = resp.json()["id"]
    print(f"Submitted task: {task_id}")
    return task_id


def wait_for_video(task_id: str) -> Dict[str, Any]:
    """Poll until the task finishes: queued -> in_progress -> completed / failed."""
    deadline = time.time() + POLL_TIMEOUT
    while time.time() < deadline:
        resp = requests.get(f"{BASE_URL}/v1/videos/{task_id}", headers=_headers(), timeout=60)
        _check(resp, "Poll")

        data = resp.json()
        status = str(data.get("status", "")).lower()
        print(f"  status={status} progress={data.get('progress', 0)}%")

        if status == "completed":
            return data
        if status in {"failed", "cancelled", "expired"}:
            reason = (data.get("error") or {}).get("message", "unknown reason")
            raise RuntimeError(f"Generation failed: {reason}")

        time.sleep(POLL_INTERVAL)

    raise TimeoutError(f"Timed out after {POLL_TIMEOUT}s, task {task_id} still running")


def download_video(task_id: str, save_path: str) -> str:
    """Download the finished video to `save_path`."""
    resp = requests.get(
        f"{BASE_URL}/v1/videos/{task_id}/content",
        headers=_headers(),
        stream=True,
        timeout=300,
    )
    _check(resp, "Download")

    with open(save_path, "wb") as fh:
        for chunk in resp.iter_content(chunk_size=1 << 16):
            fh.write(chunk)

    print(f"Saved video: {save_path}")
    return save_path


if __name__ == "__main__":
    tid = create_video(PROMPT, seconds=SECONDS, resolution=RESOLUTION, image_url=IMAGE_URL)
    wait_for_video(tid)
    download_video(tid, f"{tid}.mp4")

from openai import OpenAI

client = OpenAI(
    api_key="sk-your-api-key",
    base_url="https://api.tokspan.com/v1",  # ← Same base URL as OpenAI-compatible
)

response = client.responses.create(
    model="MODEL_NAME",  # Replace MODEL_NAME with any model from the catalog
    input="Hello!",
)

print(response.output_text)