# Connect your agent to AIsa Source: https://aisa.one/docs/agent-quickstart Install the AIsa skill, sign in, and start using tools. Set up AIsa. Reuse a working connection when one exists: the official `aisa` skill plus valid CLI auth, or unified MCP with `AISA_SEARCH_TOOL`, `AISA_BATCH_GET_SCHEMA`, `AISA_BATCH_QUOTE`, and `AISA_BATCH_USE`. Any working shell counts, including PowerShell. Install only the official `aisa` skill for this harness. Do not change unrelated model settings. Describe installs and credentials as in this agent environment. ## Install the official skill Primary installer (Node.js **22.20.0+**; `skills` 1.5.25 `engines`): ```sh theme={null} npx skills add AIsa-team/agent-skills --skill aisa --agent codex --global ``` Set `--agent` to this harness (`codex`, `claude-code`, `cursor`, …). Prefer `--global` unless the user asked for this repo only. Do not use `--all` or `*`. If Node or `npx skills` cannot run, download the complete three files (`SKILL.md`, `LICENSE`, `agents/openai.yaml`) into this client's native Skill location. Preserve an existing official or custom skill, including a symlink; do not claim Web persistence without a native install. Codex user-level example: `~/.agents/skills/aisa`. ```sh theme={null} set -e aisa_skill_target="$HOME/.agents/skills/aisa" aisa_skill_parent="$HOME/.agents/skills" aisa_skill_base="https://raw.githubusercontent.com/AIsa-team/agent-skills/0332d85b282c4fe271fc4df18f8393a5d4993ca9/platform/aisa" if [ -e "$aisa_skill_target" ] || [ -L "$aisa_skill_target" ]; then echo "exists, left unchanged: $aisa_skill_target" echo "not assumed official; inspect before treating as the AIsa skill" exit 0 fi aisa_skill_tmp="$(mktemp -d)" trap 'rm -rf "$aisa_skill_tmp"' EXIT mkdir -p "$aisa_skill_tmp/aisa/agents" "$aisa_skill_parent" curl -fSL "$aisa_skill_base/SKILL.md" -o "$aisa_skill_tmp/aisa/SKILL.md" curl -fSL "$aisa_skill_base/LICENSE" -o "$aisa_skill_tmp/aisa/LICENSE" curl -fSL "$aisa_skill_base/agents/openai.yaml" -o "$aisa_skill_tmp/aisa/agents/openai.yaml" mv "$aisa_skill_tmp/aisa" "$aisa_skill_target" ``` ## CLI Reuse `@aisa-one/cli` **0.5.0 or later** if it works. Install only if it is absent. Do not downgrade. CLI may keep its Node.js **18+** floor; do not replace a working CLI to match the Skill installer. ```sh theme={null} npm install -g @aisa-one/cli aisa --version ``` After the skill is on disk, read it in this session. For sign-in, follow that skill and `aisa login --help`. Check authentication with `aisa balance`. `aisa whoami` is local only. `AISA_API_KEY` overrides the stored key; if they conflict, explain both sources and do not blindly unset the environment variable. Never print credentials. Do not send the user to copy a key from the dashboard. Browser `aisa login` remains the primary way to obtain credentials. ## MCP When this environment cannot run CLI commands, or the user prefers MCP, connect `https://tools.aisa.one/mcp` (Streamable HTTP, OAuth). The client owns browser sign-in and tokens. Do not require `npx`. Do not use `https://mcp.aisa.one/servers` or the default `aisa connect` web-search server. Connection succeeds only after OAuth completed **and** `AISA_SEARCH_TOOL`, `AISA_BATCH_GET_SCHEMA`, `AISA_BATCH_QUOTE`, and `AISA_BATCH_USE` are present. Metadata or a `401` challenge is not a protected call. ## After AIsa is connected Say **AIsa is connected.** only after authentication is verified (`aisa balance` on the CLI path, or OAuth completed with the four tools on the MCP path). That is not a completed business task. If the user already named a task, continue it. Otherwise ask **What would you like to do first?** Follow the `aisa` skill. Setup is not spending approval. If the quote or documented maximum exceeds the remaining approved cap, stop. Do not ask the user to approve that same endpoint under an insufficient cap. Do not jump to HTTP to bypass missing credentials, exhausted credit, or an outage of the same API. A CLI/MCP client or router limitation may still allow the direct HTTP fallback below; do not use a paid request to probe availability. Do not extract or reuse client-owned MCP OAuth tokens. ## Direct HTTP API fallback Use this only when CLI and MCP are both unavailable, HTTP requests are supported, and a valid existing AIsa API key or secret is already available. Use this for a client, tooling, or router limitation; it does not bypass invalid API credentials, exhausted credit, or a failure of the same underlying API. Use the matching endpoint reference and published pricing. [API Reference](https://aisa.one/docs/api-reference). [Authentication](https://aisa.one/docs/guides/authentication). Data APIs: `https://api.aisa.one/apis/v1`. Model catalog: `https://api.aisa.one/v1/models`. Read [pricing](https://aisa.one/docs/guides/pricing) before any paid data request. Before presenting a paid request or cost proposal for approval, read the selected endpoint's full reference, or the matching OpenAPI operation, including parameters and charging rules. A catalog, index, or pricing overview is not the endpoint contract. Send the key as a Bearer token. Do not send a paid example request from this page. Success on `/v1/models` or other discovery does not prove authenticated business access. If there is no documented maximum or provider bound, or no auth, stop at that limitation. A changed endpoint, scope, or maximum needs new details and approval. ### API key Reuse `AISA_API_KEY`. If it is unset and this agent can read the filesystem, use `~/.aisa/key` from `aisa login` without displaying it. Otherwise use an AIsa API key already in this client's authorized secret store. If sources conflict, explain them; do not overwrite a custom key. If none of those exist and `aisa login` is usable, run browser `aisa login` so the key is stored automatically. If there is no usable CLI or browser-login path, the last option is for the user to sign in at [https://console.aisa.one/api-keys](https://console.aisa.one/api-keys), create a key, and save it in this client's credential or secret settings, or as local `AISA_API_KEY`. Do not ask them to paste the key into chat. Do not print it. Not every client has a secret UI; if this client cannot store a credential, stop there. Wait for credentials before protected API requests. Obtaining a key is not paid-call approval. ## Paid API approval first This contract applies **only** to direct HTTP calls to paid, dynamically priced, or potentially high-cost data endpoints. It does not apply to documented free discovery. It does not add a separate subsequent-message requirement to ordinary CLI or MCP quote/call. ```xml theme={null} ``` The original task, or an "I approve" in the same planning turn, is not that subsequent approval. ## Other surfaces Only if the user asked for models, REST, API keys, or extra skills: * [Getting Started](https://aisa.one/docs/guides/getting-started-with-aisa) * [Authentication](https://aisa.one/docs/guides/authentication) * [Models](https://aisa.one/docs/guides/models) * [API Reference](https://aisa.one/docs/api-reference) * [Agent Skills catalog](https://aisa.one/docs/agent-skills) # API Reference Source: https://aisa.one/docs/api-reference One key, one base URL, every API. Browse every endpoint AIsa routes to with interactive examples. AIsa exposes a unified API surface at `https://api.aisa.one` — OpenAI-compatible chat at `/v1` and all other APIs under `/apis/v1`. Authenticate once with your `AISA_API_KEY` and call any endpoint below — chat, video, search, market data, and more. OpenAI-, Anthropic-, and Google-compatible chat completion endpoints. YouTube SERP plus Tavily search, extract, crawl, and map. Sonar, Sonar Pro, Sonar Reasoning Pro, and Sonar Deep Research. Company fundamentals, filings, prices, insider trades, macro data. User, tweet, list, community, trend, space, and post endpoints. Scholar, web, smart, and explain search for research. Polymarket, Kalshi, and matching-market data. ## Essentials Error codes and how to handle them. Per-endpoint limits and headers. Read wallet balance and API-key availability. # OpenAI Chat Source: https://aisa.one/docs/api-reference/chat/post_chat-completions openapi/openai-chat.json POST /chat/completions Create chat completion Creates a model response for the given chat conversation. Learn more in the [text generation](https://platform.openai.com/docs/guides/text-generation), [vision](https://platform.openai.com/docs/guides/vision), and [audio](https://platform.openai.com/docs/guides/audio) guides. Parameter support can differ depending on the model used to generate the response, particularly for newer reasoning models. Parameters that are only supported for reasoning models are noted below. For the current state of unsupported parameters in reasoning models, [refer to the reasoning guide](https://platform.openai.com/docs/guides/reasoning). ## Streaming responses Set `"stream": true` to receive server-sent events (SSE) as each token is generated. This produces a lower time-to-first-token and is ideal for chat UIs. ```bash curl theme={null} curl https://api.aisa.one/v1/chat/completions \ -H "Authorization: Bearer $AISA_API_KEY" \ -H "Content-Type: application/json" \ -N \ -d '{ "model": "gpt-5", "messages": [{"role": "user", "content": "Write a haiku about APIs."}], "stream": true }' ``` ```python Python theme={null} from openai import OpenAI client = OpenAI(base_url="https://api.aisa.one/v1", api_key="sk-aisa-...") stream = client.chat.completions.create( model="gpt-5", messages=[{"role": "user", "content": "Write a haiku about APIs."}], stream=True, ) for chunk in stream: delta = chunk.choices[0].delta.content or "" print(delta, end="", flush=True) ``` ```typescript TypeScript theme={null} import OpenAI from "openai"; const client = new OpenAI({ baseURL: "https://api.aisa.one/v1", apiKey: process.env.AISA_API_KEY, }); const stream = await client.chat.completions.create({ model: "gpt-5", messages: [{ role: "user", content: "Write a haiku about APIs." }], stream: true, }); for await (const chunk of stream) { process.stdout.write(chunk.choices[0]?.delta?.content ?? ""); } ``` ### Stream anatomy Each line of the SSE stream looks like: ``` data: {"id":"chatcmpl-...","choices":[{"delta":{"content":"Quiet"},"index":0}]} data: {"id":"chatcmpl-...","choices":[{"delta":{"content":" packets"},"index":0}]} ... data: {"id":"chatcmpl-...","choices":[{"delta":{},"finish_reason":"stop","index":0}]} data: [DONE] ``` * Each `data:` line is a JSON object. The first chunk includes the `role`; subsequent chunks contain only `delta.content`. * The stream ends with a final chunk whose `finish_reason` is set, followed by a literal `data: [DONE]` line. * If tool calls are used, `delta.tool_calls` arrives incrementally and should be concatenated by `index`. ### Handling errors and timeouts * **Mid-stream errors** arrive as a normal SSE event with an `error` key instead of `choices`. Close the stream and surface the error to the caller. * **Stream disconnects** (network blip, client timeout) cannot be resumed — restart the request. The partial response is not billed beyond the tokens you received. * **Idle timeout**: AIsa closes streams that are idle (no tokens) for more than 60 s. Set your client read timeout to 120 s to give a safety margin. * **Client backpressure**: stop reading from the stream if your downstream consumer is slow — AIsa throttles delivery rather than dropping tokens. Streaming bills the same per-token rate as non-streaming. You pay for tokens that were delivered, even if the stream is cut off mid-response. # Image Generation via Chat Source: https://aisa.one/docs/api-reference/chat/post_chat-completions-image-generation openapi/chat-image-generation.json POST /chat/completions Image generation over the /v1/chat/completions route using OpenAI's multimodal chat schema. As of July 28, 2026 the Wan 2.7 image models have moved to /v1/images/generations; seedream-4-5-251128 is the remaining model configured on this route. Some image models are reachable over the **Chat Completions** endpoint: you send a standard chat request with a multimodal `content` array containing a text prompt, and AIsa returns generated images as `{type: "image"}` parts inside `choices[].message.content[]`. **Routing changed.** `wan2.7-image` and `wan2.7-image-pro` no longer serve this route — calling them here returns `400 model_route_not_supported`. They now use [`POST /v1/images/generations`](/docs/api-reference/chat/post_images-generations) and `POST /v1/images/edits`. `seedream-5-0-260128` and `gpt-image-2` are on `/v1/images/generations` as well. Gemini-compatible `generateContent` requests use [`/v1beta/models/{model}:generateContent`](/docs/api-reference/chat/post_models-model-generatecontent). ## Supported models | Model | Cost | Status | | --------------------- | ----------------- | ----------------------------------------------------------------------------------------------------------------------------------- | | `seedream-4-5-251128` | \$0.036 / request | Configured on this route; probes on July 28, 2026 returned `502 no available channel`, so verify availability before building on it | The multimodal request and response shapes below document how the gateway wraps image generation on the chat route. They were captured from the Wan models while those served this endpoint — re-verify against an actual response before depending on field-level details. ## Request The request schema is the same `POST /v1/chat/completions` you already use for text — the only differences are which model you pass and how `content` is structured. **Critical rule:** `messages[].content` must be an **array of typed parts**. Passing a plain string returns `400 invalid_parameter_error` with the message `"Input should be a valid list: messages[*].content"`. ```bash curl theme={null} curl -sS -X POST "https://api.aisa.one/v1/chat/completions" \ -H "Authorization: Bearer $AISA_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "model": "seedream-4-5-251128", "messages": [ { "role": "user", "content": [ { "type": "text", "text": "A cute red panda, ultra-detailed, cinematic lighting" } ] } ], "n": 1 }' ``` ```python Python theme={null} from openai import OpenAI client = OpenAI(base_url="https://api.aisa.one/v1", api_key="sk-aisa-...") resp = client.chat.completions.create( model="seedream-4-5-251128", messages=[ { "role": "user", "content": [ {"type": "text", "text": "A cute red panda, ultra-detailed, cinematic lighting"} ], } ], n=1, ) # Pull image URLs out of the response for choice in resp.choices: for part in choice.message.content: if part["type"] == "image": print(part["image"]) ``` ```typescript TypeScript theme={null} import OpenAI from "openai"; const client = new OpenAI({ baseURL: "https://api.aisa.one/v1", apiKey: process.env.AISA_API_KEY, }); const resp = await client.chat.completions.create({ model: "seedream-4-5-251128", messages: [ { role: "user", content: [ { type: "text", text: "A cute red panda, ultra-detailed, cinematic lighting" }, ] as any, }, ], n: 1, }); const urls = resp.choices .flatMap((c) => (c.message.content as any[])) .filter((p) => p.type === "image") .map((p) => p.image); ``` ### Request fields | Field | Type | Required | Notes | | ------------------------------------ | ------- | --------------------- | --------------------------------------------------------------------------------- | | `model` | string | yes | `seedream-4-5-251128` | | `messages[].role` | string | yes | `user` for the prompt turn | | `messages[].content` | array | **yes** | Must be an array, not a string | | `messages[].content[].type` | string | yes | `text` for prompt parts; `image_url` for image-to-image inputs | | `messages[].content[].text` | string | when `type=text` | The prompt | | `messages[].content[].image_url.url` | string | when `type=image_url` | Reference image URL | | `n` | integer | no | Number of images. Each is billed separately — pass `1` unless you want candidates | ## Response shape ```json theme={null} { "id": "chatcmpl-fcc86dfd-...", "object": "chat.completion", "created": 1776495713, "model": "seedream-4-5-251128", "choices": [ { "index": 0, "finish_reason": "stop", "message": { "role": "assistant", "content": [ { "type": "image", "image": "https://cdn.aisa.one/images/seedream/..." } ] } } ], "usage": { "prompt_tokens": 104, "completion_tokens": 8, "total_tokens": 112 } } ``` * **One choice per image.** If `n=4`, you get 4 entries in `choices`. * **Every `choice.message.content`** is an array with a single `{ "type": "image", "image": "..." }` part. * `image` is a short-lived URL (download it soon) or base64 data, depending on your workspace configuration. * `usage.total_tokens` reflects the small token cost of the request framing — **billing is per-image** at the rate in the table above, not per token. ## Image-to-image Prepend an `image_url` part to the `content` array and follow it with a text instruction. For the Wan models this workflow now lives on [`POST /v1/images/edits`](/docs/api-reference/chat/post_images-generations): ```json theme={null} { "model": "seedream-4-5-251128", "messages": [ { "role": "user", "content": [ { "type": "image_url", "image_url": { "url": "https://example.com/reference.jpg" } }, { "type": "text", "text": "Transform into an oil painting in the style of Van Gogh" } ] } ], "n": 1 } ``` ## Why the playground shows the Chat Completions path The playground sends exactly the same `POST /v1/chat/completions` request the standard [OpenAI Chat](/docs/api-reference/chat/post_chat-completions) endpoint uses — only the `model` and `content` shape are tuned for images. Your existing OpenAI-compatible SDK code works without modification; just swap the model and content shape. ## Common 4xx causes * `400 invalid_parameter_error — Input should be a valid list: messages[*].content` — `content` was passed as a string; wrap in an array of typed parts. * `400` referencing `messages` — you sent the Gemini-style `contents`/`parts`. Use `messages` with OpenAI multimodal parts. * `400 model_route_not_supported` — the model does not serve this endpoint. The error body lists the routes it does serve; `wan2.7-image`, `wan2.7-image-pro`, `seedream-5-0-260128`, and `gpt-image-2` all belong on [`/v1/images/generations`](/docs/api-reference/chat/post_images-generations). * `502 no available channel` — the route exists but the upstream has no capacity right now. Retry, or use an image model on `/v1/images/generations`. * `500 model_not_found` — your workspace isn't provisioned for this model family. Contact support. See [Error Codes](/docs/api-reference/errors) and [Rate Limits](/docs/api-reference/rate-limits) for more. ## Related The same endpoint used for text models. Gemini-compatible generateContent endpoint. Agent skill that wraps image + video generation. # OpenAI-Compatible Image Generations Source: https://aisa.one/docs/api-reference/chat/post_images-generations openapi/openai-images-generations.json POST /images/generations Generate images with Seedream, Wan, and gpt-image-2 via the standard POST /v1/images/generations endpoint. OpenAI-compatible request shape; Seedream routes require a minimum image size of 3,686,400 pixels (e.g., 1920×1920). The standard OpenAI-compatible `POST /v1/images/generations` endpoint. As of July 28, 2026 it serves `seedream-5-0-260128`, `wan2.7-image`, `wan2.7-image-pro`, and `gpt-image-2`. The older `seedream-4-5-251128` route is reached through [Image Generation via Chat](/docs/api-reference/chat/post_chat-completions-image-generation) instead. ## Routing at a glance | Model | Endpoint | | ----------------------------------- | ----------------------------------------------------------------------------------------------------------- | | `seedream-5-0-260128` | **`POST /v1/images/generations`** *(this page)*, also `POST /v1/chat/completions` | | `wan2.7-image` / `wan2.7-image-pro` | **`POST /v1/images/generations`** *(this page)*, `POST /v1/images/edits` | | `gpt-image-2` | **`POST /v1/images/generations`** *(this page)*, `POST /v1/images/edits` | | `seedream-4-5-251128` | [`POST /v1/chat/completions`](/docs/api-reference/chat/post_chat-completions-image-generation) | | Gemini-compatible models | [`POST /v1beta/models/{model}:generateContent`](/docs/api-reference/chat/post_models-model-generatecontent) | ## Supported models | Model | Cost | Notes | | --------------------- | ---------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------- | | `seedream-5-0-260128` | \$0.035 / request | Min image size **3,686,400 pixels** (e.g., 1920×1920) | | `wan2.7-image` | \$0.030 / request | Also accepts `POST /v1/images/edits` | | `wan2.7-image-pro` | \$0.075 / request | Higher-quality Wan route | | `gpt-image-2` | \$0.03 / request or \$0.05 / image (1024×1024) | Token pricing also applies on some routes — see [AI Model Pricing](/docs/guides/pricing/ai-model-pricing-llm-inference) | ## Size constraint ⚠️ (Seedream routes) Seedream's upstream enforces a minimum of **3,686,400 pixels**. Requests below that are rejected with: ``` 400 InvalidParameter: image size must be at least 3686400 pixels ``` | Size | Pixels | Accepted? | | ----------- | --------- | ------------------- | | `1024x1024` | 1,048,576 | ❌ | | `1536x1536` | 2,359,296 | ❌ | | `1920x1920` | 3,686,400 | ✅ (exact threshold) | | `2048x2048` | 4,194,304 | ✅ | | `2304x1600` | 3,686,400 | ✅ | | `2560x1920` | 4,915,200 | ✅ | Any aspect ratio works as long as `width × height ≥ 3,686,400`. ## Request ```bash curl theme={null} curl -sS -X POST "https://api.aisa.one/v1/images/generations" \ -H "Authorization: Bearer $AISA_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "model": "seedream-5-0-260128", "prompt": "A cute red panda, ultra-detailed, cinematic lighting", "n": 1, "size": "2048x2048" }' ``` ```python Python theme={null} from openai import OpenAI client = OpenAI(base_url="https://api.aisa.one/v1", api_key="sk-aisa-...") resp = client.images.generate( model="seedream-5-0-260128", prompt="A cute red panda, ultra-detailed, cinematic lighting", n=1, size="2048x2048", ) for item in resp.data: print(item.url) ``` ```typescript TypeScript theme={null} import OpenAI from "openai"; const client = new OpenAI({ baseURL: "https://api.aisa.one/v1", apiKey: process.env.AISA_API_KEY, }); const resp = await client.images.generate({ model: "seedream-5-0-260128", prompt: "A cute red panda, ultra-detailed, cinematic lighting", n: 1, size: "2048x2048", }); for (const item of resp.data) { console.log(item.url); } ``` ### Request fields | Field | Type | Required | Notes | | -------- | ------- | -------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `model` | string | yes | One of `seedream-5-0-260128`, `wan2.7-image`, `wan2.7-image-pro`, `gpt-image-2` | | `prompt` | string | yes | Text description of the image to generate | | `n` | integer | no | Number of images. Each is billed separately at the model's per-request rate | | `size` | string | no | `WIDTHxHEIGHT`. Seedream routes must satisfy `width × height ≥ 3,686,400`; `wan2.7-image` and `gpt-image-2` accept smaller sizes (`1024x1024` verified working) | ## Response ```json theme={null} { "model": "seedream-5-0-260128", "created": 1776495432, "data": [ { "url": "https://cdn.aisa.one/images/seedream/...", "size": "2048x2048" } ], "usage": { "generated_images": 1, "output_tokens": 16384, "total_tokens": 16384 } } ``` **AIsa's response adds a few extensions** over the vanilla OpenAI schema: * `model` echoed at the root * `data[].size` — actual dimensions of each returned image * `usage` — includes `generated_images` (drives billing), plus `output_tokens` / `total_tokens` for token accounting URLs in `data[].url` are **short-lived**. Download and persist the image to your own storage before it expires. ## Common 4xx causes * `400 InvalidParameter — image size must be at least 3686400 pixels` — `size` was too small. Use `1920x1920` or larger. * `404 openai_error` — you passed a model that isn't routed through this endpoint (e.g., `wan2.7-image`). Use the [chat-based route](/docs/api-reference/chat/post_chat-completions-image-generation) instead. * `400 invalid_request` — malformed `size` string (e.g., `1024` instead of `1024x1024`). See [Error Codes](/docs/api-reference/errors) and [Rate Limits](/docs/api-reference/rate-limits) for more. ## Related The `/v1/chat/completions` route for the Wan 2.7 family. Gemini-compatible generateContent endpoint. Agent skill that wraps image + video generation. # Claude Messages Source: https://aisa.one/docs/api-reference/chat/post_messages openapi/claude-messages.json POST /messages Create a message Creates a Claude model response using the Anthropic-compatible Messages API. This endpoint mirrors the [Anthropic `/v1/messages` specification](https://platform.claude.com/docs/en/api/messages/create), routed through the AIsa gateway at `https://api.aisa.one/v1/messages`. Use this endpoint when you want to call Claude models (`claude-opus-4-7`, `claude-sonnet-4-6`, `claude-haiku-4-5-20251001`, etc.) with Anthropic's native request format — including extended thinking, tool use, and prompt caching. If you prefer OpenAI-style chat completions, the same Claude models are also available via the [OpenAI Chat](/docs/api-reference/chat/post_chat-completions) endpoint. Authentication uses your AIsa API key as a Bearer token. See the [model catalog](/docs/guides/models) for the full list of supported Claude variants and context windows, and [pricing](/docs/guides/pricing/ai-model-pricing-llm-inference) for per-token rates. # Gemini Generate Content Source: https://aisa.one/docs/api-reference/chat/post_models-model-generatecontent openapi/gemini-openapi.json POST /models/{model}:generateContent Generate content using a Gemini-compatible AIsa model # Create Embeddings Source: https://aisa.one/docs/api-reference/embeddings/post_embeddings-create openapi/jina.json POST /embeddings Generate embedding vectors from text using Jina embeddings, served via the OpenAI-compatible AIsa relay. Generate embedding vectors for one or more input strings. Pass a non-empty `input` string, or an array of strings for batch embedding. The request and response are OpenAI-compatible, so the OpenAI SDK works unchanged by pointing `base_url` at the AIsa relay. **Available models** (both 1024-dim output): * `jina-embeddings-v3` * `jina-embeddings-v5-text-small` Served via the AIsa relay path `/v1/embeddings` — OpenAI-compatible. Billing is token-based at **\$0.050 per 1M tokens**; the `usage.total_tokens` field reports the tokens billed for each request. ```bash curl theme={null} curl https://api.aisa.one/v1/embeddings \ -H "Authorization: Bearer $AISA_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "model": "jina-embeddings-v3", "input": "A fast, OpenAI-compatible embeddings endpoint." }' ``` ```bash curl (v5-text-small) theme={null} curl https://api.aisa.one/v1/embeddings \ -H "Authorization: Bearer $AISA_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "model": "jina-embeddings-v5-text-small", "input": "A fast, OpenAI-compatible embeddings endpoint." }' ``` ```python Python theme={null} from openai import OpenAI client = OpenAI(base_url="https://api.aisa.one/v1", api_key="sk-aisa-...") resp = client.embeddings.create( model="jina-embeddings-v5-text-small", # or "jina-embeddings-v3" input="A fast, OpenAI-compatible embeddings endpoint.", ) print(resp.data[0].embedding) # 1024-dim vector ``` # Analyst Estimates Source: https://aisa.one/docs/api-reference/financial/get_analyst-estimates openapi/analyst-estimates.json GET /analyst-estimates Forward analyst consensus for revenue and EPS, by fiscal period. Forward analyst consensus for one stock: `fiscal_period`, `period`, `revenue` and `earnings_per_share` per estimated period. `ticker` is required; `period` selects annual or quarterly and `limit` caps how many periods come back. Deliberately narrow — no analyst names, no ratings, no price targets, no high/low dispersion. Use it for what the street expects. For what was actually reported, and by how much it beat or missed, use [`get_financial_earnings`](/docs/api-reference/financial/get_earnings). # Facts Source: https://aisa.one/docs/api-reference/financial/get_company-facts openapi/openapi-financial.json GET /company/facts Identity and classification for one company — sector, industry, exchange and CIK. Identity and classification for one company: `name`, `ticker`, `cik`, `sector`, `industry`, `exchange`, `location`, `is_active`, `sec_filings_url`, and the SIC trio `sic_code` / `sic_industry` / `sic_sector`. Accepts either `ticker` or `cik`. No prices and no fundamentals at all. Use it to resolve a ticker into the `cik` that the filings tools accept, or to confirm what sector a company is actually classified under before comparing it to peers. # Earnings Snapshot Source: https://aisa.one/docs/api-reference/financial/get_earnings openapi/openapi-financial.json GET /earnings What a company actually reported, against what was expected, with beat/miss signals. Reported earnings for one stock, actuals against estimates. Each entry carries `report_period`, `fiscal_period`, `filing_date`, `filing_url` and `accession_number`, a `quarterly` block with `revenue`, `estimated_revenue`, `revenue_surprise` and `revenue_surprise_pct`, the same trio for `earnings_per_share`, plus year-over-year change fields. It also returns `signals`: upstream-computed flags such as EPS\_BEAT with a `headline` and the `actual` / `estimate` / `surprise_pct` behind it. `ticker` is required and it is the only parameter. Use it for what a company actually reported. For forward-looking consensus that has not happened yet use [`get_financial_analyst_estimates`](/docs/api-reference/financial/get_analyst-estimates). ## Example ```bash theme={null} curl -X GET "https://api.aisa.one/apis/v1/financial/earnings?ticker=NVDA" \ -H "Authorization: Bearer $AISA_API_KEY" ``` # Historical Financial Metrics Source: https://aisa.one/docs/api-reference/financial/get_financial-metrics openapi/openapi-financial.json GET /financial-metrics Computed valuation, margin and return ratios for one company, across periods. Computed ratios for one company over time, about 49 per period: `market_cap`, `enterprise_value`, `price_to_earnings_ratio`, `price_to_book_ratio`, `price_to_sales_ratio`, `enterprise_value_to_ebitda_ratio`, `free_cash_flow_yield`, `peg_ratio`, `gross_margin`, `operating_margin`, `net_margin`, `return_on_equity`, `return_on_assets`, `return_on_invested_capital`, the turnover and liquidity ratios, each stamped with `report_period` and `fiscal_period`. `period` is required; identify by `ticker` or `cik`. Use it to trend a ratio across periods. For the current values only, [`get_financial_financial_metrics_snapshot`](/docs/api-reference/financial/get_financial-metrics-snapshot) is one row and much smaller. # Financial Metrics Snapshot Source: https://aisa.one/docs/api-reference/financial/get_financial-metrics-snapshot openapi/openapi-financial.json GET /financial-metrics/snapshot The same ratio set, current values only — one row instead of a series. The same ratio set as [`get_financial_financial_metrics`](/docs/api-reference/financial/get_financial-metrics) but current-only: one `snapshot` object of about 41 fields — `market_cap`, `enterprise_value`, `price_to_earnings_ratio`, `price_to_book_ratio`, `price_to_sales_ratio`, `enterprise_value_to_ebitda_ratio`, `free_cash_flow_yield`, `peg_ratio`, the margin and return ratios, and the liquidity ratios. Takes only `ticker` or `cik`, with no period argument. Use it to size up a company right now. For history, or to see whether a multiple is unusual for this company, use [`get_financial_financial_metrics`](/docs/api-reference/financial/get_financial-metrics). # All Financial Statements Source: https://aisa.one/docs/api-reference/financial/get_financials openapi/openapi-financial.json GET /financials All three financial statements for one company in a single call. All three statements for one company in a single call. Returns a `financials` object holding `income_statements`, `balance_sheets` and `cash_flow_statements`, each the same shape the dedicated tools return. `period` is required (annual, quarterly or ttm); identify the company by `ticker` or `cik` and cap with `limit`. Use it when you need the full picture and would otherwise make three calls. When you only need one statement, [`get_financial_financials_income_statements`](/docs/api-reference/financial/get_financials-income-statements), [`get_financial_financials_balance_sheets`](/docs/api-reference/financial/get_financials-balance-sheets) or [`get_financial_financials_cash_flow_statements`](/docs/api-reference/financial/get_financials-cash-flow-statements) returns far less data; when you need a handful of named fields across several companies, [`post_financial_financials_search_line_items`](/docs/api-reference/financial/post_financials-search-line-items) is narrower still. # Balance Sheets Source: https://aisa.one/docs/api-reference/financial/get_financials-balance-sheets openapi/openapi-financial.json GET /financials/balance-sheets Balance sheets for one company — assets, liabilities and equity, about 36 fields per period. Balance sheets for one company, about 36 fields per period: `total_assets`, `current_assets`, `cash_and_equivalents`, `inventory`, `trade_and_non_trade_receivables`, `property_plant_and_equipment`, `goodwill_and_intangible_assets`, `total_liabilities`, `current_liabilities`, `current_debt`, `trade_and_non_trade_payables`, `deferred_revenue` and the equity lines, stamped with `report_period`, `fiscal_period`, `currency` and `filing_url`. `period` is required. Use it for capital structure and liquidity. For the ratios already computed off these numbers use [`get_financial_financial_metrics`](/docs/api-reference/financial/get_financial-metrics). # Cash Flow Statements Source: https://aisa.one/docs/api-reference/financial/get_financials-cash-flow-statements openapi/openapi-financial.json GET /financials/cash-flow-statements Cash flow statements for one company — operating, investing and financing, about 27 fields per period. Cash flow statements for one company, about 27 fields per period: `net_cash_flow_from_operations`, `net_cash_flow_from_investing`, `net_cash_flow_from_financing`, `capital_expenditure`, `depreciation_and_amortization`, `share_based_compensation`, `issuance_or_repayment_of_debt_securities`, `issuance_or_purchase_of_equity_shares` and `dividends_and_other_cash_distributions`, stamped with `report_period`, `fiscal_period` and `currency`. `period` is required. Use it to see cash generation rather than accounting earnings. Free cash flow yield and similar derived figures live in [`get_financial_financial_metrics`](/docs/api-reference/financial/get_financial-metrics). # Income Statements Source: https://aisa.one/docs/api-reference/financial/get_financials-income-statements openapi/openapi-financial.json GET /financials/income-statements Income statements for one company — revenue through to net income, about 32 fields per period. Income statements for one company, about 32 fields per period: `revenue`, `cost_of_revenue`, `gross_profit`, `operating_expense`, `selling_general_and_administrative_expenses`, `research_and_development`, `operating_income`, `interest_expense`, `ebit`, `income_tax_expense`, `net_income`, `net_income_common_stock` and the per-share lines, each stamped with `report_period`, `fiscal_period`, `currency`, `filing_date` and `filing_url`. `period` is required (annual, quarterly or ttm). Use it for the revenue-to-earnings walk. For all three statements at once use [`get_financial_financials`](/docs/api-reference/financial/get_financials). # Insider Trades (by ticker) Source: https://aisa.one/docs/api-reference/financial/get_insider-trades openapi/openapi-financial.json GET /insider-trades Form 4 insider buys and sells — who, how many shares, at what price, and when. Form 4 insider transactions for one stock. Each row carries the person (`name`, `title`, `is_board_director`), the trade (`transaction_date`, `transaction_code`, `transaction_type`, `transaction_shares`, `transaction_price_per_share`, `transaction_value`), the resulting position (`shares_owned_before_transaction`, `shares_owned_after_transaction`) and the filing (`form_type`, `filing_date`, `security_title`). `ticker` is required. Filter with `name` or `transaction_type`, and bound by filing date with `filing_date`, `filing_date_gte`, `filing_date_lte`, `filing_date_gt` or `filing_date_lt`. Use it for who inside the company bought or sold and when. # Historical Interest Rates Source: https://aisa.one/docs/api-reference/financial/get_macro-interest-rates openapi/macro_snapshot.json GET /macro/interest-rates One central bank's policy rate over time. The bank code must be uppercase. One central bank's policy rate over time, as an `interest_rates` array of `bank`, `name`, `date` and `rate`. `bank` is required and bound by `start_date` and `end_date`. Trap worth knowing: the code is case-sensitive and must be uppercase — FED works, fed returns HTTP 404 with "No data found", which reads like an empty result rather than a bad argument. Valid codes are FED, ECB, BOJ, BOE, BOC, RBA, PBOC, SNB, RBI and BOK; [`get_financial_macro_interest_rates_snapshot`](/docs/api-reference/financial/get_macro-interest-rates-snapshot) with no arguments lists them all. # Interest Rates Snapshot Source: https://aisa.one/docs/api-reference/financial/get_macro-interest-rates-snapshot openapi/macro_snapshot.json GET /macro/interest-rates/snapshot Current policy rates for ten central banks, and the place to discover the valid bank codes. Current policy rates for the ten central banks tracked here, as an `interest_rates` array of `bank`, `name`, `rate` and `date`. `bank` is optional — omit it to get all ten at once, which is also how you discover the valid codes: FED, ECB, BOJ, BOE, BOC, RBA, PBOC, SNB, RBI and BOK. Use it for the current rate backdrop. For one bank's rate path over time use [`get_financial_macro_interest_rates`](/docs/api-reference/financial/get_macro-interest-rates). # Search Financials Source: https://aisa.one/docs/api-reference/financial/post_financials-search-line-items openapi/openapi-financial.json POST /financials/search/line-items Pull named line items across several companies at once, instead of three full statements each. Pull named financial line items across one or more companies in a single call. Body takes `tickers` and `line_items` (both required, both arrays), plus `period` (annual, quarterly or ttm) and `limit`. Returns `search_results` with one row per ticker and period carrying only the fields you asked for, alongside `report_period`, `period` and `currency`. Use it to build a comparison table without pulling three full statements per company. The item names are the same field names the statement tools return, so look one up there first if unsure. For everything about a single company use [`get_financial_financials`](/docs/api-reference/financial/get_financials). # Stock Screener Source: https://aisa.one/docs/api-reference/financial/post_financials-search-screener openapi/openapi-financial.json POST /financials/search/screener Find tickers by numeric conditions — the only tool here that does not need a ticker up front. Find tickers that match numeric conditions. Body takes `filters` — each a `field`, an `operator` and a `value` — plus `limit`. Returns `results` with `ticker`, `currency`, `sector`, `industry` and whichever filtered field was matched. This is the only tool here that works without knowing a ticker in advance; everything else takes one as input. Filterable fields are the metric names [`get_financial_financial_metrics`](/docs/api-reference/financial/get_financial-metrics) returns. Use it to build a candidate list, then pull detail on each name with the statement or metric tools. # Sonar Source: https://aisa.one/docs/api-reference/perplexity/post_perplexity-sonar openapi/perplexity-openapi.json POST /perplexity/sonar Ask a question and get a written answer with web citations, rather than a list of links to read yourself. Ask a question and get a written answer with web citations, rather than a list of links to read yourself. Body is OpenAI chat-completions shaped: `model` (required, `sonar`) and `messages`. Returns `choices[0].message.content` as prose, plus `citations` (an array of URL strings) and `search_results[]` with `title`, `url`, `snippet`, `date` and `source`, and a `usage` block. Measured at about 3 seconds. Billed at a flat \$0.012 per request. This is the cheapest and fastest of the four Perplexity endpoints — use it for a single factual question. Step up to [`post_perplexity_sonar_pro`](/docs/api-reference/perplexity/post_perplexity-sonar-pro) for multi-part questions, or [`post_perplexity_sonar_reasoning_pro`](/docs/api-reference/perplexity/post_perplexity-sonar-reasoning-pro) when the answer requires working through steps. If you need results you can iterate over rather than prose, use [`post_tavily_search`](/docs/api-reference/search/post_tavily-search); `post_exa_answer` answers the same shape of question with semantic retrieval, at \$0.08. ## Example ```bash theme={null} curl -X POST "https://api.aisa.one/apis/v1/perplexity/sonar" \ -H "Authorization: Bearer YOUR_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "model": "sonar", "messages": [ {"role": "user", "content": "What are the latest developments in quantum computing?"} ] }' ``` # Sonar Deep Research Source: https://aisa.one/docs/api-reference/perplexity/post_perplexity-sonar-deep-research openapi/perplexity-openapi.json POST /perplexity/sonar-deep-research Commission a report: this endpoint runs many searches and writes a long, cited document. Commission a report: this endpoint runs many searches and writes a long, cited document. `model` (required, `sonar-deep-research`) and `messages` in; `choices[0].message.content`, `citations`, `search_results[]` and `usage` out, where `usage` also reports `num_search_queries` and `reasoning_tokens`. ⚠️ Budget for the wait: a two-sentence question measured **192 seconds** and returned 86 KB after 10 upstream searches — roughly 60 times slower and 10 times larger than [`post_perplexity_sonar`](/docs/api-reference/perplexity/post_perplexity-sonar), at the same flat \$0.012 per request. Many clients time out well before it answers, so call it only when a report is genuinely the deliverable, and never in a loop. For anything you would read in one sitting, the other three Perplexity endpoints answer in seconds. ## Example ```bash theme={null} curl -X POST "https://api.aisa.one/apis/v1/perplexity/sonar-deep-research" \ -H "Authorization: Bearer YOUR_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "model": "sonar-deep-research", "messages": [ {"role": "user", "content": "Write a comprehensive analysis of the global semiconductor supply chain risks in 2026"} ] }' ``` # Sonar Pro Source: https://aisa.one/docs/api-reference/perplexity/post_perplexity-sonar-pro openapi/perplexity-openapi.json POST /perplexity/sonar-pro Ask a question that needs more than one search pass and get a written answer with citations. Ask a question that needs more than one search pass and get a written answer with citations. Same request and response shape as [`post_perplexity_sonar`](/docs/api-reference/perplexity/post_perplexity-sonar) — `model` (required, `sonar-pro`) and `messages` in, `choices[0].message.content`, `citations`, `search_results[]` and `usage` out. Measured at about 10 seconds, roughly three times `sonar`, for the same flat \$0.012 per request. Use it for questions with several parts or follow-ups. For a single lookup `sonar` answers in a third of the time at the same price; when the difficulty is reasoning rather than retrieval, [`post_perplexity_sonar_reasoning_pro`](/docs/api-reference/perplexity/post_perplexity-sonar-reasoning-pro) shows its working. ## Example ```bash theme={null} curl -X POST "https://api.aisa.one/apis/v1/perplexity/sonar-pro" \ -H "Authorization: Bearer YOUR_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "model": "sonar-pro", "messages": [ {"role": "user", "content": "Compare the economic policies of the US and EU regarding AI regulation in 2025-2026"} ] }' ``` # Sonar Reasoning Pro Source: https://aisa.one/docs/api-reference/perplexity/post_perplexity-sonar-reasoning-pro openapi/perplexity-openapi.json POST /perplexity/sonar-reasoning-pro Ask a question that has to be worked through, not just looked up, and get a step-by-step answer backed by web search. Ask a question that has to be worked through, not just looked up, and get a step-by-step answer backed by web search. Same shape as the other Perplexity endpoints — `model` (required, `sonar-reasoning-pro`) and `messages` in; `choices[0].message.content`, `citations`, `search_results[]` and `usage` out. Measured at about 5 seconds, flat \$0.012 per request. Use it for comparison, causation and analysis. When the question is simply what is the case, [`post_perplexity_sonar`](/docs/api-reference/perplexity/post_perplexity-sonar) is faster; when you need a long report over many sources rather than an answer, [`post_perplexity_sonar_deep_research`](/docs/api-reference/perplexity/post_perplexity-sonar-deep-research). ## Example ```bash theme={null} curl -X POST "https://api.aisa.one/apis/v1/perplexity/sonar-reasoning-pro" \ -H "Authorization: Bearer YOUR_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "model": "sonar-reasoning-pro", "messages": [ {"role": "user", "content": "Analyze whether Tesla stock is overvalued based on current P/E ratio compared to industry averages"} ] }' ``` # Rerank Documents Source: https://aisa.one/docs/api-reference/rerank/post_rerank-create openapi/jina.json POST /rerank Reorder documents by relevance to a query using Jina rerank, served via the OpenAI-compatible AIsa relay. Rerank a list of documents against a `query` using `jina-reranker-v3`. Provide a non-empty `query` and a non-empty `documents` array; results come back ordered by `relevance_score`. Use the optional `top_n` to return only the most relevant documents. This pairs naturally with embeddings-based retrieval: embed and shortlist candidates, then rerank for final ordering. Served via the AIsa relay path `/v1/rerank` — OpenAI-compatible. Billing is token-based at **\$0.050 per 1M tokens**; the `usage.total_tokens` field reports the tokens billed for each request. ```bash curl theme={null} curl https://api.aisa.one/v1/rerank \ -H "Authorization: Bearer $AISA_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "model": "jina-reranker-v3", "query": "What is the capital of France?", "documents": [ "Paris is the capital of France.", "Berlin is the capital of Germany.", "The Eiffel Tower is in Paris." ], "top_n": 2 }' ``` ```python Python theme={null} import requests resp = requests.post( "https://api.aisa.one/v1/rerank", headers={"Authorization": "Bearer sk-aisa-..."}, json={ "model": "jina-reranker-v3", "query": "What is the capital of France?", "documents": [ "Paris is the capital of France.", "Berlin is the capital of Germany.", "The Eiffel Tower is in Paris.", ], "top_n": 2, }, ) print(resp.json()["results"]) ``` # Poll an Agent Run Source: https://aisa.one/docs/api-reference/search/get_exa-agent-run openapi/exa.json GET /exa/agent/runs/{jobId} Fetch an Agent run submitted by post_exa_agent_runs, by its jobId. Fetch an Agent run submitted by [`post_exa_agent_runs`](/docs/api-reference/search/post_exa-agent-runs), by its `jobId`. Returns the same envelope — `id`, `status`, `createdAt`, `completedAt`, `pricing`, `output`, `error`. Repeat until `status` is `completed`, `failed` or `cancelled`; on success `output` carries `text`, `structured` and `grounding`. Reads a run only; it cannot start one. # Poll a Batch Scrape Job Source: https://aisa.one/docs/api-reference/search/get_firecrawl-batch-scrape-job openapi/firecrawl.json GET /firecrawl/batch-scrape/{jobId} Fetch a batch scrape job submitted by post_firecrawl_batch_scrape, by its jobId. Fetch a batch scrape job submitted by [`post_firecrawl_batch_scrape`](/docs/api-reference/search/post_firecrawl-batch-scrape), by its `jobId`. Returns the same envelope — `id`, `status`, `createdAt`, `completedAt`, `pricing`, `output`, `error`. Repeat until `status` is terminal; on success `output` is an array of documents with `markdown` and `metadata`. Reads a job only; it cannot start one. # Poll a Crawl Job Source: https://aisa.one/docs/api-reference/search/get_firecrawl-crawl-job openapi/firecrawl.json GET /firecrawl/crawl/{jobId} Fetch a crawl job submitted by post_firecrawl_crawl, by its jobId. Fetch a crawl job submitted by [`post_firecrawl_crawl`](/docs/api-reference/search/post_firecrawl-crawl), by its `jobId`. Returns the same envelope the submission returned — `id`, `status`, `createdAt`, `completedAt`, `pricing`, `output`, `error`. Repeat until `status` is `completed`, `failed` or `cancelled`; on success `output` is an array of pages with `markdown` and `metadata`. Polling is cheap and fast, measured under a second. This tool only reads a job — it cannot start one. # YouTube Search API Source: https://aisa.one/docs/api-reference/search/get_youtube-search openapi/youte-search.json GET /youtube/search Search YouTube and get back matching videos, channels, and playlists. Search YouTube and get back matching videos, channels, and playlists. Set `engine=youtube` and pass the query in `q`; both are required. Optionally narrow by country (`gl`) and interface language (`hl`), or pass a YouTube filter token in `sp` for pagination and advanced filters such as upload date, duration, or result type. Use this to find video content on a topic, track a channel's recent uploads, or gauge how much video coverage a subject has. Note: this is served through the AIsa mapped path `/apis/v1/youtube/search`; the upstream provider's canonical path is not mounted directly. # Anthropic Web Search Source: https://aisa.one/docs/api-reference/search/post_anthropic-websearch-search openapi/websearch.json POST /anthropic-websearch/search Ask a question and get a Claude-written answer grounded in a live web search, with the underlying sources and inline citations, billed at exact cost. Ask a question and get an answer that Claude wrote after searching the live web. Send a normal Messages request — a `messages` array plus `max_tokens` — and the endpoint injects a fixed, server-pinned model and the `web_search` tool for you; you cannot override the model or add tools, which keeps cost bounded. Claude decides when to search (up to `max_uses` searches, default 5), reads the results, and answers with inline citations. The response is a standard Anthropic Messages object: `content[]` contains `server_tool_use` (the queries issued), `web_search_tool_result` (the sources found) and `text` blocks (the answer with `citations`), and `usage.server_tool_use.web_search_requests` reports how many searches were billed. Billing is pay-as-you-go at exact cost: `web_search_requests × $0.01` plus the model's own token cost, with no markup; a failed search (HTTP 200 `web_search_tool_result_error`) is not billed. Use this when you want a written, cited answer grounded in current web content — for open-web research that returns ranked links and page text in one call use [`post_tavily_search`](/docs/api-reference/search/post_tavily-search) instead, and for the OpenAI-model equivalent see [`post_openai_websearch_search`](/docs/api-reference/search/post_openai-websearch-search). # BytePlus Fetch Source: https://aisa.one/docs/api-reference/search/post_byteplus-fetch openapi/byteplus-search.json POST /byteplus/fetch Fetch a URL and return clean, structured page content — title, body text, and publish time. Fetch a single URL and get back clean, structured page content under `Result.Data` — `Title`, `ContentText` (clean body text), `PublishTime` (Unix seconds), plus `StatusCode` and `Url`. `Url` is required. The response wraps `ResponseMetadata.RequestId` and a `Result` object holding `Data` and `LogId`. Billed a flat \$0.00088 per successful call; failed requests are not charged. Use this to extract full page content for URLs you already have — typically pairing it with [`post_byteplus_web_search`](/docs/api-reference/search/post_byteplus-web-search) results to turn a list of links into readable content for RAG or analysis. # BytePlus Web Search Source: https://aisa.one/docs/api-reference/search/post_byteplus-web-search openapi/byteplus-search.json POST /byteplus/web-search AI-oriented real-time web search that returns titled results with links and snippets. Run a real-time web search built for AI agents and get back a ranked list of titled results with links and snippets. `Query` is required; narrow the result set with `Count` (up to 20), `Filter` (`Sites` to restrict, `BlockHosts` to exclude), `Language`, and `TimeRange`. The response wraps `ResponseMetadata.RequestId` and a `Result` object whose `WebResults` array holds each hit (`Title`, `Url`, `Snippet`, `Summary`, `SiteName`, `PublishTime`/`PublishTimeUnix`), alongside `ResultCount`, `SearchContext`, and `TimeCost`. Billed a flat \$0.00528 per successful call; failed requests are not charged. Use it for RAG retrieval augmentation, competitive/PR monitoring, fact-checking, and content sourcing. ⚠️ Results carry links and snippets, not full page text — pair each result URL with [`post_byteplus_fetch`](/docs/api-reference/search/post_byteplus-fetch) to pull clean, structured page content. # Exa Agent Runs Source: https://aisa.one/docs/api-reference/search/post_exa-agent-runs openapi/exa.json POST /exa/agent/runs Hand a research task to an agent that works in the background. Hand a research task to an agent that works in the background. `query` and an `Idempotency-Key` are required; `effort` trades depth against time, `outputSchema` shapes the result, `dataSources` restricts where it looks, and `previousRunId` continues an earlier run. Asynchronous. Submitting returns HTTP 202 and a job envelope — `id`, `object`, `endpoint`, `status`, `createdAt`, `completedAt`, `pricing`, `output`, `error` — with `output` still null. Poll [`get_exa_agent_run`](/docs/api-reference/search/get_exa-agent-run) until terminal; `output` then carries `text`, `structured` and `grounding`. A one-sentence question completed in well under a minute. Billed a flat \$0.10 per run — `pricing.billingMode` is `fixed_request`, so unlike a Firecrawl crawl the price does not grow with what it finds. Use it when a report is the deliverable. For an answer you read in one sitting, [`post_exa_answer`](/docs/api-reference/search/post_exa-answer) returns in about two seconds. Send a fresh `Idempotency-Key` per distinct task. # Exa Answer Source: https://aisa.one/docs/api-reference/search/post_exa-answer openapi/exa.json POST /exa/answer Ask a question and get a written answer with citations. Ask a question and get a written answer with citations. `query` is required; `text` includes the source text and `outputSchema` shapes a structured reply. Returns `requestId`, `answer` as prose, `citations[]` with `id`, `title` and `url`, and `costDollars`. Measured at 2.1 seconds with 8 citations. Billed a flat \$0.08 per successful request. It sits between a search and a research run: faster and cheaper than [`post_exa_agent_runs`](/docs/api-reference/search/post_exa-agent-runs), and more direct than reading [`post_exa_search`](/docs/api-reference/search/post_exa-search) results yourself. [`post_perplexity_sonar`](/docs/api-reference/perplexity/post_perplexity-sonar) answers the same shape of question for \$0.012 — reach for Exa when the retrieval needs to be semantic. # Exa Contents Source: https://aisa.one/docs/api-reference/search/post_exa-contents openapi/exa.json POST /exa/contents Fetch page text and metadata for URLs you already have. Fetch page text and metadata for URLs you already have. `ids` is required and takes the `id` values from [`post_exa_search`](/docs/api-reference/search/post_exa-search) — which are plain URLs, so any URL works. Toggle `text`, `highlights`, `summary`, `subpages` and `livecrawl`. Returns `results[]` with `id`, `title`, `url`, `author` and `text`, plus a **`statuses[]` array giving per-URL `status` and `source`** — read it, because a URL that could not be fetched is reported there rather than raising. Cached results are served instantly; a miss falls back to a live crawl. Measured at 1.2 seconds. Billed a flat \$0.08 per successful request. For a whole site rather than a URL list, [`post_firecrawl_crawl`](/docs/api-reference/search/post_firecrawl-crawl). # Exa Search Source: https://aisa.one/docs/api-reference/search/post_exa-search openapi/exa.json POST /exa/search Search the web by meaning rather than by keyword. Search the web by meaning rather than by keyword. `query` is required; narrow with `category`, `includeDomains`, `excludeDomains`, `startPublishedDate`, `endPublishedDate`, and set `numResults`. Returns `requestId`, `resolvedSearchType`, `searchTime`, `costDollars` and `results[]` with `id`, `title` and `url`. **`id` is the URL**, and it is what [`post_exa_contents`](/docs/api-reference/search/post_exa-contents) takes. Measured at 1.4 seconds — the fastest search here. Billed a flat \$0.08 per successful request. ⚠️ Results carry **no page text** unless you ask: pass `contents`, or follow up with [`post_exa_contents`](/docs/api-reference/search/post_exa-contents). Choose it over [`post_tavily_search`](/docs/api-reference/search/post_tavily-search) when the query is a description rather than keywords; choose Tavily when you want the text in the same call, and [`post_exa_answer`](/docs/api-reference/search/post_exa-answer) when you want a written answer rather than a list. # Firecrawl Batch Scrape Source: https://aisa.one/docs/api-reference/search/post_firecrawl-batch-scrape openapi/firecrawl.json POST /firecrawl/batch-scrape Scrape many URLs as one background job. Scrape many URLs as one background job. `urls` and an `Idempotency-Key` are required; `maxConcurrency`, `onlyMainContent`, `includeTags`, `excludeTags`, `maxAge`, `minAge` and `timeout` tune it. Asynchronous. Submitting returns HTTP 202 and a job envelope — `id`, `object`, `endpoint`, `status`, `createdAt`, `completedAt`, `pricing`, `output`, `error` — with `output` still null. Poll [`get_firecrawl_batch_scrape_job`](/docs/api-reference/search/get_firecrawl-batch-scrape-job) until terminal; `output` is then an array of documents with `markdown` and `metadata`. Use it when you have a list of URLs and do not need them immediately. When you do need them immediately, [`post_tavily_extract`](/docs/api-reference/search/post_tavily-extract) returns a small batch synchronously in about a second; for a single page [`post_firecrawl_scrape`](/docs/api-reference/search/post_firecrawl-scrape). Send a fresh `Idempotency-Key` per distinct batch. # Firecrawl Crawl Source: https://aisa.one/docs/api-reference/search/post_firecrawl-crawl openapi/firecrawl.json POST /firecrawl/crawl Crawl a whole site rooted at url and return the content of every page it keeps. Crawl a whole site rooted at `url` and return the content of every page it keeps. `url`, `limit` and an `Idempotency-Key` are required; steer it with `includePaths`, `excludePaths`, `maxDiscoveryDepth`, `crawlEntireDomain`, `allowSubdomains`, `delay` and `maxConcurrency`. Asynchronous. Submitting returns HTTP 202 and a job envelope — `id`, `object`, `endpoint`, `status`, `createdAt`, `completedAt`, `pricing`, `output`, `error` — with `output` still null. Poll [`get_firecrawl_crawl_job`](/docs/api-reference/search/get_firecrawl-crawl-job) until `status` is `completed`, `failed` or `cancelled`; `output` is then an array of pages, each with `markdown` and `metadata`. A 3-page crawl measured 43 KB and finished in under a minute, and `pricing.billingMode` is `metered_result`, so **cost scales with what it finds** — set `limit`. Send a fresh `Idempotency-Key` per distinct crawl; reusing one returns the earlier job instead of starting a new one. For a handful of known URLs [`post_firecrawl_batch_scrape`](/docs/api-reference/search/post_firecrawl-batch-scrape) is cheaper, and for structure alone [`post_firecrawl_map`](/docs/api-reference/search/post_firecrawl-map) costs far less. # Firecrawl Map Source: https://aisa.one/docs/api-reference/search/post_firecrawl-map openapi/firecrawl.json POST /firecrawl/map List the URLs reachable from a starting page, without fetching any content. List the URLs reachable from a starting page, without fetching any content. `url` and `limit` are both required (limit 1 to 100000). Returns `success`, a request `id`, and `links[]` with `url` and `title` — note these are **objects with a title**, unlike [`post_tavily_map`](/docs/api-reference/search/post_tavily-map) which returns bare strings. Measured at about 9 seconds. Billed 1 credit per discovered link, so `limit` is a cost control, not just a page control. Use it to size a site before paying to crawl it, then fetch only what matters with [`post_firecrawl_scrape`](/docs/api-reference/search/post_firecrawl-scrape). When you want content and structure in one pass, [`post_firecrawl_crawl`](/docs/api-reference/search/post_firecrawl-crawl). # Firecrawl Parse Source: https://aisa.one/docs/api-reference/search/post_firecrawl-parse openapi/firecrawl.json POST /firecrawl/parse Parse an HTML file you upload and get markdown back. Parse an HTML file you upload and get markdown back. This is `multipart/form-data` with two fields: `file` (an HTML upload that must carry a `text/html` content type or an `.html`/`.htm` filename) and `options` (a JSON string that must set `proxy` to `basic`, may additionally set `formats` to `["markdown"]`, and is capped at 64 KB). Returns `success` and `data.markdown` with `metadata`. Billed 1 Firecrawl credit. ⚠️ **Not available as an MCP tool.** A tool call carries JSON, so the file arrives as a plain form field with no filename and upstream rejects it — verified. Over MCP use [`post_firecrawl_scrape`](/docs/api-reference/search/post_firecrawl-scrape) with a URL instead. This endpoint is for HTTP clients that hold an actual file. # Firecrawl Scrape Source: https://aisa.one/docs/api-reference/search/post_firecrawl-scrape openapi/firecrawl.json POST /firecrawl/scrape Fetch one URL and get its main content back as markdown. Fetch one URL and get its main content back as markdown. `url` and `proxy` are both required — `proxy` must be `basic` on the metered profile — and `formats` selects the output. Returns `success` and `data` with `markdown` plus a large `metadata` object carrying the page's og: and twitter: tags, `statusCode`, `sourceURL` and `language`. Measured at about 10 seconds for one page. ⚠️ The URL must be HTTPS and must not point at a PDF; both are rejected rather than best-effort. Use it when you have the URL and want the text. For several URLs at once [`post_firecrawl_batch_scrape`](/docs/api-reference/search/post_firecrawl-batch-scrape) runs them as one background job, and [`post_tavily_extract`](/docs/api-reference/search/post_tavily-extract) does a small batch synchronously. To find URLs first, [`post_firecrawl_map`](/docs/api-reference/search/post_firecrawl-map). # Firecrawl Search Source: https://aisa.one/docs/api-reference/search/post_firecrawl-search openapi/firecrawl.json POST /firecrawl/search Search the web and get back ranked results. Search the web and get back ranked results. `query` is required; `limit` sets how many. Returns `success`, `creditsUsed`, a request `id`, and `data.web[]` with `url`, `title`, `description` and `position` — **titles and snippets only, no page text**. Measured at about 15 seconds for 2 results, the slowest of the search tools here. Billed per Firecrawl credit, roughly `ceil(limit / 10) * 2`. On the AIsa metered profile only the web source is supported; `scrapeOptions`, enterprise mode and non-web sources are rejected. Reach for something else when: you want the page text in the same call — [`post_tavily_search`](/docs/api-reference/search/post_tavily-search) returns it and answers in a third of the time; you already know the URLs — [`post_firecrawl_scrape`](/docs/api-reference/search/post_firecrawl-scrape); you want relevance judged by meaning rather than keywords — [`post_exa_search`](/docs/api-reference/search/post_exa-search). # OpenAI Web Search Source: https://aisa.one/docs/api-reference/search/post_openai-websearch-search openapi/websearch.json POST /openai-websearch/search Ask a question and get an OpenAI-model answer grounded in a live web search, with the underlying sources and URL citations, billed at exact cost. Ask a question and get an answer that an OpenAI model wrote after searching the live web. Send a Responses request — an `input` string (or message array) — and the endpoint injects a fixed, server-pinned model and the `web_search` tool for you; the model, tool and per-request search cap are server-controlled to keep cost bounded. The reply is a standard OpenAI Responses object: `output[]` contains `web_search_call` items (each a search that ran) and a `message` item with the answer text and URL citations, and the billed search count equals the number of `web_search_call` items. Billing is pay-as-you-go at exact cost: `web_search_calls × $0.01` plus the model's own token cost (fresh input = `input_tokens − cached`), with no markup. Use this when you want a written, cited answer grounded in current web content from an OpenAI model — for the Anthropic-model equivalent see [`post_anthropic_websearch_search`](/docs/api-reference/search/post_anthropic-websearch-search), and for raw ranked links with extracted page text use [`post_tavily_search`](/docs/api-reference/search/post_tavily-search). # Oxylabs AI Search Source: https://aisa.one/docs/api-reference/search/post_oxylabs-ai-search openapi/oxylabs.json POST /oxylabs/ai-search Query the major AI answer engines and get back the AI-generated answer text plus its cited source URLs for GEO/AEO visibility monitoring. Run a real query against a major AI answer engine and get back the AI-generated `answer_text` together with the cited source URLs — built for GEO/AEO, so you can monitor how a brand or product is surfaced and cited across AI answers. Pick the engine with `source` (`chatgpt`, `gemini`, `perplexity`, `google_search` for Google AI Overviews, or `google_ai_mode`) and send the parameters that source expects: `prompt` for chatgpt/gemini/perplexity, `query` with `render: "html"` for the Google-type sources, plus `parse: true` and a country-level `geo_location` such as `"United States"`. The request body is passed through unchanged to the upstream engine, and the parsed shape inside each `results[]` entry varies by source — `google_search` returns `ai_overviews[]` with `answer_text` and `references[]{source, url}` (the shape documented here), while chatgpt/gemini return `response_text` + `citations[]`, perplexity returns `top_sources[]`/`sources_results[]`, and google\_ai\_mode returns `content.citations[]{text, urls[]}`. Billed at a flat **\$0.001** per successful result; 400/429/5xx/6xx and upstream 4xx responses are not billed. AI sources (chatgpt/gemini/perplexity) take \~40–60s and Google-type sources \~4–8s, so set your client timeout to at least **90s**. # Tavily Crawl Source: https://aisa.one/docs/api-reference/search/post_tavily-crawl openapi/tavily.json POST /tavily/crawl Walk a site from a root url and return the content of the pages it finds. Walk a site from a root `url` and return the content of the pages it finds. Steer it with natural-language `instructions` plus regex path and domain filters, and bound it with `max_depth`, `max_breadth` and `limit`. Returns `base_url` and `results[]` with `url` and `raw_content`. Measured at about 4.5 seconds for a 3-page limit; cost and time grow with the bounds you set, so set them. Use it for broad coverage of one site — documentation, a catalogue, a competitor's blog. It answers synchronously, which `post_firecrawl_crawl` does not: that one runs as a background job and suits crawls too large to wait on. For a handful of known pages [`post_tavily_extract`](/docs/api-reference/search/post_tavily-extract) is far cheaper; to size a site before paying to crawl it, run [`post_tavily_map`](/docs/api-reference/search/post_tavily-map) first. # Tavily Extract Source: https://aisa.one/docs/api-reference/search/post_tavily-extract openapi/tavily.json POST /tavily/extract Fetch clean, parsed content for URLs you already have — from a search result, a sitemap, or a user. Fetch clean, parsed content for URLs you already have — from a search result, a sitemap, or a user. `urls` is required and takes several at once. Returns `results[]` with `url`, `title`, `raw_content` and `images`, plus a `failed_results[]` array — **read that one**, because a page that could not be fetched is reported there rather than raising an error. Choose `format` (markdown or text) and `extract_depth`. Measured at about 1 second for one page. Use this instead of [`post_tavily_search`](/docs/api-reference/search/post_tavily-search) whenever you can already name the pages; searching for pages you can name costs more and may not return them. For a long list that can wait, `post_firecrawl_batch_scrape` runs it as a background job. To discover the URLs of a whole site first, use [`post_tavily_map`](/docs/api-reference/search/post_tavily-map). # Tavily Map Source: https://aisa.one/docs/api-reference/search/post_tavily-map openapi/tavily.json POST /tavily/map List a site's URLs from a root url without fetching any page content. List a site's URLs from a root `url` without fetching any page content. Steer it with natural-language `instructions` and regex `select_paths` / `exclude_paths` / `select_domains` filters. Returns `base_url` and `results` — **a flat array of URL strings, not objects** — with `response_time` and `request_id`. Fast and cheap: measured at about 1.5 seconds. Use it to size a site before committing to a crawl, then fetch only the parts that matter with [`post_tavily_extract`](/docs/api-reference/search/post_tavily-extract). When you want the content rather than the shape, [`post_tavily_crawl`](/docs/api-reference/search/post_tavily-crawl) does both in one call. # Tavily Search Source: https://aisa.one/docs/api-reference/search/post_tavily-search openapi/tavily.json POST /tavily/search Search the web and get back ranked results with the page text already extracted, so there is no second call to fetch content. Search the web and get back ranked results with the page text already extracted, so there is no second call to fetch content. `query` is required. Returns `results[]` with `url`, `title`, `content` (the extracted excerpt), `score` and optionally `raw_content`, alongside `query`, `images`, `response_time` and `request_id`; set `include_answer` to also get a one-paragraph `answer`. Filter with `topic` (general/news/finance), `time_range` or explicit `start_date`/`end_date`, and trade cost against depth with `search_depth`. Measured at roughly 6 seconds for 2 results. This is the default choice for open-web research, and the only search here that returns ranked results and page text in one call. Reach past it when: you already know the URLs — [`post_tavily_extract`](/docs/api-reference/search/post_tavily-extract) is cheaper and exact; the query is a description rather than keywords — `post_exa_search` matches on meaning; you want a written answer rather than a list to iterate — [`post_perplexity_sonar`](/docs/api-reference/perplexity/post_perplexity-sonar); you want peer-reviewed papers — [`post_scholar_search_scholar`](/docs/api-reference/scholar/post_scholar-search-scholar). # AIsa Capabilities by Goal Source: https://aisa.one/docs/by-goal Choose AIsa models, Skills, and APIs based on the outcome an agent needs to produce. Use this page when the task is clear but the correct AIsa product surface is not. Start with the desired outcome, then follow the smallest relevant path. ## Research and knowledge Use AIsa for evidence gathering, current-event research, academic search, competitor research, or multi-source synthesis. * [Multi-source Search Skill](/docs/agent-skills/search): combine web, scholar, Perplexity, and Tavily sources. * [Last 30 Days](/docs/agent-skills/last30days): produce a recent-signal brief across web, social, markets, and communities. * [Scholar Search](/docs/agent-skills/scholar-search): find academic papers and scholarly sources. * [Search API reference](/docs/api-reference/search/get_youtube-search): compose individual search endpoints yourself. * [Research agent use case](/docs/use-cases/research-agent): choose a retrieval and evidence workflow. ## Markets and finance Use AIsa for company research, market data, filings, financial metrics, prediction markets, portfolio analysis, or cross-source trend work. * [MarketPulse](/docs/agent-skills/marketpulse): retrieve equity data, financials, filings, analyst estimates, and macro context. * [Trend Forecast](/docs/agent-skills/trend-forecast): combine markets, news, social signals, and LLM synthesis. * [Prediction Market Data](/docs/agent-skills/prediction-market-data): inspect Polymarket and Kalshi data. * [Financial API reference](/docs/api-reference/financial/get_prices): compose company and market endpoints directly. * [Market intelligence use case](/docs/use-cases/market-intelligence-agent): design a broader market-research agent. ## Go-to-market and enrichment Use AIsa when an agent needs company discovery, people data, contact enrichment, creator discovery, or sales-research inputs. * [API Reference](/docs/api-reference): browse direct company, people, Apollo, WaveInflu, and enrichment APIs. * [SEO Keyword Research](/docs/agent-skills/seo-keyword-research): build a keyword and competitor strategy. * [Sales research use case](/docs/use-cases/sales-research-agent): plan a read-first company and contact research workflow. ## Social and media Use AIsa for X/Twitter intelligence, YouTube research, creator discovery, publishing workflows, or media generation. * [Twitter Autopilot](/docs/agent-skills/twitter-autopilot): combine X/Twitter research and approved actions. * [AIsa YouTube Search](/docs/agent-skills/aisa-youtube-search): search videos, channels, and playlists. * [Media Gen](/docs/agent-skills/mediagen): generate images or video through supported model routes. * [Twitter API reference](/docs/api-reference/twitter/get_twitter-user-info): control individual read and write endpoints. * [Social intelligence agent](/docs/use-cases/social-intelligence-agent): design source-bounded social and media research with separate action controls. ## Models and generation Use model inference when the primary need is reasoning, generation, coding, translation, vision, or multimodal processing. * [Model catalog](/docs/guides/models): inspect model IDs, endpoints, capabilities, and live-catalog guidance. * [Chat Completions API](/docs/api-reference/chat/post_chat-completions): use the OpenAI-compatible interface. * [What is an LLM gateway?](/docs/guides/learn/what-is-an-llm-gateway): understand model routing and unified billing. ## Autonomous operations and payments Use authenticated actions only when an agent must change an external system. Use programmatic payment capabilities only after checking budget, authorization, and settlement requirements. * [Capabilities by interface](/docs/by-interface): compare Skills, direct APIs, models, actions, MCP, A2A, and payments. * [AIsa Wallet and Payments](/docs/guides/pricing/wallet): understand account funding and usage deductions. * [Machine payments for agents](/docs/concepts/machine-payments-for-agents): decide when programmatic payment is appropriate. * [Security](/docs/guides/security): review data handling and credential requirements. * [Autonomous API purchasing](/docs/use-cases/autonomous-api-purchasing): separate capability selection, authorization, settlement, delivery, and audit. ## Selection rule Prefer the smallest product surface that completes the task: 1. Model inference for reasoning or generation. 2. A Skill for a complete reusable outcome. 3. Direct APIs for custom orchestration. 4. Authenticated actions only when side effects are required. 5. Programmatic payments only with explicit budget and settlement controls. For an overall product-fit decision, continue to [When to use AIsa](/docs/evaluate/when-to-use-aisa). # AIsa Capabilities by Interface Source: https://aisa.one/docs/by-interface Choose between AI model inference, Agent Skills, direct APIs, authenticated actions, MCP, A2A discovery, and programmatic payments. Choose an interface based on how much orchestration, control, and external side-effect handling the application requires. ## AI model inference Use model inference when the main task is language, reasoning, coding, vision, image generation, or another supported model capability. * Base URL: `https://api.aisa.one/v1` * Start with [Models](/docs/guides/models) and the [Chat Completions API](/docs/api-reference/chat/post_chat-completions). * Use exact model IDs from the live catalog or model guide. Model inference alone is usually enough when the workflow does not need external data or tools. ## Agent Skills Use an Agent Skill when the user requests a complete, task-oriented outcome. A Skill can encode tool selection, workflow steps, safety notes, and output structure. * Start with [Agent Skills](/docs/agent-skills) and the [Skills Quickstart](/docs/agent-skills/quickstart). * Prefer an existing Skill when it already covers the task. * Create a custom Skill when the workflow depends on internal systems or organization-specific rules. See [Pre-built versus custom Skills](/docs/guides/learn/agent-skills-vs-tools) for the decision process. For a direct comparison of reusable workflows and application-owned orchestration, see [Agent Skills vs. Direct APIs](/docs/concepts/agent-skills-vs-direct-apis). ## Direct APIs Use direct APIs when the application should select endpoints, sequence calls, and control retries or data processing itself. * Base URL: `https://api.aisa.one/apis/v1` * Start with the [API Reference](/docs/api-reference). * Load only the endpoint pages needed for the task. Direct APIs provide more control than Skills but require more orchestration code. ## Authenticated actions Use authenticated actions when an agent must send, publish, create, update, or delete information in an external system. Before execution: 1. Verify the required OAuth connection or delegated credential. 2. Separate read operations from write operations. 3. Show the intended side effect to the user when confirmation is required. 4. Use the narrowest available permission and endpoint. Do not infer permission to perform a write action from permission to read data. ## MCP Use MCP from compatible agent clients that need standardized tool discovery and invocation. * Inspect the [MCP catalogue](https://mcp.aisa.one/servers) — the live list of entry points, modules and servers. * Check each server entry's `status` before connecting. * A planned MCP server does not mean the corresponding HTTP API is unavailable; inspect the documented API surface separately. ## A2A discovery Use the [Agent Card](https://aisa.one/.well-known/agent-card.json) to discover high-level capabilities, authentication metadata, tags, and example tasks. Use [Agent Discovery](/docs/guides/agent-discovery) for the discovery-to-invocation flow. Fetch the OpenAPI specification when exact request and response schemas are needed. ## Programmatic payments Use programmatic payment capabilities when an agent needs to pay for supported APIs or services at runtime. Before enabling an autonomous payment flow, define: * The maximum amount per request and per task. * The funding source and settlement method. * Whether user confirmation is required. * How retries, duplicate charges, and failed responses are handled. * What audit record is retained. See [AIsa Wallet and Payments](/docs/guides/pricing/wallet) and [Machine payments for agents](/docs/concepts/machine-payments-for-agents). For a full selection-to-settlement workflow, see [Autonomous API purchasing](/docs/use-cases/autonomous-api-purchasing). ## Quick choice | Requirement | Preferred interface | | ------------------------------------------ | -------------------- | | Reasoning or generation only | AI model inference | | Reusable end-to-end task | Agent Skill | | Custom endpoint orchestration | Direct APIs | | External write or publish operation | Authenticated action | | Standardized client tool discovery | MCP | | High-level machine capability discovery | A2A Agent Card | | Runtime purchase of a supported capability | Programmatic payment | If the task is described as an outcome rather than an interface, start with [Capabilities by Goal](/docs/by-goal). # What Is an Agent Capability Layer? Source: https://aisa.one/docs/concepts/agent-capability-layer Understand how an agent capability layer combines model inference, data APIs, reusable Skills, authenticated actions, and payment controls. An **agent capability layer** gives an AI agent access to external capabilities through a common integration surface. It sits between the agent runtime and the model providers, data services, tools, and external systems the agent may need. A model gateway is one part of this layer. It handles model inference. A broader capability layer also helps agents retrieve current information, execute structured workflows, discover tools, and use controlled side effects or payment flows. ## The problem it solves Without a shared capability layer, an application may need to maintain separate integrations for: * Model providers and model-specific request formats. * Search, financial, social, company, and media data. * Authentication and API keys for each provider. * Retry, billing, and usage behavior across services. * Reusable task instructions for agent runtimes. * OAuth-connected actions and other side effects. This fragmentation increases integration and operational work. It can also make it harder for an agent to discover which capability is appropriate for the current task. ## The AIsa capability surfaces AIsa exposes several surfaces for different levels of control: | Surface | Use it for | | ----------------------------------------------- | ---------------------------------------------------------------- | | [AI model inference](/docs/guides/models) | Reasoning, generation, coding, vision, and supported media tasks | | [Agent Skills](/docs/agent-skills) | Reusable task-oriented workflows and instructions | | [Direct APIs](/docs/api-reference) | Application-controlled endpoint composition | | Authenticated actions | Approved writes to connected external systems | | [Agent discovery](/docs/guides/agent-discovery) | A2A, MCP, OpenAPI, and machine-readable capability inspection | | [Payments](/docs/guides/pricing/wallet) | Funding usage and controlling billable API consumption | These surfaces are complementary. A workflow may use a model to plan, a Skill to select a process, direct APIs to collect evidence, and an authenticated action to publish an approved result. ## Capability layer versus workflow platform A capability layer supplies access and reusable integration primitives. It does not automatically define every business process, approval rule, or application state transition. Your application or agent runtime still owns decisions such as: * Which task should run. * Which data is sufficient evidence. * Which writes require confirmation. * How budgets and retries are enforced. * What application state is retained. Use AIsa to reduce provider integration work, not to replace application-specific policy. ## When this architecture is useful Consider a capability layer when an agent needs more than one of the following: * Multiple model families through a common interface. * Current external data from several domains. * Reusable Skills shared across agent clients. * Machine-readable discovery through A2A, MCP, or OpenAPI. * Controlled external actions or programmatic API purchasing. A direct provider integration may be simpler when the application needs only one stable model or one specialized API. ## Next steps * [When to use AIsa](/docs/evaluate/when-to-use-aisa) * [Model gateway versus capability layer](/docs/concepts/model-gateway-vs-capability-layer) * [Capabilities by goal](/docs/by-goal) * [Capabilities by interface](/docs/by-interface) # Agent Skills vs. Direct APIs Source: https://aisa.one/docs/concepts/agent-skills-vs-direct-apis Decide whether an agent should follow a reusable AIsa Skill or call individual APIs with application-controlled orchestration. An **Agent Skill** packages task-oriented instructions, tool selection, workflow steps, safety notes, and output guidance. A **direct API integration** gives the application explicit control over endpoints, parameters, sequencing, retries, and state. Both can use the same underlying AIsa capabilities. The choice is primarily about who owns orchestration and how reusable the workflow should be. ## Side-by-side comparison | Requirement | Agent Skill | Direct API | | -------------------------- | ----------------------------------------------------- | ---------------------------------------------------------- | | Primary unit | Complete task or workflow | Individual endpoint operation | | Orchestration | Encoded in reusable instructions and supporting files | Implemented by the application | | Parameter control | Guided by the Skill | Fully application-controlled | | Reuse across agent clients | High when the client supports the Skill format | Requires shared application code or SDK wrappers | | Inspection | Review the Skill instructions and referenced tools | Review source code, API calls, and schemas | | Custom business state | Usually supplied by the runtime or application | Fully controlled by the application | | Maintenance | Update the Skill when the workflow changes | Update integration code when contracts or logic change | | Best fit | Repeatable outcome with a known process | Product-specific orchestration or precise endpoint control | A Skill is not automatically a hosted service or an opaque agent. It is a portable instruction bundle that teaches a compatible runtime how to perform a task with documented capabilities. ## Use an Agent Skill when Prefer a Skill when: * The user asks for an outcome rather than a specific endpoint. * The workflow is repeated across projects or agent clients. * Tool selection and sequencing should follow a consistent method. * Evidence rules, safety checks, and output structure should travel with the workflow. * An existing Skill already covers the task and can be reviewed before use. Start with the [Agent Skills catalog](/docs/agent-skills) and [Skills Quickstart](/docs/agent-skills/quickstart). ## Use direct APIs when Prefer direct APIs when: * The application must choose exact endpoints and parameters. * Request timing, caching, pagination, retries, or fallback behavior is product-specific. * Data must be normalized into an internal schema. * The workflow depends on proprietary business rules or internal state. * Every external call must be represented explicitly in application code and observability. Start with the [API Reference](/docs/api-reference) and load only the endpoint pages required for the task. ## Combine them when appropriate The two approaches are complementary. A Skill can define the process while direct APIs provide the individual operations. For example, a research Skill may instruct the agent to: 1. Clarify the research question. 2. Call specific search or data APIs. 3. Preserve source URLs and retrieval times. 4. Use a model for synthesis. 5. Label unsupported claims and missing evidence. The Skill owns the reusable method. The APIs still define the exact requests and responses. ## Read, write, and payment boundaries Neither interface removes the need to classify operations: * **Read:** retrieve information without changing an external system. * **Write:** create, send, publish, update, delete, follow, or otherwise change external state. * **Payment:** incur a billable runtime purchase or initiate a financial transaction. A Skill that references a write or payment operation does not grant permission to execute it. Before side effects: 1. Verify the connected identity and authorization. 2. Display the target and intended effect when confirmation is required. 3. Apply the narrowest permission and operation. 4. Avoid unbounded or ambiguous retries. 5. Verify the external result and usage record. ## Decision checklist Choose the interface by asking: * Is the task a reusable outcome or a product-specific integration? * Who should own endpoint sequencing and task state? * Does the application need exact parameter and retry control? * Will multiple agent clients reuse the same instructions? * Are any operations writes or payments? * How will the workflow be tested, reviewed, and updated? If the task is described by its desired outcome, start with [Capabilities by Goal](/docs/by-goal). If the interface is already known, continue with [Capabilities by Interface](/docs/by-interface). ## Related guidance * [One API for Models, Data, and Agent Tools](/docs/concepts/unified-model-data-tools-api) * [Pre-built Skills vs. Custom Skills](/docs/guides/learn/agent-skills-vs-tools) * [AIsa Architecture and Integration Boundaries](/docs/evaluate/architecture) * [Security Evaluation Guide](/docs/evaluate/security) # Machine Payments for AI Agents Source: https://aisa.one/docs/concepts/machine-payments-for-agents Decide when an AI agent should purchase API capabilities programmatically and which budget, confirmation, and audit controls are required. A machine-payment flow allows software to pay for a supported capability at runtime. For an AI agent, this can reduce the need to maintain a separate subscription or provider account for every API it may use. Payment automation should not be treated as unlimited spending authority. It is an execution capability with financial side effects and should be governed like any other privileged action. ## When programmatic payment is useful Consider it when: * An agent needs occasional access to a paid API that is not worth a dedicated subscription. * Usage varies by task and per-call billing is easier to control than separate provider accounts. * The application needs a common wallet or usage balance across supported capabilities. * The task can define a clear maximum spend before execution. A prepaid account or normal API key may be simpler when usage is predictable and the application does not need runtime purchasing decisions. ## Controls to define first Before enabling an autonomous payment path, define: | Control | Question | | ------------------- | ------------------------------------------------------------------ | | Per-request limit | What is the maximum amount for one call? | | Per-task limit | How much may the complete workflow spend? | | Time-based limit | What daily or monthly ceiling applies? | | Confirmation policy | Which amounts or capability types require user approval? | | Retry policy | Can a failed request be retried without a duplicate charge? | | Audit record | Which request, amount, capability, and result fields are retained? | | Failure behavior | What happens when payment settles but the upstream result fails? | ## Separate selection from authorization An agent may determine that a paid API is useful without being authorized to buy it. Keep these decisions separate: 1. **Capability selection:** identify the API or service that could complete the task. 2. **Cost estimation:** determine the expected amount and uncertainty. 3. **Authorization:** compare the cost with policy and request confirmation if needed. 4. **Execution:** submit the paid request once. 5. **Verification:** confirm both settlement and the API result. 6. **Audit:** record the decision and outcome without exposing secrets. ## AIsa billing context AIsa uses usage-based billing for model and API consumption. The [Wallet and Payments](/docs/guides/pricing/wallet) guide explains account funding, supported top-up methods, balance deductions, and usage logs. The existence of a wallet does not imply that every AIsa capability is available through an autonomous payment protocol. Check the specific API documentation and authentication requirements before designing the flow. ## Safety rules for agents * Never infer spending permission from possession of an API key or wallet connection. * Do not expose wallet credentials, API keys, signatures, or authorization tokens. * Avoid open-ended retry loops for billable calls. * Prefer a read-only preview or quote before a paid side effect when available. * Verify the final response instead of treating successful settlement as successful task completion. ## Related guidance * [Capabilities by Interface](/docs/by-interface) * [Pricing and Billing](/docs/guides/pricing) * [AIsa Wallet and Payments](/docs/guides/pricing/wallet) * [Authentication](/docs/guides/authentication) * [Security](/docs/guides/security) # Model Gateway vs. Agent Capability Layer Source: https://aisa.one/docs/concepts/model-gateway-vs-capability-layer Compare a model-only gateway with a broader agent capability layer and decide which architecture fits a workflow. A **model gateway** standardizes access to AI models. An **agent capability layer** includes model access but also exposes data, tools, reusable workflows, discovery metadata, and controlled action or payment surfaces. The distinction matters because many agents need current evidence and external operations in addition to language generation. ## Side-by-side comparison | Requirement | Model gateway | Agent capability layer | | -------------------------------------------- | ------------------------- | ------------------------------------------------- | | Unified model API | Core function | Included | | Model routing and common billing | Common | Included for model use | | Live search, market, social, or company data | Usually separate | Available through direct APIs or Skills | | Reusable task workflows | Application-owned | Can be packaged as Agent Skills | | Machine-readable capability discovery | May expose model metadata | Can expose Agent Card, MCP, and OpenAPI resources | | Authenticated external writes | Usually outside scope | Can be represented as controlled action surfaces | | Programmatic API purchasing | Usually outside scope | Can be paired with payment and budget controls | ## Choose a model gateway when A model gateway is usually sufficient when: * The application primarily generates or analyzes content. * External facts are already supplied by the application. * The team has separate tool and data integrations. * The workflow does not need reusable cross-tool Skills. Start with [AIsa Models](/docs/guides/models) if this describes the requirement. You can use the model gateway without adopting every other AIsa surface. ## Choose a broader capability layer when A broader layer is useful when: * The agent must retrieve current information before answering. * Several data providers would otherwise require separate integrations. * Multiple agent clients should share the same task instructions. * The agent needs machine-readable discovery of available capabilities. * The workflow may include controlled writes or billable runtime purchases. Start with [Capabilities by Goal](/docs/by-goal) or [Capabilities by Interface](/docs/by-interface). ## They are not mutually exclusive The model gateway is a capability inside the broader layer. An application can begin with model inference and add APIs or Skills only when a real workflow needs them. This incremental approach avoids unnecessary orchestration: 1. Use a model for reasoning or generation. 2. Add a direct API when current external data is required. 3. Package repeated orchestration as a Skill. 4. Add authenticated actions only when side effects are necessary. 5. Add programmatic payment controls only for runtime purchasing requirements. ## Evaluation questions Before choosing an architecture, ask: * Does the application need one model provider, several models, or models plus external data? * Who should own endpoint sequencing: the application or a reusable Skill? * Are any operations writes rather than reads? * Does the agent need to discover capabilities dynamically? * What budget, retry, and audit rules apply? For a full product-fit checklist, see [When to use AIsa](/docs/evaluate/when-to-use-aisa). # One API for Models, Data, and Agent Tools Source: https://aisa.one/docs/concepts/unified-model-data-tools-api Understand what AIsa unifies across models, live data, Agent Skills, actions, discovery, and billing—and what remains capability-specific. AIsa gives AI agents a common resource and transaction boundary for supported models, APIs, data services, Agent Skills, and paid capabilities. This reduces the number of separate provider accounts, credentials, discovery formats, and billing relationships an application must manage. “Unified” does **not** mean every capability uses one identical endpoint, request schema, price unit, or authorization method. It means an agent can begin from one product and account boundary, discover the appropriate surface, and then use the exact contract for that capability. ## What AIsa unifies For supported capabilities, AIsa can provide a shared starting point for: * **Product discovery:** identify whether the task needs a model, Skill, direct API, authenticated action, or payment flow. * **Account access:** use an AIsa account and API credential for documented model and API surfaces. * **Machine discovery:** inspect the Agent Card, MCP manifest, OpenAPI specification, and llms resources. * **Usage visibility:** review billable model and API consumption through AIsa usage and billing surfaces. * **Technical routing:** move from a task goal to the smallest relevant documentation and API contract. Authenticated actions may also require a provider-specific OAuth connection or delegated credential. Possession of an AIsa API key does not by itself authorize an external write. ## What remains capability-specific Each resource can still have its own operational contract: | Concern | Why it can differ | | ---------------------------- | --------------------------------------------------------------------------------------------- | | Endpoint and request schema | Model inference, search, financial data, and social APIs accept different inputs | | Response semantics | Generated text, source records, market data, and action receipts require different validation | | Billing unit | Usage may be measured by tokens, requests, media outputs, or another documented unit | | Availability and rate limits | Capabilities can depend on different upstream providers and quotas | | Additional authorization | Writes may require OAuth, account connection, or explicit user confirmation | | Retry behavior | A read can often be retried differently from a write or paid request | Use the [OpenAPI specification](https://aisa.one/openapi.yaml) and exact documentation page as the implementation source of truth. ## Resource types | Resource | Use it when | Start with | | ---------------------------- | --------------------------------------------------------------------------- | ---------------------------------------------------------------------------- | | AI model inference | The task is reasoning, generation, coding, vision, or media processing | [Models](/docs/guides/models) | | Live data or specialized API | The workflow needs current, structured, provider-backed information | [API Reference](/docs/api-reference) | | Agent Skill | The outcome is reusable and benefits from an established workflow | [Agent Skills](/docs/agent-skills) | | Authenticated action | The agent must change an external system | [Capabilities by Interface](/docs/by-interface#authenticated-actions) | | Machine discovery | A client must inspect capabilities and contracts programmatically | [Agent Discovery](/docs/guides/agent-discovery) | | Programmatic payment | A supported capability must be purchased at runtime under explicit controls | [Machine Payments for AI Agents](/docs/concepts/machine-payments-for-agents) | ## Example: research followed by an approved action A single task can cross several surfaces without treating them as interchangeable: 1. Use [Capabilities by Goal](/docs/by-goal) to select a research path. 2. Call a search or data API to retrieve current evidence. 3. Use a model to compare and synthesize the evidence. 4. If the result should be published or sent, classify that step as an authenticated write. 5. Verify the connected identity and request confirmation where required. 6. Inspect usage and the external result separately. The common boundary reduces integration fragmentation. The application still owns task state, evidence requirements, authorization policy, retry logic, and result verification. ## When one interface is useful Consider this architecture when: * An agent needs models plus current external data. * A product would otherwise maintain several provider integrations. * Multiple agent clients should reuse the same Skills or discovery resources. * The workflow needs shared usage visibility across different capability types. * New resources should be added incrementally without redesigning the whole agent. ## When direct integrations may be simpler A direct provider integration can be the better choice when: * One stable model or API solves the complete task. * The team needs a provider-specific feature not exposed through AIsa. * Existing reliability, compliance, procurement, and billing processes already cover the provider. * An additional routing or billing dependency is not desirable. AIsa is not an all-or-nothing architecture. Start with the smallest useful surface and add other resource types only when the workflow needs them. ## Next steps * [Agent Skills vs. Direct APIs](/docs/concepts/agent-skills-vs-direct-apis) * [Model Gateway vs. Agent Capability Layer](/docs/concepts/model-gateway-vs-capability-layer) * [AIsa Architecture and Integration Boundaries](/docs/evaluate/architecture) * [When to Use AIsa](/docs/evaluate/when-to-use-aisa) * [Capabilities by Interface](/docs/by-interface) # AIsa Architecture and Integration Boundaries Source: https://aisa.one/docs/evaluate/architecture Understand where AIsa sits between an agent application and upstream models, APIs, Skills, actions, and billing systems. AIsa sits between an agent application and supported upstream capabilities. The application sends an authenticated request to an AIsa endpoint; AIsa routes the request to the relevant model or API integration and returns the result. ## High-level request path ```text theme={null} Agent or application -> AIsa model or API endpoint -> selected upstream capability -> AIsa response and usage record -> application verification and state handling ``` Agent Skills and machine-discovery resources help the agent choose and understand capabilities, but they do not replace the runtime request path. ## Endpoint families | Surface | Base URL | Responsibility | | --------------------------- | ------------------------------ | ------------------------------------------------------------------- | | Model inference | `https://api.aisa.one/v1` | Model requests and compatible inference routes | | Data and capability APIs | `https://api.aisa.one/apis/v1` | Search, financial, social, company, media, and other supported APIs | | Documentation and discovery | `https://aisa.one` | Human and machine-readable capability metadata | Use the [Agent Quickstart](/docs/agent-quickstart) for the smallest integration path. ## What AIsa handles Depending on the selected surface, AIsa may handle: * Common authentication at the AIsa boundary. * Routing to a supported model or API provider. * Normalized or documented endpoint contracts. * Usage accounting and billing. * Machine-readable capability metadata. * Reusable Skill instructions for agent runtimes. ## What the application still owns The application remains responsible for: * User intent and authorization. * Business logic and task state. * Evidence standards and result verification. * Secret storage in the client environment. * Retry and idempotency policy appropriate to the operation. * Confirmation for external writes and payments. * Long-term storage of application data. * Fallback behavior if a capability is unavailable. A common gateway does not remove the need for application-specific policy. ## Read, write, and payment boundaries Classify each operation before execution: 1. **Read:** retrieves data without changing an external system. 2. **Write:** creates, updates, sends, publishes, or deletes external data. 3. **Payment:** moves value or authorizes a billable runtime purchase. A credential that permits one class should not be assumed to permit another. Apply narrower confirmation and retry policies to writes and payments. ## Data and provider boundaries AIsa integrates with upstream providers. Requests needed to fulfill an operation may be sent to the selected provider. Review [Security](/docs/guides/security) and any relevant upstream terms for the workload. For current models and API contracts, use live or generated sources rather than architecture prose: * [Models](/docs/guides/models) * [API Reference](/docs/api-reference) * [OpenAPI specification](https://aisa.one/openapi.yaml) ## Deployment considerations For production use, define: * Health and timeout expectations. * Retry behavior for reads versus writes. * Budget and balance monitoring. * Provider or route fallback policy. * Logging that excludes secrets and sensitive request content. * A verification step before reporting success. For an overall fit assessment, see [When to use AIsa](/docs/evaluate/when-to-use-aisa). # Pricing Evaluation Guide Source: https://aisa.one/docs/evaluate/pricing Evaluate AIsa model, API, wallet, and usage-based billing without relying on stale static price claims. AIsa uses usage-based billing across model inference and billable API capabilities. Exact prices depend on the selected model, route, or endpoint and can change independently of this evaluation page. Use current pricing sources for final decisions. ## Sources of truth * [AI Model Pricing](/docs/guides/pricing/ai-model-pricing-llm-inference) for model-pricing guidance. * [Per-call API Pricing](/docs/guides/pricing/per-call-api-pricing) for API billing guidance. * [Wallet and Payments](/docs/guides/pricing/wallet) for funding and balance behavior. * [Usage Logs](/docs/guides/dashboard/usage-logs) for observed account usage. * The live model catalog or exact API page for current capability context. Do not copy a price from a comparison or conceptual article into production logic. ## Estimate the complete workflow A multi-step agent may incur more than one charge. Estimate: 1. Retrieval or API calls. 2. Model input and output tokens. 3. Retries or fallback routes. 4. Enrichment calls for shortlisted records. 5. Media generation or other per-request capabilities. The cheapest individual endpoint may not produce the lowest complete-task cost if it requires more retries, tokens, or follow-up calls. ## Budget controls Define: * Maximum cost per API call. * Maximum cost per task. * Daily or monthly workspace limits. * Whether the agent may select a more expensive fallback. * Which amount requires confirmation. * What happens when the balance is insufficient. For runtime purchasing, also see [Machine payments for agents](/docs/concepts/machine-payments-for-agents). ## Compare alternatives fairly When comparing AIsa with direct providers or another gateway, include: * Model or endpoint price. * Engineering work for additional providers. * Billing and credential management. * Required data APIs or tools. * Reliability and fallback requirements. * Observability and audit needs. A direct provider can be the simpler option for a stable, single-provider workload. A shared capability layer may be more useful when the workflow combines several providers or capability types. ## Verify before production * Confirm the exact model ID or endpoint. * Check current price units. * Run a small representative request. * Inspect the usage record. * Measure the complete workflow, not only one call. * Add budget alerts before scaling traffic. For the broader product decision, see [When to use AIsa](/docs/evaluate/when-to-use-aisa). # Security Evaluation Guide Source: https://aisa.one/docs/evaluate/security Evaluate AIsa authentication, data handling, upstream-provider boundaries, actions, payments, and production controls. Use this page as an evaluation checklist. The detailed security policy is maintained in [Security and Data Privacy](/docs/guides/security), and API-key guidance is maintained in [Authentication](/docs/guides/authentication). ## Authentication AIsa API requests use Bearer-token authentication unless the exact capability documentation states otherwise. Evaluate: * How keys are created, scoped, stored, and rotated. * Whether development and production use separate credentials. * Whether logs, errors, and analytics exclude credentials. * Which people or services can access the key. Do not embed keys in client-side applications, public repositories, documentation examples, or agent prompts. ## Request and response data Review [Security and Data Privacy](/docs/guides/security) for AIsa's documented processing and retention model. Also consider the selected upstream provider, because provider-specific terms may apply to data required to fulfill the request. For sensitive workloads, identify: * The data fields sent to AIsa and upstream providers. * Whether the task can minimize or redact those fields. * Applicable regulatory or contractual restrictions. * Whether the result may contain sensitive data. ## External actions Writes require stricter controls than reads. Before an action that sends, publishes, creates, updates, or deletes external data: 1. Verify the connected identity and permission. 2. Display the intended target and side effect. 3. Obtain confirmation where required. 4. Avoid unbounded retries. 5. Verify the external result. Read access must not be treated as authorization to write. ## Payments and billable calls For programmatic payment or billable agent workflows, define spend limits, confirmation thresholds, duplicate-charge handling, and audit records. See: * [Pricing and Billing](/docs/guides/pricing) * [Wallet and Payments](/docs/guides/pricing/wallet) * [Machine payments for agents](/docs/concepts/machine-payments-for-agents) ## Operational controls Production integrations should define: * Request timeouts and rate-limit handling. * Separate retry policies for idempotent reads and side-effecting operations. * Budget or balance alerts. * Sanitized error reporting. * Dependency health checks and fallback behavior. * Verification before reporting that an operation succeeded. ## Security questions for procurement or review * Which exact capability and upstream provider will process the request? * What data is sent, stored, or logged? * Which credentials and permissions are required? * Does the operation create an external side effect? * How are spend and retries bounded? * What evidence verifies the final result? Use the exact API or Skill page to answer capability-specific questions. Do not rely on a general platform description for endpoint-level security assumptions. # Supported AIsa Capabilities Source: https://aisa.one/docs/evaluate/supported-capabilities Evaluate the main AIsa capability surfaces and find the live source of truth for models, APIs, Skills, actions, discovery, and billing. AIsa supports multiple capability surfaces. Availability is not represented by one static count: model routes, API providers, Skills, MCP descriptors, and authenticated actions have different release and status mechanisms. Use this page to identify the correct source of truth before building against a capability. ## AI model inference AIsa exposes model inference through `https://api.aisa.one/v1` with OpenAI-compatible and selected provider-compatible routes. Check: * [Live model catalog](https://aisa.one/models) for current availability. * [Models guide](/docs/guides/models) for IDs, capability vocabulary, and endpoint guidance. * [AI model pricing](/docs/guides/pricing/ai-model-pricing-llm-inference) for pricing guidance. Do not infer model availability or modality support from the provider family name alone. ## Direct data and capability APIs AIsa exposes non-chat APIs under `https://api.aisa.one/apis/v1`. The [API Reference](/docs/api-reference) is the technical entry point for exact methods, paths, parameters, authentication, and examples. Relevant domains include search, research, financial data, social platforms, prediction markets, media, company and people data, and other providers represented in the current reference. A page in the API reference documents a route; production use should still account for current health, pricing, rate limits, and provider-specific requirements. ## Agent Skills [Agent Skills](/docs/agent-skills) are reusable instruction bundles for supported agent runtimes. They may combine models, APIs, scripts, safety notes, and output guidance. Check: * The Skill page for its intended trigger and tools. * The Skill source repository for the current implementation. * Configuration requirements before execution. A Skill is not the same as an independently hosted service. It teaches an agent how to use the underlying capabilities. ## Authenticated actions Some APIs can create, update, send, publish, follow, or otherwise change an external system. These operations may require an OAuth-connected account or additional authorization. Treat them separately from read-only APIs: * Verify required permissions. * Identify the external side effect. * Obtain confirmation when required. * Verify the external result after execution. ## Machine-readable discovery AIsa publishes: * [Agent Card](https://aisa.one/.well-known/agent-card.json) for high-level A2A-style discovery. * [MCP catalogue](https://mcp.aisa.one/servers) for the live list of MCP entry points, modules and servers. * [OpenAPI specification](https://aisa.one/openapi.yaml) for request and response contracts. * [Technical llms.txt](https://aisa.one/docs/llms.txt) for documentation routing. Check status fields in discovery resources. A planned MCP descriptor should not be treated as a live MCP server. ## Billing and payments Model and API usage is usage-based. Review: * [Pricing and Billing](/docs/guides/pricing) * [Wallet and Payments](/docs/guides/pricing/wallet) * [Usage Logs](/docs/guides/dashboard/usage-logs) * [Machine payments for agents](/docs/concepts/machine-payments-for-agents) Do not assume every capability supports the same authentication or payment path. ## Verification checklist Before relying on a capability: 1. Confirm its live model, API, Skill, or discovery entry. 2. Read the exact authentication requirements. 3. Check pricing and rate limits. 4. Test the smallest safe request. 5. Verify response shape and failure behavior. 6. For writes or payments, verify authorization and side effects separately. For product-fit guidance, see [When to use AIsa](/docs/evaluate/when-to-use-aisa). # When to Use AIsa Source: https://aisa.one/docs/evaluate/when-to-use-aisa Evaluate whether AIsa fits a workflow that needs models, live data, Agent Skills, discovery, actions, or usage-based billing. AIsa is a good candidate when an agent needs more than one provider integration and the application benefits from a common model, data, Skill, discovery, or billing surface. ## Consider AIsa when * The agent needs model inference plus current external data. * The application would otherwise maintain several provider keys and API contracts. * A reusable Skill can replace repeated endpoint orchestration. * The agent needs to discover capabilities through Agent Card, MCP, or OpenAPI. * The workflow needs usage-based access to multiple supported capabilities. * The team wants to start with model inference and add data or Skills incrementally. ## AIsa may not be necessary when * One model provider fully covers the workload. * One specialized API already solves the complete problem. * The team intentionally owns every provider integration and billing relationship. * The workflow has no need for current external data, reusable Skills, or machine discovery. Using AIsa is not an all-or-nothing decision. A project can use the model gateway first and adopt other surfaces only when the workflow requires them. ## Fit checklist | Question | If yes | | --------------------------------------------------------- | ------------------------------------------------------------------------------------------ | | Do you need more than one model family? | Start with [Models](/docs/guides/models). | | Do you need current web, market, social, or company data? | Choose a [Skill or direct API](/docs/by-goal). | | Do you need an end-to-end reusable task? | Review [Agent Skills](/docs/agent-skills). | | Do you need custom endpoint sequencing? | Use the [API Reference](/docs/api-reference). | | Do you need external writes? | Review [Capabilities by Interface](/docs/by-interface) and authorization requirements. | | Do you need runtime purchasing? | Review [Machine payments](/docs/concepts/machine-payments-for-agents) and budget controls. | ## Evaluation sequence 1. Define the user outcome and required evidence. 2. Choose the smallest suitable interface. 3. Check current availability, pricing, authentication, and rate limits. 4. Test a read-only or low-risk request. 5. Decide which data, side effects, and costs the application will own. 6. Document fallback and failure behavior before production use. ## Main trade-offs A common capability layer can reduce integration duplication, but it also introduces a dependency on an additional routing and billing layer. Evaluate: * Latency and reliability for the required route. * Whether the live catalog supports the exact model or API needed. * Data handling and upstream-provider terms. * Cost visibility and budget controls. * Migration and fallback requirements. ## Start here * [Agent Quickstart](/docs/agent-quickstart) * [Capabilities by Goal](/docs/by-goal) * [Capabilities by Interface](/docs/by-interface) * [Security](/docs/guides/security) * [Pricing and Billing](/docs/guides/pricing) * [Service and capability discovery](/docs/guides/agent-discovery) # Welcome to AIsa Source: https://aisa.one/docs/guides The unified API gateway for AI agents - live LLM and media model routing, 100+ data APIs, and stablecoin payments through one endpoint. AIsa is the unified resource and payment layer for the AI economy. Route requests to the live catalog of GPT, Claude, Gemini, Grok, DeepSeek, Qwen, Kimi, MiniMax, GLM, Seed, Seedream, Wan, Hunyuan, and MiMo models, access real-time web, financial, and social data from 100+ APIs, and let autonomous agents pay for their own compute - all through one API key. Create an account, generate an API key, and make your first unified API call in minutes. Test any model in the browser - adjust parameters, inspect payloads, no code required. Configure OpenClaw with AIsa using the recommended quick setup path. Connect Hermes Agent to the AIsa model endpoint and capability layer. ## How it works Swap your `base_url` to AIsa and instantly access GPT, Claude, Gemini, Grok, DeepSeek, Qwen, Kimi, MiniMax, GLM, Seed, Seedream, Wan, Hunyuan, and MiMo models. Most models use OpenAI-compatible chat completions; selected models also expose Anthropic Messages, OpenAI Responses, Gemini GenerateContent, or image-generation routes. Access 100+ specialized APIs - Twitter, Perplexity, Tavily, YouTube, stock prices, prediction markets - without managing separate vendor accounts. Fund a single AIsa wallet with fiat or USDC. Every endpoint supports the x402 machine payment protocol, so agents can pay for compute and data on their own. ## Core pillars Live LLM and media model routing plus 100+ data APIs behind one gateway. One key, one bill, zero vendor lock-in. Composable, reusable agent capabilities for Claude Code, Cursor, OpenClaw, and more. Install with a single command. Pre-configured OpenClaw instances with LLMs and Skills built in. Deploy agents to Telegram, Discord, or Slack without managing infra. ## Supported models AIsa is API-compatible with the OpenAI ecosystem for chat-style model calls, with additional provider-compatible routes where useful. Switch models without changing billing or key management - optimize for cost, speed, reasoning, coding, vision, audio, image generation, or long context on a per-request basis. | Family | Developer | Modalities | | ---------------------------- | ----------- | ----------------------------------------- | | GPT | OpenAI | Text, Vision, Image, Coding | | Claude | Anthropic | Text, Vision, Coding | | Gemini | Google | Text | | Grok | xAI | Text, Vision, Coding | | DeepSeek | DeepSeek | Text, Coding | | Qwen and Wan | Alibaba | Text, Vision, Audio, Video, Image, Coding | | Kimi | Moonshot AI | Text, Vision, Video, Coding | | MiniMax | MiniMax | Text, Vision, Video, Coding | | GLM | Zhipu AI | Text, Coding | | Seed, Seedream, and Dreamina | ByteDance | Text, Vision, Video, Image, Coding | | Hunyuan | Tencent | Text | | MiMo | Xiaomi | Text | | HappyHorse | HappyHorse | Video | See the exact model IDs, context windows, endpoint mappings, capabilities, and billing notes in the [supported model catalog](/docs/guides/models), the [AI Model Pricing](/docs/guides/pricing/ai-model-pricing-llm-inference) docs, or the live [AIsa Marketplace](https://aisa.one/models). ## Next steps Make your first unified API call. Browse and install production-ready skills. Explore every endpoint with interactive examples. AIsa vs. OpenRouter, pricing, compatibility. # Agent Discovery – Let Autonomous Agents Find and Use AIsa Source: https://aisa.one/docs/guides/agent-discovery Integrate autonomous agents with AIsa using the A2A Agent Card, MCP manifest, OpenAI plugin manifest, OpenAPI 3.1 spec, and llms.txt resources. AIsa publishes several machine-readable discovery resources so that autonomous agents can find, understand, and invoke supported capabilities. This guide explains the main resources and the discovery-to-invocation flow. ## Discovery Endpoints AIsa exposes the following public URLs for agent and documentation discovery. They require no authentication to read. | Endpoint | Protocol | URL | Purpose | | :--------------------- | :----------------- | :--------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------- | | **Agent Card** | Google A2A | `https://aisa.one/.well-known/agent-card.json` | High-level capabilities with metadata, tags, examples, and I/O modes | | **AI Plugin** | OpenAI Plugin (v1) | `https://aisa.one/.well-known/ai-plugin.json` | Backward compatibility with ChatGPT-era agent tooling | | **MCP Catalogue** | Live MCP inventory | `https://mcp.aisa.one/servers` | Entry points (root `mcp.aisa.one/mcp`, domain aliases), modules and per-server endpoints, generated by the running service | | **OpenAPI Spec** | OpenAPI 3.1.0 | `https://aisa.one/openapi.yaml` | Machine-readable request and response contracts | | **Product llms.txt** | llms.txt | `https://aisa.one/llms.txt` | Product fit, goals, interfaces, and evaluation routes | | **Technical llms.txt** | llms.txt | `https://aisa.one/docs/llms.txt` | Technical documentation router | ## How Agent Discovery Works The discovery flow follows three steps: **discover**, **inspect**, and **invoke**. An autonomous agent starts by fetching the agent card to learn what AIsa can do, selects the relevant skill, and then calls the corresponding API endpoint using the OpenAPI spec for request/response schemas. The agent fetches `/.well-known/agent-card.json` from `aisa.one`. The response contains a list of skills, each with an `id`, `name`, `description`, `tags`, and `examples`. The agent uses this metadata to determine whether AIsa can fulfill the current task. Once the agent identifies a relevant skill, it fetches `/openapi.yaml` to retrieve the full request/response schema for the corresponding API endpoints. The OpenAPI spec provides parameter types, required fields, authentication requirements, and example payloads. The agent constructs an authenticated API request using the schema from the OpenAPI spec, sends it to `api.aisa.one`, and processes the response. All endpoints use Bearer token authentication with an AIsa API key. ## The A2A Agent Card The [Agent2Agent (A2A) Protocol](https://a2a-protocol.org/latest/) defines a standard format for agents to advertise capabilities and interoperate. AIsa's agent card lives at the well-known URL and describes the platform, authentication requirements, and public capability catalog. ### Fetching the Agent Card ```bash curl theme={null} curl -s https://aisa.one/.well-known/agent-card.json | jq . ``` ```python Python theme={null} import requests card = requests.get("https://aisa.one/.well-known/agent-card.json").json() print(f"Agent: {card['name']} — {card['description']}") print(f"Skills: {len(card['skills'])}") for skill in card["skills"]: print(f" • {skill['id']}: {skill['name']}") ``` ```typescript TypeScript theme={null} const res = await fetch("https://aisa.one/.well-known/agent-card.json"); const card = await res.json(); console.log(`Agent: ${card.name} — ${card.description}`); console.log(`Skills: ${card.skills.length}`); card.skills.forEach((s: any) => console.log(` • ${s.id}: ${s.name}`)); ``` ### Agent Card Structure The top-level fields describe the agent identity, authentication, and capabilities: | Field | Type | Description | | :----------------- | :----- | :----------------------------------------------------------- | | `name` | string | Agent name — `"AIsa"` | | `description` | string | One-line summary of the agent's purpose | | `url` | string | Base URL for API requests — `https://api.aisa.one` | | `provider` | object | Organization name and website | | `version` | string | Semantic version of the agent card | | `documentationUrl` | string | Link to human-readable documentation | | `capabilities` | object | Feature flags — streaming, push notifications, state history | | `authentication` | object | Supported auth schemes and credential instructions | ### Skill Objects Each entry in the `skills` array describes a single capability: | Field | Type | Description | | :------------ | :-------- | :---------------------------------------------------------------------- | | `id` | string | Unique skill identifier (e.g., `chat-completions`, `twitter-autopilot`) | | `name` | string | Human-readable skill name | | `description` | string | What the skill does and what data it provides | | `tags` | string\[] | Searchable tags for filtering and matching | | `examples` | string\[] | Natural-language example queries the skill can handle | | `inputModes` | string\[] | Accepted content types (defaults to `application/json`) | | `outputModes` | string\[] | Response content types (e.g., `application/json`, `text/event-stream`) | ### Available capabilities The Agent Card is generated from the public catalog. Fetch the live card instead of relying on a fixed capability list in documentation: ```bash theme={null} curl -s https://aisa.one/.well-known/agent-card.json \ | jq -r '.skills[] | [.id, .name, (.tags // [] | join(","))] | @tsv' ``` Use each capability's `description`, `tags`, and `examples` for matching. Confirm the underlying Skill or API documentation before invocation. ## The OpenAI Plugin Manifest For backward compatibility with agent frameworks that implement the original ChatGPT plugin protocol, AIsa also publishes an `ai-plugin.json` manifest at `/.well-known/ai-plugin.json`. The manifest references the same OpenAPI spec. For current OpenAI tool integration guidance, see [Actions](https://platform.openai.com/docs/actions). ```bash theme={null} curl -s https://aisa.one/.well-known/ai-plugin.json | jq . ``` The manifest includes a `description_for_model` field that lists key API endpoints, helping LLM-based agents understand which tools are available without parsing the full OpenAPI spec. ## The OpenAPI 3.1 Specification The consolidated OpenAPI spec at `/openapi.yaml` is the authoritative machine-readable contract for constructing API requests. Parse the live specification instead of relying on a fixed path or schema count. ### Fetching and Parsing the Spec ```python Python theme={null} import yaml, requests spec = yaml.safe_load(requests.get("https://aisa.one/openapi.yaml").text) paths = list(spec["paths"].keys()) print(f"Total endpoints: {len(paths)}") print(f"First 5: {paths[:5]}") ``` ```typescript TypeScript theme={null} import YAML from "yaml"; const res = await fetch("https://aisa.one/openapi.yaml"); const spec = YAML.parse(await res.text()); const paths = Object.keys(spec.paths); console.log(`Total endpoints: ${paths.length}`); ``` ```bash curl theme={null} curl -s https://aisa.one/openapi.yaml | head -50 ``` ### API Categories The spec organizes endpoints into the following tag groups: | Category | Example Endpoints | Description | | :----------------- | :------------------------------------------------------------ | :-------------------------------------------------------------- | | AI Models | `/v1/chat/completions`, `/v1/models` | Live LLM and media model catalog, OpenAI-compatible chat routes | | Twitter/X | `/apis/v1/twitter/tweet/advanced_search` | Profile, timeline, search, posting | | Financial Data | `/apis/v1/financial/prices`, `/apis/v1/financial/sec-filings` | Equities, SEC, earnings, screening | | Web & News Search | `/apis/v1/tavily/search`, `/apis/v1/search/smart` | Multi-source and Tavily search | | Prediction Markets | `/apis/v1/polymarket/events`, `/apis/v1/kalshi/markets` | Polymarket and Kalshi data | | Crypto Data | `/apis/v1/coingecko/simple/price` | CoinGecko market data | | Image Generation | `/v1/images/generations` | GPT, Seedream, Wan, and other image-capable routes | | YouTube Search | `/apis/v1/youtube/search` | YouTube SERP | | Scholar Search | `/apis/v1/scholar/search/scholar` | Academic paper search | ## End-to-End Integration Example The following Python example demonstrates the complete discovery-to-invocation flow. An autonomous agent discovers AIsa's capabilities, identifies the `chat-completions` skill, and makes an authenticated API call. ```python theme={null} import requests # Step 1: Discover — fetch the agent card card = requests.get("https://aisa.one/.well-known/agent-card.json").json() # Step 2: Find a skill by tag target_tag = "llm" matching = [s for s in card["skills"] if target_tag in s.get("tags", [])] if not matching: raise RuntimeError(f"No skill found with tag '{target_tag}'") skill = matching[0] print(f"Selected skill: {skill['name']} ({skill['id']})") # Step 3: Invoke — call the API using the base URL from the card response = requests.post( f"{card['url']}/v1/chat/completions", headers={ "Authorization": "Bearer YOUR_AISA_API_KEY", "Content-Type": "application/json", }, json={ "model": "gpt-5.4-mini", "messages": [ {"role": "user", "content": "Summarize the A2A protocol in two sentences."} ], }, ) result = response.json() print(result["choices"][0]["message"]["content"]) ``` ## Authentication All AIsa API endpoints require Bearer token authentication. Include your API key in the `Authorization` header of every request: ``` Authorization: Bearer YOUR_AISA_API_KEY ``` Generate an API key from the AIsa console. For detailed key management guidance — scoping, rotation, and secure storage — see the [Authentication](/docs/guides/authentication) guide. The discovery resources (`agent-card.json`, `mcp.json`, `ai-plugin.json`, `openapi.yaml`, and llms.txt files) are publicly readable and require no authentication. API calls to `api.aisa.one` require the authentication documented for the selected route. ## Integration Patterns ### Pattern 1: Tag-Based Skill Matching Agents can match tasks to skills using the `tags` array. This is the recommended approach for agents that need to dynamically select capabilities at runtime. ```python theme={null} def find_skills_by_tags(card, required_tags): """Return skills that match ALL required tags.""" return [ skill for skill in card["skills"] if all(tag in skill.get("tags", []) for tag in required_tags) ] # Find skills for financial research finance_skills = find_skills_by_tags(card, ["finance", "stocks"]) # Returns: [MarketPulse Financial Data] ``` ### Pattern 2: Example-Based Intent Matching For LLM-powered agents, the `examples` field provides natural-language queries that can be used for semantic similarity matching against the user's intent. ```python theme={null} # Collect all examples with their skill IDs example_index = [] for skill in card["skills"]: for example in skill.get("examples", []): example_index.append({"text": example, "skill_id": skill["id"]}) # Use an embedding model to find the closest match to the user's query # user_query = "What's the stock price of Apple?" # → Matches MarketPulse skill via "Get the current stock price for AAPL" ``` ## Interactive Explorer AIsa provides two browser-based tools for exploring the discovery surface: * **[API Explorer](https://aisa.one/api-explorer)** — Interactive API reference for browsing documented endpoints and request/response examples. * **[Agent Discovery](https://aisa.one/agent-discovery)** — Visual skill explorer with search and tag filtering, plus integration code examples. ## CORS Support The discovery endpoints include permissive CORS headers (`Access-Control-Allow-Origin: *`) so that browser-based agents and web applications can fetch them directly without a proxy server. This applies to: * `/.well-known/agent-card.json` * `/.well-known/ai-plugin.json` * `/openapi.yaml` ## Related API key generation, scoping, rotation, and secure storage. Browse and install composable skills for Claude Code, Cursor, and OpenClaw. Make your first authenticated API request in minutes. # Authentication Source: https://aisa.one/docs/guides/authentication Authenticate every AIsa API request with a Bearer token. Covers API key generation, storage, rotation, scoping, and best practices for secure key management. Every AIsa API request is authenticated with a single Bearer token — your **AIsa API key**. One key works across all 100+ endpoints: LLM inference, search, financial data, Twitter, prediction markets, and more. ## How it works Create a key in the [dashboard](https://console.aisa.one) under **API Keys**. Each key has a unique prefix (`sk-aisa-...`) and is shown **once** — copy it immediately to a secure store. Include the key in every request's `Authorization` header: ``` Authorization: Bearer YOUR_AISA_API_KEY ``` Every call deducts from your workspace wallet. Usage and cost appear in [Usage Logs](/docs/guides/dashboard/usage-logs) in real time. ## Authenticating with SDKs Because AIsa is OpenAI-compatible, the official OpenAI SDKs work by swapping `base_url` and `api_key`: ```python Python theme={null} from openai import OpenAI client = OpenAI( base_url="https://api.aisa.one/v1", api_key="sk-aisa-..." ) ``` ```typescript TypeScript theme={null} import OpenAI from "openai"; const client = new OpenAI({ baseURL: "https://api.aisa.one/v1", apiKey: process.env.AISA_API_KEY, }); ``` ```bash curl theme={null} curl https://api.aisa.one/v1/chat/completions \ -H "Authorization: Bearer $AISA_API_KEY" \ -H "Content-Type: application/json" \ -d '{"model":"gpt-5.4","messages":[{"role":"user","content":"Hello"}]}' ``` Pass the key through an environment variable (`AISA_API_KEY`) rather than hard-coding it in source. All AIsa examples and skill clients read from this variable by default. ## Key lifecycle ### Creating keys * Navigate to [console.aisa.one](https://console.aisa.one) → **API Keys**. * Click **Create Key**, give it a label (e.g., `prod-web-app`, `ci-tests`), and copy the value. * Create **one key per deployment environment** — separate keys for dev, staging, prod, and each service. This makes rotation and revocation surgical. ### Scoping and quotas On the key creation form you can optionally set: * **Spend cap** — maximum USD the key can charge per day/week/month. When hit, subsequent requests return `429 quota_exceeded`. * **Rate-limit overrides** — lower the default RPM/TPM below your account tier for a specific key. * **Model allowlist** — restrict the key to specific models (e.g., only `gpt-5.4-mini` for a cost-sensitive internal tool). ### Rotating keys Rotate keys at least **every 90 days**, or immediately if you suspect exposure. Generate a new key with the same label + a version suffix (e.g., `prod-web-app-v2`). Push the new key to your secret manager. Wait for the deployment to roll out across every instance. Once you've verified no requests are still using the old key (check **Usage Logs** filtered by key), revoke it in the dashboard. ### Revoking keys If a key leaks, **revoke it immediately** in the dashboard. Revocation is instant — the next request with that key returns `401 revoked_api_key`. Always revoke before investigating. ## Storing keys securely Never commit keys to source control. Never paste keys in public issues, shared documents, or screenshots. AIsa keys grant full spend authority against your wallet. Use a `.env` file and a loader like `python-dotenv` or `dotenv` (Node). Add `.env` to `.gitignore`. ```bash theme={null} # .env AISA_API_KEY=sk-aisa-... ``` ```python theme={null} from dotenv import load_dotenv load_dotenv() ``` Store the key as a **secret** in your CI provider (GitHub Actions, GitLab CI, CircleCI). Reference it as an environment variable in the workflow. ```yaml theme={null} # GitHub Actions env: AISA_API_KEY: ${{ secrets.AISA_API_KEY }} ``` Use a dedicated `ci-tests` key with a low spend cap so a runaway test can't drain the wallet. Use your cloud provider's secret manager: * **AWS**: Secrets Manager or Systems Manager Parameter Store * **GCP**: Secret Manager * **Azure**: Key Vault * **Fly/Render/Railway**: the platform's built-in env var encryption Rotate by updating the secret; the next container restart picks it up. **Never ship an API key in a browser, mobile app, or any client the user can inspect.** Always route through a backend proxy you control. If you need to call AIsa from a client, build a server-side endpoint that: 1. Validates the caller (user auth) 2. Applies per-user rate limits 3. Forwards to AIsa with your server-held key ## Best practices * **One key per service** — never share keys across apps * **Scope narrowly** — use model allowlists and spend caps to blast-radius any leak * **Rotate on a schedule** — at minimum every 90 days; immediately on personnel change * **Monitor usage logs** — unusual spikes often appear in [Usage Logs](/docs/guides/dashboard/usage-logs) before billing alerts * **Set quota alerts** — configure daily/weekly spend thresholds in the [AIsa console](https://console.aisa.one/) settings * **Prefer SSO** for dashboard access so revocation propagates from your identity provider ## Related Data retention, transport security, and third-party provider handling. 401, 403, and other auth-related responses. RPM, TPM, and concurrency caps per tier. Make your first authenticated request. # Changelog Source: https://aisa.one/docs/guides/changelog A running log of new features, API additions, fixes, and improvements to the AIsa platform. Updated with every significant release. Stay up to date with what's new across the AIsa platform — API endpoints, documentation, developer tools, and infrastructure changes. Entries are grouped by date, with the most recent changes at the top. *** ## April 21, 2026 ### Agent Discovery Infrastructure AIsa now publishes three machine-readable discovery endpoints so autonomous agents can find, authenticate with, and invoke AIsa's capabilities without human intervention. | Endpoint | URL | Protocol | | :----------------- | :----------------------------- | :--------------- | | A2A Agent Card | `/.well-known/agent-card.json` | Google A2A | | AI Plugin Manifest | `/.well-known/ai-plugin.json` | OpenAI Plugin v1 | | OpenAPI Spec | `/openapi.yaml` | OpenAPI 3.1.0 | All three endpoints include permissive CORS headers (`Access-Control-Allow-Origin: *`) so browser-based agents and web applications can fetch them directly. The agent card advertises 13 skills with tags, descriptions, and example queries for programmatic skill matching. Learn how to integrate your agents with AIsa using the A2A protocol, plugin manifest, and OpenAPI spec. ### Developer Tools on aisa.one The main website now includes two new developer-facing pages and an updated navigation structure: **API Explorer** — An interactive Swagger UI at [aisa.one/api-explorer](https://aisa.one/api-explorer) for browsing, testing, and integrating with all 111+ AIsa endpoints directly in the browser. Supports persistent authorization and live request execution. **Agent Discovery Page** — A visual skill explorer at [aisa.one/agent-discovery](https://aisa.one/agent-discovery) with search and tag filtering across all 13 skills, integration code examples in Python, TypeScript, and cURL, and a live "Try It" sandbox for testing the discovery-to-invocation flow. **Developers Dropdown** — The navbar now features a "Developers" dropdown with quick links to Documentation, API Explorer, Agent Discovery, and the OpenAPI Spec. ### OpenAPI Auto-Sync A new GitHub Actions workflow automatically consolidates individual OpenAPI specs from the docs repo, validates the generated `openapi.yaml`, and syncs it to the website repository. Slack notifications report success, no-change, or failure outcomes. ### URL Migration All documentation URLs have been migrated from `docs.aisa.one` to `aisa.one/docs`, and `marketplace.aisa.one` has been replaced with `console.aisa.one`. Existing links redirect automatically. *** ## April 20, 2026 ### Financial API Additions Two new endpoints have been added to the Financial Data API: | Endpoint | Description | | :--------------------------------------- | :------------------------------------------------------------------- | | `GET /apis/v1/financial/prices/snapshot` | Batch price snapshot for multiple tickers in a single request | | `GET /apis/v1/financial/earnings` | Earnings data including EPS actuals, estimates, and surprise metrics | The Financial API reference pages have been reorganized by canonical tag for easier navigation, and macro interest rate pages are now grouped under a dedicated "Interest Rates" subheader. ### Prediction Market Fixes Several improvements to the Polymarket and Kalshi API documentation: The Polymarket candlestick and wallet PnL endpoints have been corrected to use query parameters instead of path parameters, matching the actual API behavior. Missing query parameters `condition_id` and `wallet_address` have been added to the relevant endpoints. The pagination example link in the Polymarket spec has been updated to point to the correct location. ### Analyst Estimates Correction The analyst estimates endpoint has been renamed from "Earnings Per Share" to "Analyst Estimates" to accurately reflect its content. The description has been updated to remove references to price targets and analyst counts that are not returned by the endpoint. *** ## April 19, 2026 ### CoinGecko API (23 Endpoints) A complete CoinGecko integration is now available through AIsa, covering cryptocurrency market data across 23 endpoints. Access coin prices, market charts, OHLC data, trending coins, exchange information, and global market statistics — all through your existing AIsa API key. Browse all 23 CoinGecko endpoints with interactive examples. ### Video Generation — All 4 Wan Models The video generation documentation has been expanded to cover all four Wan 2.7 model variants: | Model | Type | Resolution | | :-------------------- | :------------- | :--------- | | `wan2.7-t2v-1.3B` | Text-to-video | 480p | | `wan2.7-t2v-14B` | Text-to-video | 720p | | `wan2.7-i2v-480p-14B` | Image-to-video | 480p | | `wan2.7-i2v-720p-14B` | Image-to-video | 720p | > These variant IDs were later consolidated. The gateway now exposes `wan2.7-t2v`, `wan2.7-i2v`, and `wan2.7-r2v` at 720p/1080p — see the [model catalog](/docs/guides/models) for current IDs. ### Navigation Restructure Documentation tab slugs have been flattened to `/guides`, `/api-reference`, and `/agent-skills` for cleaner URLs and improved navigation. *** ## April 18, 2026 ### Image Generation Endpoints Two new image generation pages have been added to the API reference: **Image Generation via Chat** — Generate images using the `wan2.7-image` model family through the standard `/v1/chat/completions` endpoint. This allows image generation within the same conversational interface used for text. **OpenAI-Compatible Image Generations** — Generate images using SeedREAM through the `/v1/images/generations` endpoint, fully compatible with the OpenAI Images API format. The video task-status endpoint has been corrected to use a path parameter for the task ID, matching the actual API behavior. *** ## April 17, 2026 ### Twitter/X Action Endpoints Six new Twitter/X action endpoints are now available, enabling full read-write automation: | Endpoint | Method | Description | | :---------------------------------- | :----- | :--------------------- | | `/apis/v1/twitter/follow_twitter` | POST | Follow a user | | `/apis/v1/twitter/unfollow_twitter` | POST | Unfollow a user | | `/apis/v1/twitter/post_twitter` | POST | Post a tweet | | `/apis/v1/twitter/like_twitter` | POST | Like a tweet | | `/apis/v1/twitter/unlike_twitter` | POST | Unlike a tweet | | `/apis/v1/twitter/auth_twitter` | POST | Initiate OAuth linking | These endpoints complement the existing read-only Twitter search and profile endpoints, enabling autonomous agents to engage on Twitter/X programmatically. ### Documentation Platform Migration The AIsa documentation has been migrated from ReadMe.com to Mintlify, bringing improved navigation, interactive API playground, and a cleaner reading experience. All existing documentation URLs continue to work through automatic redirects. ### Model Catalog Updates The model families table on the welcome page has been updated to reflect the current catalog. Pricing documentation has been clarified to note that Anthropic models are available at provider rates rather than discounted rates. ### Housekeeping Several orphaned OpenAPI specification files have been removed, including stale v2 Twitter specs and unused Jina AI specs. This cleanup reduces repository size and prevents confusion with outdated endpoint definitions. *** ## Earlier Releases For changes prior to April 17, 2026, see the [GitHub commit history](https://github.com/AIsa-team/docs/commits/main). # Access Chinese AI Models via One API - Qwen, DeepSeek, Kimi, ByteDance Seed, MiniMax, GLM, StepFun and MiMo Source: https://aisa.one/docs/guides/chinese-llms Current AIsa guide to Chinese LLM and media models: exact model IDs, context windows, capabilities, endpoints, and pricing links for Qwen, Wan, DeepSeek, Kimi, ByteDance Seed, Seedream, MiniMax, GLM, StepFun, and Xiaomi MiMo. OpenAI-compatible through https://api.aisa.one/v1. AIsa gives you one API key for China's leading AI model families: Alibaba Qwen and Wan, DeepSeek, Moonshot Kimi, ByteDance Seed and Seedream, MiniMax, Zhipu GLM, StepFun, and Xiaomi MiMo. Use the same AIsa wallet, usage logs, and OpenAI-compatible SDK setup you use for GPT and Claude. This page was refreshed from the live [AIsa Model Gateway](https://aisa.one/models) pricing feed on July 28, 2026. For exact prices at request time, check [aisa.one/models](https://aisa.one/models) or the [pricing guide](/docs/guides/pricing/ai-model-pricing-llm-inference). ## API base ```python theme={null} from openai import OpenAI client = OpenAI( api_key="YOUR_AISA_API_KEY", base_url="https://api.aisa.one/v1" ) response = client.chat.completions.create( model="qwen3.7-max", messages=[{"role": "user", "content": "Compare Qwen, DeepSeek, and Kimi for a coding agent."}] ) print(response.choices[0].message.content) ``` Chinese text, vision, coding, audio, and video-understanding models use `POST /v1/chat/completions`, and most also accept Anthropic-compatible `POST /v1/messages`. `POST /v1/responses` is now served by most Chinese text-model routes (including `qwen3-max`, `MiniMax-M3`, `deepseek-v3`, `glm-5.2`, and `kimi-k3`) — exceptions include `qwen-plus-2025-12-01`, `seed-2-0-mini-260215`, and the `step-3.5-flash` routes; an unsupported combination returns `400 model_route_not_supported`. Image models use `POST /v1/images/generations` and `POST /v1/images/edits` (except `seedream-4-5-251128`, which stays on chat/completions); Wan and Dreamina video models are asynchronous through `POST /v1/video/generations`. Use the exact model IDs below. ## Alibaba Qwen and Wan | Model ID | Context | Capabilities | Best for | | -------------------------------- | --------: | ---------------------------------- | ------------------------------------------------- | | `qwen-flash` | 1,000,000 | Audio, Coding, Text, Video, Vision | Lowest-cost high-volume multimodal work | | `qwen-mt-flash` | 1,000,000 | Text | Fast translation | | `qwen-mt-lite` | 1,000,000 | Text | Lowest-cost translation | | `qwen-plus-2025-12-01` | 1,000,000 | Audio, Coding, Text, Video, Vision | General multimodal workloads | | `qwen3-coder-480b-a35b-instruct` | 262,144 | Coding, Text | Maximum Qwen coding capability | | `qwen3-coder-flash` | 1,000,000 | Coding, Text | Fast coding pipelines | | `qwen3-coder-plus` | 1,000,000 | Coding, Text | Balanced coding agents | | `qwen3-max` | 262,144 | Audio, Coding, Text, Video, Vision | Strong general Qwen model | | `qwen3-vl-flash` | 131,072 | Coding, Text, Video, Vision | Low-cost vision and video understanding | | `qwen3-vl-flash-2025-10-15` | 131,072 | Coding, Text, Video, Vision | Pinned Qwen VL Flash version | | `qwen3-vl-plus` | 131,072 | Coding, Text, Video, Vision | Stronger document/spatial vision | | `qwen3.6-plus` | 1,000,000 | Coding, Text, Video, Vision | Long-context Chinese and bilingual work | | `qwen3.6-plus-2026-04-02` | 262,144 | Coding, Text, Vision | Pinned Qwen 3.6 Plus version | | `qwen3.7-max` | 1,000,000 | Coding, Text | Frontier Qwen reasoning and agentic coding | | `qwen3.7-max-2026-06-08` | — | Text | Pinned Qwen 3.7 Max version | | `qwen3.7-plus` | — | Text | Lower-cost Qwen 3.7 route | | `wan2.7-image` | N/A | Image, Text, Vision | Image generation/editing, text in images | | `wan2.7-image-pro` | N/A | Image, Text, Video, Vision | Higher-quality image and image-to-video workflows | | `wan2.7-t2v` | — | Video | Text-to-video generation (720p/1080p) | | `wan2.7-i2v` | — | Video | Image-to-video generation (720p/1080p) | | `wan2.7-r2v` | — | Video | Reference-to-video generation (720p/1080p) | ## DeepSeek | Model ID | Context | Capabilities | Best for | | ------------------- | ------: | ------------ | ------------------------------------------------------ | | `deepseek-r1` | 262,144 | Coding, Text | Reasoning-heavy DeepSeek tasks | | `deepseek-v3` | 262,144 | Coding, Text | Low-cost general and coding work | | `deepseek-v3.1` | 262,144 | Coding, Text | Balanced DeepSeek reasoning and coding | | `deepseek-v3.2` | 128,000 | Coding, Text | Very low-cost current DeepSeek general use | | `deepseek-v4-flash` | 262,144 | Coding, Text | Very low-cost high-throughput coding/text | | `deepseek-v4-pro` | 262,144 | Coding, Text | Strong DeepSeek route on chat/completions and messages | ## Kimi | Model ID | Context | Capabilities | Best for | | ------------------ | ------: | --------------------------- | ------------------------------------------------------------- | | `kimi-k3` | — | Text | Newest Kimi generation; Moonshot's highest-tier route on AIsa | | `kimi-k2.7-code` | — | Text | Coding-focused K2.7 route | | `kimi-k2.6` | 128,000 | Text | General Kimi reasoning and long-context text | | `kimi-k2.5` | 262,144 | Coding, Text, Video, Vision | Visual coding, document vision, long-video understanding | | `kimi-k2-thinking` | 256,000 | Coding, Text | Reasoning and agentic coding | ## MiniMax and GLM | Model ID | Provider | Context | Capabilities | Best for | | -------------- | --------- | --------: | --------------------------- | ---------------------------------------------- | | `MiniMax-M2.5` | MiniMax | 262,144 | Coding, Text | Cost-efficient long-document text and coding | | `MiniMax-M3` | MiniMax | 1,000,000 | Coding, Text, Video, Vision | 1M-context MiniMax with vision/video tags | | `glm-5` | Zhipu GLM | 128,000 | Coding, Text | Chinese reasoning, bilingual documents, coding | | `glm-5.1` | Zhipu GLM | — | Text | Mid-tier GLM 5 revision | | `glm-5.2` | Zhipu GLM | — | Text | Newest GLM 5 revision | ## ByteDance Seed and Seedream | Model ID | Context | Capabilities | Best for | | ----------------------------------- | ------: | --------------------------- | --------------------------------------------- | | `seed-1-6-250915` | 262,144 | Text, Video, Vision | Stable general Seed route | | `seed-1-6-flash-250715` | 262,144 | Text, Video, Vision | Fast, low-cost throughput | | `seed-1-8-251228` | 262,144 | Coding, Text, Video, Vision | Stronger agentic and coding tasks | | `seed-2-0-mini-260215` | 262,144 | Coding, Text, Video, Vision | Low-cost Seed 2.0 route | | `seed-2-0-lite-260228` | 262,144 | Coding, Text, Video, Vision | Balanced Seed 2.0 route | | `seed-2-0-pro-260328` | 262,144 | Coding, Text, Video, Vision | Strongest Seed 2.0 route | | `seedream-4-5-251128` | N/A | Image, Vision | Image generation and editing | | `seedream-5-0-260128` | 262,144 | Image, Vision | Newer Seedream image route | | `dreamina-seedance-2-0-260128` | — | Video | Dreamina Seedance video generation (up to 4k) | | `dreamina-seedance-2-0-fast-260128` | — | Video | Faster, lower-cost Seedance video route | ## StepFun and Xiaomi MiMo | Model ID | Provider | Context | Capabilities | Best for | | --------------------- | -------- | ------: | ------------ | ----------------------------------- | | `step-3.5-flash` | StepFun | — | Text | Low-cost StepFun text route | | `step-3.5-flash-2603` | StepFun | — | Text | Pinned snapshot of `step-3.5-flash` | | `step-3.7-flash` | StepFun | — | Text | Newest StepFun flash route | | `mimo-v2.5` | Xiaomi | — | Text | Very low-cost Xiaomi MiMo route | | `mimo-v2.5-pro` | Xiaomi | — | Text | Higher-tier MiMo route | ## Choosing quickly | Need | Start with | | ----------------------------------- | ------------------------------------------------------------------- | | Lowest-cost text or coding | `deepseek-v4-flash`, `qwen-flash`, `qwen-mt-flash` | | 1M-token Chinese/bilingual context | `qwen3.7-max`, `qwen3.6-plus`, `MiniMax-M3` | | Coding agents | `qwen3-coder-plus`, `qwen3.7-max`, `kimi-k2-thinking`, `MiniMax-M3` | | Vision/document/video understanding | `qwen3-vl-plus`, `kimi-k2.5`, `seed-2-0-pro-260328` | | Image generation/editing | `seedream-5-0-260128`, `seedream-4-5-251128`, `wan2.7-image-pro` | | Chinese-language reasoning | `glm-5.2`, `qwen3.7-max`, `MiniMax-M3` | | Video generation | `wan2.7-t2v`, `wan2.7-i2v`, `dreamina-seedance-2-0-260128` | | Lowest-cost experimentation | `qwen-flash`, `step-3.5-flash` | A `—` in the Context column means the current gateway metadata does not publish that model's context window, and the Capabilities column then shows only its base type. Check [aisa.one/models](https://aisa.one/models) for live limits and capability tags. ## Provider guides * [Qwen and Wan models](/docs/guides/chinese-llms/qwen) * [DeepSeek models](/docs/guides/chinese-llms/deepseek) * [Kimi models](/docs/guides/chinese-llms/kimi) * [ByteDance Seed and Seedream](/docs/guides/chinese-llms/bytedance) * [MiniMax models](/docs/guides/chinese-llms/minimax) * [GLM models](/docs/guides/chinese-llms/glm) * [All supported AIsa models](/docs/guides/models) # ByteDance Models API - Access Seed and Seedream via AIsa Source: https://aisa.one/docs/guides/chinese-llms/bytedance Current AIsa guide to ByteDance Seed and Seedream model IDs, context windows, capabilities, endpoints, and prices, including Seed 1.x, Seed 2.0, Seedream 4.5, and Seedream 5.0 routes through BytePlus. AIsa routes ByteDance Seed and Seedream models through BytePlus, ByteDance's official international enterprise platform. Use one AIsa API key for Seed text/vision/video/coding models and Seedream image models. Seed text/vision/video-understanding models use `POST /v1/chat/completions` (most also accept Anthropic-compatible `POST /v1/messages`). `seedream-5-0-260128` uses `POST /v1/images/generations` and `seedream-4-5-251128` uses `POST /v1/chat/completions`; both are billed per request. Dreamina Seedance video models are asynchronous through `POST /v1/video/generations`. ## Supported ByteDance models | Model ID | Context | Capabilities | Price | Best for | | ----------------------------------- | ------: | --------------------------- | --------------------------------------------------------: | --------------------------------------- | | `seed-1-6-250915` | 262,144 | Text, Video, Vision | \$0.2250 in / \$0.9000 out per 1M | Stable general Seed route | | `seed-1-6-flash-250715` | 262,144 | Text, Video, Vision | \$0.0675 in / \$0.2700 out per 1M | Fast, low-cost throughput | | `seed-1-8-251228` | 262,144 | Coding, Text, Video, Vision | \$0.2250 in / \$1.8000 out per 1M | Stronger agentic and coding tasks | | `seed-2-0-mini-260215` | 262,144 | Coding, Text, Video, Vision | \$0.1000 in / \$0.4000 out per 1M | Low-cost Seed 2.0 route | | `seed-2-0-lite-260228` | 262,144 | Coding, Text, Video, Vision | \$0.2500 in / \$2.0000 out per 1M | Balanced Seed 2.0 route | | `seed-2-0-pro-260328` | 262,144 | Coding, Text, Video, Vision | \$0.5000 in / \$3.0000 out per 1M | Strongest Seed 2.0 route | | `seedream-4-5-251128` | N/A | Image, Vision | \$0.036/request | Image generation and editing | | `seedream-5-0-260128` | 262,144 | Image, Vision | \$0.035/request | Newer Seedream image route | | `dreamina-seedance-2-0-260128` | — | Video | \$4.30/1M tokens (480p/720p/4k), \$4.70/1M tokens (1080p) | Dreamina Seedance video generation | | `dreamina-seedance-2-0-fast-260128` | — | Video | \$3.30/1M tokens (480p/720p) | Faster, lower-cost Seedance video route | The date suffix in each model string is a release/version stamp in `YYMMDD` format, useful when pinning a production route. Dreamina Seedance video models are asynchronous: submit the job to `POST /v1/video/generations`, then poll `/v1/video/generations/{task_id}`. A `—` in the Context column means the current gateway metadata does not publish that model's context window. ## Quickstart ```python theme={null} from openai import OpenAI client = OpenAI(api_key="YOUR_AISA_API_KEY", base_url="https://api.aisa.one/v1") response = client.chat.completions.create( model="seed-2-0-pro-260328", messages=[{"role": "user", "content": "Analyze this product requirements document and identify implementation risks."}] ) print(response.choices[0].message.content) ``` ## Image route example ```python theme={null} response = client.chat.completions.create( model="seedream-5-0-260128", messages=[ {"role": "user", "content": "Create a clean product image of a glass water bottle on a white marble surface."} ] ) ``` ## Common choices | Need | Use | | -------------------------------- | --------------------------------------------------------------------- | | Lowest-cost Seed route | `seed-1-6-flash-250715` or `seed-2-0-mini-260215` | | Strongest Seed text/coding route | `seed-2-0-pro-260328` | | Stable Seed 1.x route | `seed-1-6-250915` | | Image generation/editing | `seedream-5-0-260128` or `seedream-4-5-251128` | | Video generation | `dreamina-seedance-2-0-260128` or `dreamina-seedance-2-0-fast-260128` | ## Data privacy ByteDance Seed and Seedream requests are routed through BytePlus enterprise infrastructure. For compliance and data residency requirements, [contact us](mailto:developer@aisa.one). ## Next * [All Chinese AI models](/docs/guides/chinese-llms) * [Qwen and Wan models](/docs/guides/chinese-llms/qwen) * [All supported AIsa models](/docs/guides/models) # DeepSeek API - Access DeepSeek Models via AIsa Source: https://aisa.one/docs/guides/chinese-llms/deepseek Current AIsa guide to DeepSeek model IDs, context windows, endpoints, and prices, including deepseek-r1, deepseek-v3, deepseek-v3.1, deepseek-v3.2, deepseek-v4-flash, and deepseek-v4-pro. AIsa gives you OpenAI-compatible access to the current DeepSeek model family with one API key, unified billing, usage logs, and gateway routing. `deepseek-v4-pro` exposes `POST /v1/messages`, `POST /v1/chat/completions`, and `POST /v1/responses`. Other DeepSeek routes in the current catalog use `POST /v1/chat/completions`. ## Supported DeepSeek models | Model ID | Context | Capabilities | Input / 1M | Output / 1M | Best for | | ------------------- | ------: | ------------ | ---------: | ----------: | ----------------------------------------------------- | | `deepseek-r1` | 262,144 | Coding, Text | \$0.4018 | \$1.6058 | Reasoning-heavy tasks | | `deepseek-v3` | 262,144 | Coding, Text | \$0.2009 | \$0.8029 | Low-cost general and coding work | | `deepseek-v3.1` | 262,144 | Coding, Text | \$0.4018 | \$1.2047 | Balanced reasoning and coding | | `deepseek-v3.2` | 128,000 | Coding, Text | \$0.2009 | \$0.3017 | Very low-cost general use | | `deepseek-v4-flash` | 262,144 | Coding, Text | \$0.0980 | \$0.1960 | Lowest-cost high-throughput DeepSeek route | | `deepseek-v4-pro` | 262,144 | Coding, Text | \$0.3045 | \$0.6090 | Stronger DeepSeek route with multiple endpoint styles | ## Quickstart ```python theme={null} from openai import OpenAI client = OpenAI(api_key="YOUR_AISA_API_KEY", base_url="https://api.aisa.one/v1") response = client.chat.completions.create( model="deepseek-v4-flash", messages=[{"role": "user", "content": "Review this pull request for security and correctness."}] ) print(response.choices[0].message.content) ``` ## Common choices | Need | Use | | -------------------------------------------- | ------------------- | | Cheapest DeepSeek text/coding | `deepseek-v4-flash` | | General current DeepSeek route | `deepseek-v3.2` | | Reasoning-focused route | `deepseek-r1` | | Messages or Responses endpoint compatibility | `deepseek-v4-pro` | ## Data privacy AIsa routes DeepSeek requests through an enterprise-backed aggregation path. Customer data is not used for model training under AIsa's enterprise agreements. For compliance details, [contact us](mailto:developer@aisa.one). ## Next * [All Chinese AI models](/docs/guides/chinese-llms) * [Qwen models](/docs/guides/chinese-llms/qwen) * [AI model pricing](/docs/guides/pricing/ai-model-pricing-llm-inference) # GLM API - Access Zhipu AI glm-5, glm-5.1, and glm-5.2 via AIsa Source: https://aisa.one/docs/guides/chinese-llms/glm Current AIsa guide to Zhipu GLM model access, including the exact lowercase model IDs glm-5, glm-5.1, and glm-5.2, context windows, endpoints, capabilities, and prices. AIsa gives you OpenAI-compatible access to Zhipu AI's GLM family. The current AIsa catalog exposes the exact model IDs `glm-5`, `glm-5.1`, and `glm-5.2`; use lowercase in API calls. All three accept `POST /v1/chat/completions`, Anthropic-compatible `POST /v1/messages`, and `POST /v1/responses`. ## Supported GLM models | Model ID | Context | Capabilities | Input / 1M | Output / 1M | Best for | | --------- | ------: | ------------ | ---------: | ----------: | ------------------------------------------------------- | | `glm-5.2` | — | Text | \$0.7700 | \$2.6957 | Newest GLM 5 revision; highest-tier GLM route on AIsa | | `glm-5.1` | — | Text | \$0.5775 | \$2.3107 | Mid-tier GLM 5 revision | | `glm-5` | 128,000 | Coding, Text | \$0.4222 | \$1.9011 | Chinese-language reasoning, bilingual documents, coding | Context windows and capability tags for `glm-5.1` and `glm-5.2` are not published in the current gateway metadata — check [aisa.one/models](https://aisa.one/models) for their live limits. ## Quickstart ```python theme={null} from openai import OpenAI client = OpenAI(api_key="YOUR_AISA_API_KEY", base_url="https://api.aisa.one/v1") response = client.chat.completions.create( model="glm-5", messages=[{"role": "user", "content": "Analyze the competitive dynamics of China's cloud computing market."}] ) print(response.choices[0].message.content) ``` ## Use a GLM route when you need * Chinese-language reasoning and long-form analysis * Chinese-English bilingual document processing * Coding help in Chinese development contexts * A model family distinct from Alibaba, ByteDance, MiniMax, and Moonshot ## Data privacy GLM requests through AIsa are covered by AIsa's enterprise agreement with Zhipu AI. Customer data is not used for model training. For compliance requirements, [contact us](mailto:developer@aisa.one). ## Next * [All Chinese AI models](/docs/guides/chinese-llms) * [MiniMax models](/docs/guides/chinese-llms/minimax) * [All supported AIsa models](/docs/guides/models) # Kimi API - Access Moonshot AI Models via AIsa Source: https://aisa.one/docs/guides/chinese-llms/kimi Current AIsa guide to Moonshot Kimi model IDs, context windows, capabilities, endpoints, and prices, including kimi-k3, kimi-k2.7-code, kimi-k2-thinking, kimi-k2.5, and kimi-k2.6. AIsa gives you OpenAI-compatible access to Moonshot AI's Kimi models under one AIsa key. Kimi routes are useful for agentic coding, long-context text, document vision, visual coding, and video understanding. All current Kimi models accept `POST /v1/chat/completions`, Anthropic-compatible `POST /v1/messages`, and `POST /v1/responses`. ## Supported Kimi models | Model ID | Context | Capabilities | Input / 1M | Output / 1M | Best for | | ------------------ | ------: | --------------------------- | ---------: | ----------: | ------------------------------------------------------------- | | `kimi-k3` | — | Text | \$3.1579 | \$15.7895 | Newest Kimi generation; Moonshot's highest-tier route on AIsa | | `kimi-k2.7-code` | — | Text | \$0.6257 | \$2.5992 | Coding-focused K2.7 route | | `kimi-k2.6` | 128,000 | Text | \$0.6587 | \$2.7360 | General Kimi reasoning and long-context text | | `kimi-k2.5` | 262,144 | Coding, Text, Video, Vision | \$0.4229 | \$2.2186 | Visual coding, document vision, long-video understanding | | `kimi-k2-thinking` | 256,000 | Coding, Text | \$0.4229 | \$1.6903 | Reasoning and agentic coding | Context windows and capability tags for `kimi-k3` and `kimi-k2.7-code` are not published in the current gateway metadata — check [aisa.one/models](https://aisa.one/models) for their live limits. ## Quickstart ```python theme={null} from openai import OpenAI client = OpenAI(api_key="YOUR_AISA_API_KEY", base_url="https://api.aisa.one/v1") response = client.chat.completions.create( model="kimi-k2.5", messages=[{"role": "user", "content": "Analyze this UI screenshot and suggest implementation changes."}] ) print(response.choices[0].message.content) ``` ## Common choices | Need | Use | | ------------------------------------------ | ------------------ | | Latest Kimi generation | `kimi-k3` | | Coding-focused Kimi route | `kimi-k2.7-code` | | Agentic reasoning and coding | `kimi-k2-thinking` | | Vision, visual coding, documents, or video | `kimi-k2.5` | | General Kimi text reasoning | `kimi-k2.6` | ## Data privacy AIsa has an enterprise agreement with Moonshot AI covering Kimi requests. For organization-specific compliance requirements, [contact us](mailto:developer@aisa.one). ## Next * [All Chinese AI models](/docs/guides/chinese-llms) * [DeepSeek models](/docs/guides/chinese-llms/deepseek) * [AI model pricing](/docs/guides/pricing/ai-model-pricing-llm-inference) # MiniMax API - Access MiniMax Models via AIsa Source: https://aisa.one/docs/guides/chinese-llms/minimax Current AIsa guide to MiniMax model IDs, context windows, capabilities, endpoints, and prices, including MiniMax-M2.5 and MiniMax-M3. AIsa gives you access to MiniMax models with a single OpenAI-compatible API key. The current catalog includes `MiniMax-M2.5` for cost-efficient text/coding and `MiniMax-M3` for 1M-token context with vision/video capability tags. `MiniMax-M2.5` uses `POST /v1/chat/completions`. `MiniMax-M3` exposes `POST /v1/messages`, `POST /v1/chat/completions`, and `POST /v1/responses`. ## Supported MiniMax models | Model ID | Context | Capabilities | Input / 1M | Output / 1M | Best for | | -------------- | --------: | --------------------------- | ---------: | ----------: | -------------------------------------------- | | `MiniMax-M2.5` | 262,144 | Coding, Text | \$0.2100 | \$0.8400 | Cost-efficient long-document text and coding | | `MiniMax-M3` | 1,000,000 | Coding, Text, Video, Vision | \$0.2100 | \$0.8400 | 1M-context reasoning with vision/video tags | ## Quickstart ```python theme={null} from openai import OpenAI client = OpenAI(api_key="YOUR_AISA_API_KEY", base_url="https://api.aisa.one/v1") response = client.chat.completions.create( model="MiniMax-M3", messages=[{"role": "user", "content": "Summarize this long research packet and extract action items."}] ) print(response.choices[0].message.content) ``` ## Common choices | Need | Use | | ----------------------------------------------------- | -------------- | | Cost-efficient text and coding | `MiniMax-M2.5` | | 1M-token context | `MiniMax-M3` | | Anthropic Messages or OpenAI Responses endpoint style | `MiniMax-M3` | | Vision or video-capability tags | `MiniMax-M3` | ## Data privacy MiniMax requests through AIsa are covered by AIsa's enterprise agreement with MiniMax. Customer data is not used for model training. For compliance requirements, [contact us](mailto:developer@aisa.one). ## Next * [All Chinese AI models](/docs/guides/chinese-llms) * [Kimi models](/docs/guides/chinese-llms/kimi) * [GLM models](/docs/guides/chinese-llms/glm) # Qwen and Wan API - Access Alibaba Models via AIsa Source: https://aisa.one/docs/guides/chinese-llms/qwen Current AIsa guide to Alibaba Qwen and Wan model IDs, context windows, capabilities, endpoints, and prices, including qwen3.7-max, qwen-flash, Qwen VL, Qwen Coder, Wan image models, and translation models. AIsa is an Alibaba Cloud Qwen Key Account Partner. Use one AIsa API key to access Qwen text, coding, vision, audio, video-understanding, translation, and Wan image models through the same gateway as your other LLMs. Qwen text, coding, vision, and translation models use `POST /v1/chat/completions` (most also accept Anthropic-compatible `POST /v1/messages`). Wan image models use `POST /v1/images/generations` and `POST /v1/images/edits` and are billed per request; Wan video models are asynchronous through `POST /v1/video/generations` and are billed per output second. ## Supported Alibaba models | Model ID | Context | Capabilities | Input / 1M | Output / 1M or request | Best for | | -------------------------------- | --------: | ---------------------------------- | ---------: | ----------------------------------------: | -------------------------------------------- | | `qwen-flash` | 1,000,000 | Audio, Coding, Text, Video, Vision | \$0.0154 | \$0.1512 | High-volume multimodal work | | `qwen-mt-flash` | 1,000,000 | Text | \$0.0720 | \$0.2205 | Fast translation | | `qwen-mt-lite` | 1,000,000 | Text | \$0.0840 | \$0.2520 | Lightweight translation | | `qwen-plus-2025-12-01` | 1,000,000 | Audio, Coding, Text, Video, Vision | \$0.2800 | \$0.8400 | General multimodal applications | | `qwen3-coder-480b-a35b-instruct` | 262,144 | Coding, Text | \$1.0500 | \$5.2500 | Maximum Qwen coding capability | | `qwen3-coder-flash` | 1,000,000 | Coding, Text | \$0.2100 | \$1.0500 | Fast coding throughput | | `qwen3-coder-plus` | 1,000,000 | Coding, Text | \$0.7000 | \$3.5000 | Coding agents and code review | | `qwen3-max` | 262,144 | Audio, Coding, Text, Video, Vision | \$0.7200 | \$3.6000 | Strong general Qwen route | | `qwen3-vl-flash` | 131,072 | Coding, Text, Video, Vision | \$0.0350 | \$0.2800 | Low-cost vision and video understanding | | `qwen3-vl-flash-2025-10-15` | 131,072 | Coding, Text, Video, Vision | \$0.0350 | \$0.2800 | Pinned Qwen VL Flash version | | `qwen3-vl-plus` | 131,072 | Coding, Text, Video, Vision | \$0.1400 | \$1.1200 | Stronger document and spatial vision | | `qwen3.6-plus` | 1,000,000 | Coding, Text, Video, Vision | \$0.2760 | \$1.6510 | Long-context Chinese/bilingual work | | `qwen3.6-plus-2026-04-02` | 262,144 | Coding, Text, Vision | \$0.2760 | \$1.6510 | Pinned Qwen 3.6 Plus route | | `qwen3.7-max` | 1,000,000 | Coding, Text | \$1.1550 | \$3.4657 | Frontier Qwen reasoning and agentic coding | | `qwen3.7-max-2026-06-08` | — | Text | \$1.1550 | \$3.4657 | Pinned Qwen 3.7 Max route | | `qwen3.7-plus` | — | Text | \$0.1932 | \$0.7707 | Lower-cost Qwen 3.7 route | | `wan2.7-image` | N/A | Image, Text, Vision | - | \$0.030/request | Image generation and editing | | `wan2.7-image-pro` | N/A | Image, Text, Video, Vision | - | \$0.075/request | Higher-quality image and image-to-video work | | `wan2.7-t2v` | — | Video | - | \$0.060208/s (720p), \$0.100347/s (1080p) | Text-to-video generation | | `wan2.7-i2v` | — | Video | - | \$0.060208/s (720p), \$0.100347/s (1080p) | Image-to-video generation | | `wan2.7-r2v` | — | Video | - | \$0.060208/s (720p), \$0.100347/s (1080p) | Reference-to-video generation | Video models are asynchronous: submit the job to `POST /v1/video/generations`, then poll `/v1/video/generations/{task_id}`. A `—` in the Context column means the current gateway metadata does not publish that model's context window. ## Quickstart ```python theme={null} from openai import OpenAI client = OpenAI(api_key="YOUR_AISA_API_KEY", base_url="https://api.aisa.one/v1") response = client.chat.completions.create( model="qwen3.7-max", messages=[{"role": "user", "content": "Plan a refactor for this Python service."}] ) print(response.choices[0].message.content) ``` ## Common choices | Need | Use | | ------------------------------------ | ------------------------------------------- | | Cheapest high-volume text/multimodal | `qwen-flash` | | Dedicated translation | `qwen-mt-flash` or `qwen-mt-lite` | | Best coding balance | `qwen3-coder-plus` | | Fast coding | `qwen3-coder-flash` | | Maximum Qwen coding capability | `qwen3-coder-480b-a35b-instruct` | | Long-context reasoning | `qwen3.7-max` or `qwen3.6-plus` | | Vision/document/video work | `qwen3-vl-plus` or `qwen3-vl-flash` | | Image generation/editing | `wan2.7-image-pro` or `wan2.7-image` | | Video generation | `wan2.7-t2v`, `wan2.7-i2v`, or `wan2.7-r2v` | ## Data privacy Qwen requests through AIsa are processed under AIsa's Alibaba Cloud Key Account enterprise agreement. For compliance documentation, [contact us](mailto:developer@aisa.one). ## Next * [All Chinese AI models](/docs/guides/chinese-llms) * [All supported AIsa models](/docs/guides/models) * [AI model pricing](/docs/guides/pricing/ai-model-pricing-llm-inference) # AIsa vs. OpenRouter - The Best Alternative for AI Agents Source: https://aisa.one/docs/guides/compare/openrouter OpenRouter is a popular platform for accessing multiple large language models through a single API. However, as AI applications evolve from passive chatbots to autonomous agents, developers need more than just a text-generation router. AIsa is built specifically as the infrastructure layer for the agentic economy. While we share the core functionality of an LLM gateway, AIsa goes significantly further by integrating data APIs, agent skills, and a native machine-to-machine payment layer. ## Feature Comparison The table below outlines the key differences between AIsa and OpenRouter for AI agent development. | Feature | AIsa | OpenRouter | | --------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------- | | **LLM Inference Pricing** | Provider rates; **up to \~30% cheaper** on select non-Anthropic models | Pass-through (same as direct provider rates) | | **Supported AI Models** | 108-model live catalog: GPT, Claude, Gemini, Grok, DeepSeek, Qwen, Kimi, MiniMax, GLM, Seed, Seedream, Dreamina, Wan, StepFun, and MiMo | 100+ | | **OpenAI API Compatibility** | Yes | Yes | | **Data APIs (Search, Social, Finance)** | **100+ built-in endpoints** | None (LLM inference only) | | **Agent Skills Marketplace** | **Yes** | Not supported | ## Why Choose AIsa? ### 1. The Complete Agent Infrastructure Stack Agents need to think, act, and transact. OpenRouter only provides the "thinking" layer (LLMs). AIsa provides the complete stack: * **Think:** Live LLM and media model catalog including `gpt-5.6-sol`, `claude-opus-5`, `claude-sonnet-5`, `gemini-3.5-flash`, `grok-4.5`, `qwen3.7-max`, `kimi-k3`, `deepseek-v4-flash`, and `MiniMax-M3` * **Act:** 100+ non-LLM data APIs (Twitter, Tavily Search, Polymarket, Financial Data) * **Transact:** Native stablecoin micropayments for autonomous agents ### 2. Lower Inference Costs on Select Models For many non-Anthropic models, AIsa negotiates volume discounts with the upstream provider and passes the savings through. Anthropic models (Claude family) are priced at provider rates — no AIsa-applied discount — but still benefit from the unified billing, routing, and fallback layer. The table below shows current AIsa public prices for representative routes (USD per 1M input / output tokens unless noted). OpenRouter pricing changes independently, so use its live dashboard for a final side-by-side comparison. | Model | Current AIsa pricing | Notes | | ------------------- | -------------------: | ----------------------------------------- | | `deepseek-v4-flash` | \$0.0980 / \$0.1960 | Very low-cost text and coding route | | `qwen-flash` | \$0.0225 / \$0.1800 | Low-cost high-volume multimodal route | | `kimi-k2.5` | \$0.4018 / \$2.1077 | Kimi vision/video/coding route | | `MiniMax-M3` | \$0.2100 / \$0.8400 | 1M-context MiniMax route | | `kimi-k3` | \$3.0000 / \$15.0000 | Newest Kimi generation | | `claude-opus-5` | \$5.0000 / \$25.0000 | Anthropic route at provider-style pricing | See [AI Model Pricing](/docs/guides/pricing/ai-model-pricing-llm-inference) for the full AIsa catalog. ### 3. Built-in Agentic Payments AIsa is the first unified API to natively support the Machine Payment Protocol (MPP) and x402 standards. This allows your agents to autonomously pay for the exact compute, data, and services they consume using a single funded wallet, eliminating the need for complex subscription management. ### 4. Seamless MCP Integration AIsa provides a fully integrated Model Context Protocol (MCP) server. This allows developers to instantly connect AIsa's 100+ data APIs directly into modern AI development environments like Cursor and Windsurf, streamlining the creation of context-aware applications. ## Migration Guide: Switching from OpenRouter Switching from OpenRouter to AIsa takes less than a minute. Because both platforms are fully compatible with the OpenAI API specification, you do not need to rewrite your application logic. Simply update your `base_url` and authenticate with your AIsa API key: ```python theme={null} from openai import OpenAI # 1. Change the base_url to AIsa # 2. Swap your OpenRouter key for an AIsa key client = OpenAI( base_url="https://api.aisa.one/v1", api_key="sk-aisa-..." ) # Your existing code works without modification response = client.chat.completions.create( model="gpt-5.4-mini", messages=[ {"role": "user", "content": "Hello, world!"} ] ) ``` To get started, create an account and generate an [API Key](/docs/guides/dashboard/overview). New users receive a **\$2 free credit** to test the platform. # Dashboard Overview – Monitor Your LLM API Usage Source: https://aisa.one/docs/guides/dashboard/overview The **Dashboard** is the landing page of the [AIsa Console](https://console.aisa.one/). It summarizes spend, traffic, and account health for the last 30 days, so you can tell at a glance whether your integration is working and how your usage is trending. AIsa Console dashboard showing balance and spend metric cards, 30-day spend and request charts, model split, and account status The usage figures — spend, requests, and model split — cover a fixed 30-day window. Balance, key, and account details are current state, not a windowed total. For arbitrary date ranges, per-request detail, or filtering by key and model, use [Usage & Logs](https://console.aisa.one/logs). ## Header Actions Two shortcuts sit next to the page title: * **New API Key** opens [API Keys](https://console.aisa.one/api-keys) to create a key * **Top Up** opens [Billing](https://console.aisa.one/billing) to add balance If a first top-up promotion is active on your account, the Top Up button shows the discount and a banner appears above the metrics with the remaining time. ## Metric Cards The top row is the fastest read on account state. Four metric cards showing total balance, 30-day spend with daily average, 30-day requests with error rate, and active key count **Total Balance** is the credit available for API spend. It is drawn down automatically as requests are processed. **Spend · 30D** is what your traffic cost over the last 30 days, with the daily average below it. **Requests · 30D** is the number of API calls in the same window. The subtitle shows the error rate — the share of those calls that failed. A rate climbing above your normal baseline is usually the first sign of a bad key, an unavailable model, or a malformed request. **Active Keys** shows enabled keys out of total keys, plus when any key was last used. If it reads *No key activity yet*, no request has ever been made with your keys. ## Spend and Requests Charts Two charts break the same 30-day totals down by day. Spend and Requests line charts, each showing a 30-day daily trend with the peak value labeled **Spend** is plotted in USD per day, **Requests** in calls per day. The value above each chart repeats the 30-day total, and the number in the top-right corner marks the peak day. Hover — or focus the chart and use the left and right arrow keys — to read the exact value and date for any single day. The labels below the line mark the start, middle, and end of the window. Reading the two charts together separates a traffic spike from a cost spike: requests flat but spend rising usually means a shift toward more expensive models or longer contexts. ## Model Split Model Split shows which models your traffic actually went to. Model Split panel listing models with call counts and share percentages, next to the Account panel showing account type and verification status Each row lists a model, its call count for the last 30 days, and its share of total calls. **View usage** opens [Usage & Logs](https://console.aisa.one/logs) for the full breakdown. If nothing has been called in the window, the panel reports that no model data is available. ## Account The Account panel shows your current identity and access status: * Display name and email * **Account type** — your current plan tier * **Security** — *Verified* or *Pending*, reflecting email verification * **Member since** — account creation date * **Last sign-in** — time of your most recent login ## When Data Fails to Load If balance, key, or usage data cannot be fetched, an inline warning appears at the top of the page with a **Refresh** button that retries all three requests at once. ## Related Test any model in the browser before writing code. Per-request cost, latency, and audit trail. # Model Playground – Test 100+ AI Models from a Single Endpoint Source: https://aisa.one/docs/guides/dashboard/playground The Playground is an interactive environment for testing models available through AIsa before integrating them into your application. It sends real requests through the same relay endpoints your production code uses, and shows you the exact request body and raw response alongside the result. AIsa Playground showing the request panel on the left and the JSON request preview plus output panel on the right Open it at [**Console → Playground**](https://console.aisa.one/playground). Requests are sent with one of your own API keys, so you need at least one **enabled key** before running a test. New accounts receive **free credits** that the Playground can spend immediately (the exact amount and eligibility depend on the promotion running at the time — see the official announcements for current terms). ## Endpoint Bar The bar above the panels shows the exact endpoint the current configuration targets, for example `POST https://api.aisa.one/v1/chat/completions`, along with a `stream: true` / `stream: false` chip that reflects the Stream toggle. The endpoint changes when you change the **Route**. ## Request Panel The left panel defines the request. Playground request panel with Key, Route, Model selectors, Stream, Temperature and Max tokens controls, and System and User prompt fields ### Key The **Key** selector chooses which of your API keys authenticates the request. Only enabled keys are listed, and each entry shows the key name plus a masked prefix and suffix. The full key value is never sent to the browser — the request is signed on the backend. Usage is attributed to the selected key, so you can isolate Playground traffic from application traffic by testing with a dedicated key. If you have no enabled keys, create one first — see [API Keys](https://console.aisa.one/api-keys). ### Route The **Route** selector chooses the API surface used for the request: * **Chat completions** — `POST /v1/chat/completions`, the OpenAI-compatible route. The system prompt is sent as a `system` message inside `messages`. * **Messages** — `POST /v1/messages`, the Anthropic-compatible route. The system prompt is sent as a top-level `system` field. Changing the route reloads the model list, because the two routes expose different sets of models. ### Model The **Model** selector lists every model the selected key can reach on the current route. The counter below the selectors shows how many models were loaded, and the refresh button re-fetches the list. Switching models does not change the request format — only the `model` identifier changes. If your account is still on trial credits and the selected model requires a paid balance, the Playground shows a top-up notice and disables **Run Test** for that model. Pick another model or add credits to continue. ## Generation Parameters ### Stream **Stream** controls whether the response is delivered incrementally as server-sent events. When enabled, output appears token by token in the Output panel and `"stream": true` is included in the request body. ### Temperature **Temperature** is opt-in: the toggle next to it decides whether `temperature` is included in the request at all. When the toggle is off, the parameter is omitted and the model's own default applies. When enabled, lower values produce more deterministic output and higher values increase variation. Accepted range is 0–2. ### Max Tokens **Max tokens** sets the upper bound on generated tokens, controlling response length and cost. It is always included in the request. ### System and User The **System** field carries instructions that shape the model's behavior; the **User** field carries the prompt itself. Both are plain text areas and both update the request preview as you type. **Run Test** sends the request. While a request is in flight the button becomes **Stop**, which aborts the connection immediately. ## Debug Panel The right panel shows exactly what AIsa sends, before you run anything. Debug panel showing the JSON request body with syntax highlighting, and the Output panel below it with Result and Response tabs * **JSON** — the request body as it will be posted, with line numbers * **cURL** — the same request as a copy-and-paste terminal command using `$AISA_API_KEY` The copy button in the panel header copies whichever tab is active. The cURL command is the fastest way to move a validated configuration from the Playground into a script or a teammate's terminal. The generated command wraps the JSON body in single quotes. If your System or User prompt contains a single quote (`'`), escape it before running the command in a shell, or the body will be truncated. ## Output Panel Below the request preview, the Output panel shows the response. * **Result** — the extracted assistant text, streamed live when Stream is on * **Response** — the response payload: the full JSON body for a non-streamed request, or, when streaming, the `data` payload of each SSE event on its own line (the `data:` prefixes and other event fields are stripped) The footer line reports request latency in milliseconds, the `x-request-id` returned by the gateway, and whether the call was streamed. Use that request ID when correlating a test with the [Usage Logs](https://console.aisa.one/logs) page or when contacting support. Errors are shown inline, with the raw error body available under the **Response** tab. ## Usage and Billing All Playground requests count toward usage and billing exactly like API requests, and appear in your logs and usage charts under the key you selected. ## What the Playground Is Best Used For * Comparing outputs across models without changing code * Checking that a model is reachable with a specific key * Validating the request body before writing the integration * Copying a working cURL command as a starting point * Debugging errors with the raw response and request ID in one place ## Related Ship the same request via code once you've validated it here. Create and manage the API key the Playground authenticates with. Browse current model IDs, context windows, endpoints, capabilities, and billing notes. # Usage Logs – Track API Requests, Tokens & Billing Source: https://aisa.one/docs/guides/dashboard/usage-logs **Usage & Logs** is the per-request record of everything that went through your AIsa keys in the last 30 days. Where the [Dashboard](/docs/guides/dashboard/overview) answers *how much*, this page answers *which request* — endpoint, model, latency, tokens, cache hits, cost, and status, one row at a time. AIsa Console usage logs page showing summary cards, usage value trend, model split, filter toolbar, and the per-request log table Open it at [**Console → Usage & Logs**](https://console.aisa.one/logs). Every figure on the page reflects the filters currently applied, not just the rows visible on screen. ## Summary Cards Four summary cards showing filtered request count, total tokens, cache tokens, and usage value with the charged amount **Requests** is the number of calls matching the current filters. **Tokens** is input plus output tokens across those calls. **Cache Tokens** is cache read plus cache write hits. On models that support prompt caching, a high read count against a low token count is what a working cache looks like. **Usage Value** is what the matching traffic was worth at list rates, with the amount actually **charged** to your balance below it. The two differ when a discount, promotion, or refund applied. ## Usage Value Trend and Model Split Usage value trend chart next to a model split panel listing models by usage value **Usage Value Trend** plots usage value in USD per day across the window. Hover — or focus the chart and use the arrow keys — to read any single point; the number in the top-right marks the peak. **Model Split** ranks models by usage value, up to five entries. Note that it is computed from the rows on the **current page**, so it follows your filters and paging rather than summarizing all 30 days — for the full-window breakdown, use the model split on the [Dashboard](/docs/guides/dashboard/overview). ## Search and Filters Toolbar with a search field, rows-per-page selector, stream filter, and status filter above the log table columns The search field matches against request ID, key, endpoint, and model — pasting a request ID from an error response or from the [Playground](/docs/guides/dashboard/playground) jumps straight to that call. Three controls narrow the table further: * **Rows** — 10, 20, or 50 entries per page * **Stream** — All, Streaming, or Non-Streaming * **Status** — All, Success, Failed, or Refunded Changing any filter resets you to the first page. ## Log Table Columns Each row is one API request. | Column | What it shows | | --------------- | ------------------------------------------------------------------------------------- | | **Time** | When the request was received, with its request ID underneath | | **Endpoint** | The API route that served it, for example `/v1/chat/completions` | | **API Key** | Name of the key used, or its prefix if the key is unnamed | | **Model** | The model that processed the request | | **Stream** | `stream` or `sync` | | **Latency** | Total request duration, with time to first token below it | | **Tokens** | Total tokens, with the input / output split below | | **Cache** | Total cache tokens, with the read / write split below | | **Usage Value** | Value of the call at list rates; if the amount charged differs, it appears underneath | | **Status** | `success`, `failed`, or `refunded` | The footer reports which slice of the result set you are viewing, with previous and next controls. If nothing matches, the table says so rather than showing an empty grid — widen the date-independent filters or clear the search box. ## Practical Uses * **Debug a failed call** — filter by Failed, find the request ID, and match it against your application logs * **Explain a cost spike** — sort out which model and key drove usage value on the peak day * **Verify caching works** — compare cache read counts against total tokens for repeated prompts * **Check streaming behavior** — filter to Streaming and compare time to first token against total latency * **Audit key activity** — search a key name to see everything it has done in the window ## Related High-level spend and usage metrics. Per-token rates driving the costs shown in logs. How request and token rates affect your traffic. # Frequently Asked Questions - AIsa Unified API Source: https://aisa.one/docs/guides/faq This page answers common questions about the AIsa unified model gateway, compatibility, pricing, and infrastructure. ## How does AIsa compare to OpenRouter or LiteLLM? While AIsa shares the core functionality of an LLM router (aggregating multiple models behind a single API), AIsa goes significantly further by integrating 100+ non-LLM data APIs (Twitter, Financial, Search), an MCP server, and native stablecoin micropayments for autonomous agents. AIsa is specifically built as the infrastructure layer for the agentic economy, where agents not only need to think (LLMs) but also act (data APIs) and transact (Machine-to-Machine Payments). ## Do I need to change my existing OpenAI code? No. AIsa is fully API-compatible with the OpenAI specification. If you are using the official OpenAI Python or TypeScript SDKs, you only need to change your `base_url` to `https://api.aisa.one/v1` and authenticate using an [AIsa API Key](/docs/guides/dashboard/overview). All standard parameters like `temperature`, `top_p`, and streaming responses work exactly as expected. ## How is pricing calculated? AIsa uses a unified usage-based billing system with no subscription fees. * **LLM inference** is billed per-token based on the underlying provider's cost. * **Data APIs** (like Search, Financial, or Twitter endpoints) are billed on a flat per-call basis. All usage is deducted from your single, centralized account balance. See the [Pricing Overview](/docs/guides/pricing) for detailed token and per-call costs. ## How do AIsa's LLM prices compare to OpenRouter? For many non-Anthropic models, AIsa prices LLM inference **up to \~30% below** the direct provider rates listed on OpenRouter. Anthropic models (Claude family) are priced at provider rates. See the full side-by-side breakdown in [AIsa vs. OpenRouter](/docs/guides/compare/openrouter). ## What models are available on AIsa? AIsa provides a single gateway for the live model catalog — 108 models as of August 5, 2026. Current families include OpenAI GPT, Anthropic Claude, Google Gemini, xAI Grok, DeepSeek, Alibaba Qwen and Wan, Moonshot Kimi, MiniMax, Zhipu GLM, ByteDance Seed, Seedream and Dreamina, StepFun, and Xiaomi MiMo. For a complete and up-to-date list of exact model IDs, context windows, endpoints, capabilities, and billing notes, visit the [supported model catalog](/docs/guides/models) and [AI Model Pricing](/docs/guides/pricing/ai-model-pricing-llm-inference) documentation. ## How do I get started? Proceed to the [Getting Started Guide](/docs/guides/getting-started-with-aisa) to create an account, generate an API key, and make your first unified API call using your free \$2 signup credit. # Getting Started with AIsa - Unified LLM API for AI Agents Source: https://aisa.one/docs/guides/getting-started-with-aisa This technical guide outlines the process of creating your first authenticated request using the AIsa Unified Model Gateway. Upon completion, you will be capable of calling AIsa's live model catalog through a single API endpoint using standard OpenAI-compatible tooling. ## Prerequisites To complete this quickstart, you must possess the following: 1. An active AIsa account. 2. A valid API key generated from the AIsa dashboard. 3. A foundational understanding of OpenAI-style Chat Completions APIs. All newly registered accounts automatically receive a **\$2.00 free credit balance**. These funds are immediately available for testing within the browser-based Model Playground or via direct REST API calls. ## Step 1: Account Creation and API Key Generation The first step requires establishing an identity on the platform and generating a secure authentication token. 1. Navigate to the [AIsa registration portal](https://console.aisa.one/) and create an account. The platform supports standard email registration, which requires verifying your email address before setting a password, as well as Single Sign-On (SSO) via Google OAuth and GitHub OAuth. Either path lands you in the dashboard once the account is active. 2. Upon successful registration, you are directed to the API Keys page, where a key has already been generated for you. Copy and store this key securely, it authenticates all requests and is tied to your usage and billing profile. 3. To create additional API keys or set spending limits, return to the API Keys page at any time. When creating or editing a key, you can assign it a quota, the maximum amount that key is permitted to spend, or enable unlimited quota to remove the cap entirely. > Note: A key's quota is a spending cap on that specific key, not your total funds. Your credit balance is the overall amount available in your account wallet; a key can only spend up to whichever is lower, its quota or your remaining balance. This is useful when sharing keys across projects or team members, as it prevents any single key from consuming your entire balance. A practical pattern is one key per service or environment — for example a development key with a small quota, and a production key with a larger one — so that revoking or rotating a single key never interrupts your other integrations. See [Authentication](/docs/guides/authentication) for the full set of key-management practices. Your API key authenticates all requests and is strictly tied to your usage metering and billing profile. It is critical to maintain the security of this key; never expose it in client-side code, public repositories, or unsecured environment variables. ## Step 2: Executing Your First API Call AIsa exposes a single API endpoint (`https://api.aisa.one/v1`) that dynamically routes requests to multiple providers based on the specified model parameter. Because the AIsa gateway is fully compliant with OpenAI's Chat Completions API specification, developers only need to modify three variables in their existing codebases: * `base_url`: Must point to the AIsa endpoint. * `api_key`: Must be your generated AIsa token. * `model`: Must be a valid model identifier supported by AIsa. ### Example: REST API Request via cURL The following example demonstrates a standard HTTP POST request to the completions endpoint. ```curl theme={null} curl --request POST \ --url https://api.aisa.one/v1/chat/completions \ --header 'Authorization: Bearer ' \ --header 'Content-Type: application/json' \ --data ' { "model": "gpt-5.4-mini", "messages": [ { "role": "user", "content": "Explain the concept of an AI gateway in one concise sentence." } ], "stream": false }' ``` The response format mirrors the standard OpenAI schema, returning a JSON object containing the `choices` array, the generated `message`, and detailed token usage metrics for billing transparency. ## Step 3: Integrating with Official SDKs Due to its strict API compatibility, AIsa integrates natively with official OpenAI SDKs, eliminating the need for custom libraries. ### Python SDK Integration To utilize AIsa via Python, install the `openai` package and instantiate the client with your AIsa credentials. ```python theme={null} from openai import OpenAI client = OpenAI( api_key="", base_url="https://api.aisa.one/v1" ) response = client.chat.completions.create( model="gpt-5.4-mini", messages=[ {"role": "user", "content": "Explain the concept of an AI gateway in one concise sentence."} ], stream=False ) print(response.choices[0].message.content) ``` ### TypeScript SDK Integration Similarly, Node.js environments can leverage the official `openai` NPM package. ```typescript theme={null} import OpenAI from "openai"; const client = new OpenAI({ apiKey: process.env.AISA_API_KEY, baseURL: "https://api.aisa.one/v1", }); async function main() { const response = await client.chat.completions.create({ model: "gpt-5.4-mini", messages: [ { role: "user", content: "Explain the concept of an AI gateway in one concise sentence." } ], stream: false, }); console.log(response.choices[0].message.content); } main(); ``` ## Next Steps With your authentication established and the basic integration pattern confirmed, you can proceed to explore more advanced platform features. Developers are encouraged to utilize the [Model Playground](/docs/guides/dashboard/playground) to visually inspect request payloads, test multimodal inputs, and compare the outputs of different models prior to deploying code into production environments. For detailed cost calculations regarding token consumption, review the [AI Model Pricing](/docs/guides/pricing/ai-model-pricing-llm-inference) documentation. # Pre-Built Skills vs Custom Skills — When to Use Each Source: https://aisa.one/docs/guides/learn/agent-skills-vs-tools Understand when to install a pre-built Agent Skill from the agent-skills registry versus creating your own SKILL.md from scratch with aisa skills init. There are two ways to give your AI coding agent new capabilities with AIsa Agent Skills: install a pre-built skill from the [agent-skills](https://github.com/AIsa-skills) registry, or write your own `SKILL.md` from scratch. The right choice depends on whether your use case is already covered. *** ## The core difference | | **Pre-built skill** (from registry) | **Custom skill** (your own SKILL.md) | | ------------------ | ------------------------------------------------------------------- | ------------------------------------- | | **Source** | [AIsa-team/agent-skills](https://github.com/AIsa-team/agent-skills) | You write it | | **How to install** | `aisa skills install ` | `aisa skills init ` + edit | | **Setup time** | 30 seconds | Minutes to hours | | **Maintenance** | Managed by AIsa team | Yours to maintain | | **API coverage** | AIsa's public catalogue | Any API you can reach | | **Customisation** | Use as-is | Fully custom instructions and scripts | *** ## Use a pre-built skill when… **The capability already exists in the registry.** If you need web search, financial data, Twitter/X access, image/video generation, or YouTube research — there's already a skill for it. Installing it takes one command and it comes with tested scripts and worked examples. **You want the AIsa team to maintain it.** Pre-built skills are updated when the underlying APIs change. You don't have to track API deprecations or rewrite instructions when endpoints move. **You're prototyping quickly.** `aisa skills install market` and a new Claude Code session is all you need to start querying live stock prices. Writing, testing, and maintaining an equivalent custom skill takes meaningfully longer. ### Example: install and use the market skill ```bash theme={null} # Install aisa skills install market # Open a new agent session and ask: # "Pull the last 30 days of NVDA price data and flag any days where # the move exceeded 5%. Cross-reference with earnings dates." ``` The agent reads the `market` skill description, loads the `SKILL.md` instructions, runs the bundled Python client, and calls AIsa's finance API — without you writing any code. *** ## Write a custom skill when… **You need to call your own internal APIs.** Pre-built skills cover AIsa's public API catalogue. They can't query your company's internal data warehouse, CRM, or proprietary service. For those, write a SKILL.md that describes your internal endpoints and authentication. **The existing skill doesn't cover your exact use case.** If you need a very specific workflow — a multi-step process combining several APIs in a particular order — a custom skill lets you encode exactly that sequence in the instructions body. **You want to share domain-specific knowledge with the agent.** SKILL.md files aren't just API wrappers. You can include domain context, decision rules, output formatting requirements, and caveats that your team has learned from production use. **You want to publish a skill for others.** Custom skills can be submitted to the [agent-skills](https://github.com/AIsa-team/agent-skills) registry as a pull request. If you've built something useful on top of AIsa APIs, contributing it benefits the whole ecosystem. ### Example: scaffold and edit a custom skill ```bash theme={null} # Start from the closest built-in template aisa skills init internal-crm --template default # Edit the generated SKILL.md # - Set name, description, and metadata # - Write instructions that explain your CRM's auth and endpoints # - Add example curl/Python commands for common queries ``` The `description` field is the most important line you'll write. It's what your agent reads at startup to decide when to activate the skill. Be specific about the trigger condition: ```yaml theme={null} # ❌ Too generic — the agent won't know when to use this description: "Internal CRM access." # ✅ Clear trigger — the agent knows exactly when this applies description: "Look up customer account details, support history, and renewal dates from the internal Salesforce CRM. Use when the user asks about a specific customer or account." ``` *** ## Quick decision guide ``` Is there a pre-built skill in the OpenClaw registry for this? │ ├── YES → Does it cover your use case without modification? │ ├── YES → aisa skills install │ └── NO → aisa skills init (customise or extend) │ └── NO → Does it involve an AIsa public API not yet in the registry? ├── YES → aisa skills init --template │ (and consider submitting a PR to agent-skills) └── NO → aisa skills init --template default (write instructions for your internal API) ``` *** ## What's next * [Agent Skills](/docs/agent-skills) — browse the full catalogue of pre-built skills * [Quickstart](/docs/agent-skills/quickstart) — install your first skill in 5 minutes * [Standards](/docs/agent-skills/standards) — how SKILL.md files work and how to author your own * [Getting Started with AIsa](/docs/guides/getting-started-with-aisa) — if you're new to the AIsa API # What is an LLM Gateway? A Guide to Unified AI APIs Source: https://aisa.one/docs/guides/learn/what-is-an-llm-gateway The artificial intelligence landscape is fragmenting at an unprecedented pace. Just a few years ago, integrating AI meant calling a single OpenAI endpoint. Today, developers must navigate a complex ecosystem of competing frontier models from Anthropic, Google, DeepSeek, Alibaba, and open-source providers. This fragmentation introduces significant engineering overhead. Developers are forced to manage multiple API keys, handle differing API schemas, track usage across disparate billing dashboards, and implement complex fallback logic to ensure high availability. Enter the **LLM Gateway** (also known as a unified AI API or model router). ## The Definition of an LLM Gateway An LLM gateway is a middleware layer that sits between your application and the various AI model providers. It provides a single, unified API endpoint that routes requests to the appropriate underlying model. Instead of integrating five different SDKs, you integrate one gateway SDK. The gateway handles the translation, authentication, and routing behind the scenes. ## Core Features of an LLM Gateway A robust LLM gateway solves several critical infrastructure challenges: ### 1. Unified API Schema The most immediate benefit is schema normalization. Most modern gateways adopt the OpenAI API specification as the standard. This means you can call `claude-opus-4-8`, `gemini-3.5-flash`, or `qwen3.7-max` using the same code structure you would use for `gpt-5.4-mini`. You simply change the `model` parameter in your request. ### 2. Intelligent Routing and Fallbacks Provider APIs frequently experience rate limits or unexpected downtime. An LLM gateway implements automatic failover logic. If a request to an Anthropic endpoint fails, the gateway can automatically retry the request using an identical model hosted on a different cloud provider (like AWS Bedrock or Google Cloud), ensuring your application remains highly available. ### 3. Load Balancing For high-volume applications, a single API key or provider account may not offer sufficient throughput. Gateways can load balance requests across multiple keys or deployments to maximize concurrency. ### 4. Centralized Observability and Billing Rather than logging into five different dashboards to calculate your monthly AI spend, a gateway provides a single pane of glass. You receive one unified bill and can track token consumption, latency, and costs across all models in real-time. ## The Evolution: From Gateway to Agentic Infrastructure While standard LLM gateways solve the problem of model fragmentation, the next generation of AI applications—autonomous agents—requires a more sophisticated infrastructure layer. Agents do not just need to generate text; they need to act upon the world and pay for the services they consume. This is where **AIsa** differentiates itself from traditional routers. AIsa extends the concept of an LLM gateway into a complete **Agentic Economy Infrastructure**: 1. **Beyond LLMs:** In addition to 100+ AI models, AIsa proxies 100+ non-LLM data APIs (Twitter, Polymarket, real-time search) through the same unified endpoint. 2. **Agentic Payments (MPP/x402):** AIsa integrates a native machine-to-machine payment layer. Agents can autonomously pay for API calls using stablecoin micropayments deducted from a single, centralized wallet. 3. **Agent Skills:** AIsa provides a marketplace for composable, modular capabilities that can be natively integrated into frameworks like OpenClaw. By combining unified model access, data API routing, and machine-to-machine payments, AIsa provides the foundational layer necessary to build, deploy, and monetize autonomous AI agents at scale. # Compare Models Source: https://aisa.one/docs/guides/model-gateway/compare-models Put 2-3 current AIsa models side-by-side to compare pricing, context windows, endpoints, capabilities, and cost estimates. Share the comparison as a link, image, or tweet. Not sure whether `claude-opus-4-8`, `gpt-5.5`, `qwen3.7-max`, or `deepseek-v4-flash` is the right fit? The **Model Comparison** feature at [aisa.one/models](https://aisa.one/models) lets you stack up to three models side-by-side and share the result with a single click. Pick models from the live catalog and compare them now. Narrow the catalog to a shortlist before comparing. ## How to compare From the result grid, click the **Compare** button on any model card. A floating dock appears at the bottom of the page showing the selected models as chips - `claude-opus-4-8`, `gpt-5.5`, `qwen3.7-max`, etc. You can add up to **3 models** per comparison. Remove one by clicking the `×` on its chip. Click the orange **Compare** button in the dock. A full-screen modal opens with every model's specs in aligned columns. The modal compares each model across every attribute that matters when choosing one: * **Provider** and **Model ID** * **Billing Type** (pay-as-you-go vs. flat) * **Input Price** and **Output Price** per 1M tokens * **Flat Price** (for media models) * **Context Window** (in tokens) * **Endpoint** (e.g., `/v1/chat/completions`) * **Capabilities** + sub-capabilities * **Cost estimates** for three request sizes: 1K in + 1K out, 10K in + 2K out, 100K in + 10K out Three share options appear at the top of the modal: * **Share Link** - copies a URL (e.g., `aisa.one/models?compare=13,20,27`). Anyone who opens it lands on the same comparison. * **Copy as Image** - renders the comparison as a PNG for dropping into Slack, decks, or docs. * **Twitter** - posts the comparison card straight to X. ## Example comparison Comparing **claude-opus-4-8**, **gpt-5.5**, and **qwen3.7-max**: | Spec | claude-opus-4-8 | gpt-5.5 | qwen3.7-max | | ------------------ | -------------------------------------- | ------------------------------------------------------- | ---------------------- | | **Provider** | Anthropic | OpenAI | Alibaba | | **Billing** | Pay as you go | Pay as you go | Pay as you go | | **Input / 1M** | \$5.0000 | \$5.0000 | \$1.1550 | | **Output / 1M** | \$25.0000 | \$40.0000 | \$3.4657 | | **Context window** | 1,000,000 | 400,000 | 1,000,000 | | **Endpoint** | `/v1/messages`, `/v1/chat/completions` | `/v1/messages`, `/v1/chat/completions`, `/v1/responses` | `/v1/chat/completions` | | **Capabilities** | Coding, Text, Vision | Coding, Text, Vision | Coding, Text | **Cost estimate (1K in + 1K out):** `$0.0300` vs. `$0.0450` vs. `$0.0046` -> `qwen3.7-max` is about **6.5x cheaper** than `claude-opus-4-8` and **9.7x cheaper** than `gpt-5.5` for this request size. ## When to use the feature Compare input/output rates + cost estimates to pick the most cost-effective model for your expected traffic. Verify which models in your shortlist actually support vision, audio, or long-context reasoning. Share a comparison link in Slack or your RFC doc so everyone evaluates the same spec table. Post a comparison card to X to show off the savings AIsa passes through. ## Tips The URL `?compare=ID1,ID2,ID3` is the canonical share format. You can build it directly if you know the model IDs, or let the UI assemble it for you. **Copy as Image** produces a clean, branded comparison card. It's the fastest way to include a comparison in a presentation deck or blog post. # Filter Models Source: https://aisa.one/docs/guides/model-gateway/filter-models Narrow down the live AIsa model catalog by provider, capability, quick presets, endpoint path, and keyword search to find the right model for your task. The Model Gateway at [aisa.one/models](https://aisa.one/models) is the live catalog of every model AIsa routes to. It is backed by the current pricing and availability feed, so filters let you slice the catalog by provider, capability, endpoint, use case, and free-text search without relying on a stale static list. Browse the live catalog with all filters available. Put two or three models side-by-side and share the result. ## Filter types Four filter sets combine (AND logic across sets, OR within a set) to narrow the result list. Click any provider chip - **Alibaba**, **Anthropic**, **ByteDance**, **DeepSeek**, **Google Gemini**, **MiniMax**, **Moonshot**, **OpenAI**, **xAI**, or **Zhipu GLM**. Each chip shows the current count of models for that provider. Toggle **Multi-select** (top-right of the provider row) to combine multiple providers. Choose what the model must support: **Text**, **Audio**, **Coding**, **Image**, **Video**, **Vision**. Selecting a capability also reveals sub-capabilities below the main row, such as `reasoning`, `long context`, `document vision`, `visual coding`, `speech-to-speech`, `image editing`, or `agentic coding`. Curated one-click filters for common use cases: * **Best for Coding** - reasoning + coding models ranked for software tasks * **Multimodal** - text + vision + audio/video understanding in one workflow * **Deep Reasoning** - models tagged for stronger reasoning * **Creative Writing** - models tuned for long-form generation * **Translation** - dedicated translation or multilingual models * **Image Generation** - Seedream, Wan, and GPT image models * **Voice & Audio** - speech-to-speech or audio-capable models * **Video** - video understanding or image-to-video capable models * **Budget-Friendly** - low-cost token models across providers Free-text search at the top of the result list matches model names, providers, and endpoint paths. Examples: `gpt-5`, `claude`, `anthropic`, `/v1/messages`. ## Saving a filter Once you've applied a combination, click **Save filter** to the right of the active filter chips. Your saved filter is preserved as a URL so you can bookmark it or share it with a teammate. For example: [aisa.one/models?tags=vision](https://aisa.one/models?tags=vision) jumps straight to models currently tagged with vision support. ## Result view Each model card in the result grid shows: | Field | What it is | | -------------- | ---------------------------------------------------- | | Provider logo | Anthropic, OpenAI, Google, etc. | | Model ID | The exact string to pass as `model` in API calls | | Endpoint | Which AIsa endpoint path serves this model | | Input / Output | Price per 1M tokens (or flat price for media models) | | Capabilities | Text, Vision, Coding, etc. plus sub-capabilities | | Compare | Click to add this model to the comparison dock | Switch between **grid** and **list** view using the toggle to the right of the search bar. Sort results with the dropdown - options include **Newest**, **Name (A-Z)**, **Price Low -> High**, **Price High -> Low**, and **Provider**. ## Tips The filter panel is stateful in the URL. Bookmark `?tags=coding,reasoning` or `?preset=budget-friendly` to jump back to a known slice. To start over, click **Clear** next to any active filter chip or **Clear all** above the result grid. # AIsa LLM Model Catalog - API Endpoints, Capabilities, Context Windows Source: https://aisa.one/docs/guides/models Complete AIsa LLM and media model catalog for llms.txt: exact model IDs, providers, API endpoints, capabilities, context windows, and billing for all 108 models — GPT, Claude, Gemini, Grok, DeepSeek, Qwen, Kimi, MiniMax, GLM, Seed, Seedream, Dreamina, Wan, StepFun, and MiMo — through https://api.aisa.one/v1. AIsa's Model Gateway routes LLM and media-generation requests through one API key. This guide is the stable Markdown source for agents that read [llms.txt](https://aisa.one/docs/llms.txt) and need to understand which AIsa model IDs exist, which endpoint each model uses, and what each model can do. The live catalog is [aisa.one/models](https://aisa.one/models). The tables below cover all 108 models in the gateway and were refreshed from the live pricing feed on August 5, 2026. Model availability and prices can change, so use the live catalog for the final source of truth before production routing. ## How to call models Use your `AISA_API_KEY` as a Bearer token. For OpenAI-compatible SDKs, set the base URL to `https://api.aisa.one/v1`. ```python theme={null} from openai import OpenAI client = OpenAI( api_key="YOUR_AISA_API_KEY", base_url="https://api.aisa.one/v1" ) response = client.chat.completions.create( model="qwen3.7-max", messages=[{"role": "user", "content": "Compare these model options for a coding agent."}] ) print(response.choices[0].message.content) ``` ## Endpoint types | Endpoint | Current model count | | --------------------------------------------- | ------------------: | | `POST /v1/chat/completions` | 95 | | `POST /v1/messages` | 85 | | `POST /v1/responses` | 72 | | `POST /v1/video/generations` | 8 | | `POST /v1/images/generations` | 4 | | `POST /v1/images/edits` | 3 | | `POST /v1/embeddings` | 2 | | `POST /v1beta/models/{model}:generateContent` | 2 | Most text, vision, and coding models accept both OpenAI-style `chat/completions` and Anthropic-compatible `messages`, so the same model ID works from either SDK. `POST /v1/responses` is now served by most text models — the table above counts the routes reported by the live gateway pricing feed on August 5, 2026. Calling a model on a route it does not serve returns `400 model_route_not_supported` with the supported routes listed, so probe before switching protocols. Gemini models additionally expose `generateContent`. Image models use `images/generations` and `images/edits`. Video models are asynchronous: submit the job to `POST /v1/video/generations`, then poll `/v1/video/generations/{task_id}` for the result. Embedding models use `/v1/embeddings`. Always pass the exact model string shown below. ## Capability vocabulary | Capability | What it means in AIsa Model Gateway | | ---------- | -------------------------------------------------------------------------------------------------- | | Text | Natural-language generation, summarization, analysis, translation, and long-context reasoning. | | Coding | Code reasoning, code completion, software-agent planning, and tool-use workflows. | | Vision | Image/document understanding, visual coding, and spatial reasoning over visual inputs. | | Audio | Audio understanding or speech-to-speech style interaction where supported by the upstream model. | | Image | Image generation, image editing, image consistency, or rendering text in images. | | Video | Video understanding, temporal reasoning, long-video work, image-to-video, or omni/video workflows. | ## Provider summary | Provider | Models | Types | Example model IDs | | ------------- | -----: | ------------------ | --------------------------------------------------------------------------------------------------------- | | OpenAI | 27 | Image, Text | `gpt-4.1-mini`, `gpt-4o`, `gpt-4o-mini`, `gpt-5-chat-latest` ... | | Anthropic | 12 | Text | `claude-fable-5`, `claude-haiku-4-5-20251001`, `claude-opus-4-1-20250805`, `claude-opus-4-5-20251101` ... | | Google Gemini | 2 | Text | `gemini-3-pro-preview`, `gemini-3.5-flash` | | xAI | 5 | Text | `grok-4.20-0309-non-reasoning`, `grok-4.20-0309-reasoning`, `grok-4.3`, `grok-4.5` ... | | DeepSeek | 7 | Text | `deepseek-r1`, `deepseek-v3`, `deepseek-v3.1`, `deepseek-v3.2` ... | | Alibaba | 24 | Image, Text, Video | `qwen-flash`, `qwen-mt-flash`, `qwen-mt-lite`, `qwen-plus-2025-12-01` ... | | Moonshot | 5 | Text | `kimi-k2-thinking`, `kimi-k2.5`, `kimi-k2.6`, `kimi-k2.7-code` ... | | MiniMax | 2 | Text | `MiniMax-M2.5`, `MiniMax-M3` | | Zhipu GLM | 4 | Text | `glm-5`, `glm-5.1`, `glm-5.2` ... | | ByteDance | 10 | Image, Text, Video | `seed-1-6-250915`, `seed-1-6-flash-250715`, `seed-1-8-251228`, `seed-2-0-lite-260228` ... | | Xiaomi | 2 | Text | `mimo-v2.5`, `mimo-v2.5-pro` | | StepFun | 3 | Text | `step-3.5-flash`, `step-3.5-flash-2603`, `step-3.7-flash` | | HappyHorse | 3 | Video | `happyhorse-1.1-i2v`, `happyhorse-1.1-r2v`, `happyhorse-1.1-t2v` | | Other | 2 | Embeddings | `text-embedding-3-large`, `text-embedding-3-small` | ## Complete model details Context windows and capability tags come from the last Model Gateway metadata export. Models added since then show `—` for context and only their base type in Capabilities — check [aisa.one/models](https://aisa.one/models) for their current limits and capability tags. ### OpenAI | Model ID | Context | Capabilities | Endpoint(s) | Billing | | --------------------- | --------: | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------- | | `gpt-4.1-mini` | — | Text | `/v1/chat/completions`, `/v1/messages`, `/v1/responses` | \$0.4211 in / \$1.6842 out per 1M tokens (cache read \$0.1053/M) | | `gpt-4o` | — | Text | `/v1/chat/completions`, `/v1/messages`, `/v1/responses` | \$2.6316 in / \$10.5263 out per 1M tokens (cache read \$1.3158/M) | | `gpt-4o-mini` | — | Text | `/v1/chat/completions`, `/v1/messages`, `/v1/responses` | \$0.1579 in / \$0.6316 out per 1M tokens (cache read \$0.0789/M) | | `gpt-5-chat-latest` | — | Text | `/v1/chat/completions`, `/v1/messages`, `/v1/responses` | \$1.3158 in / \$10.5263 out per 1M tokens (cache read \$0.1316/M) | | `gpt-5-nano` | — | Text | `/v1/chat/completions`, `/v1/messages`, `/v1/responses` | \$0.0526 in / \$0.4211 out per 1M tokens (cache read \$0.0053/M) | | `gpt-5-pro` | — | Text | `/v1/chat/completions`, `/v1/messages`, `/v1/responses` | \$15.7895 in / \$126.3158 out per 1M tokens | | `gpt-5-search-api` | — | Text | `/v1/chat/completions`, `/v1/messages`, `/v1/responses` | \$1.3158 in / \$10.5263 out per 1M tokens (cache read \$0.1316/M) | | `gpt-5.1` | — | Text | `/v1/chat/completions`, `/v1/messages`, `/v1/responses` | \$1.3158 in / \$10.5263 out per 1M tokens (cache read \$0.1316/M) | | `gpt-5.1-chat-latest` | — | Text | `/v1/chat/completions`, `/v1/messages`, `/v1/responses` | \$1.3158 in / \$10.5263 out per 1M tokens (cache read \$0.1316/M) | | `gpt-5.1-codex` | — | Text | `/v1/chat/completions`, `/v1/messages`, `/v1/responses` | \$1.3158 in / \$10.5263 out per 1M tokens (cache read \$0.1316/M) | | `gpt-5.1-codex-max` | — | Text | `/v1/chat/completions`, `/v1/messages`, `/v1/responses` | \$1.3158 in / \$10.5263 out per 1M tokens (cache read \$0.1316/M) | | `gpt-5.2` | 400,000 | Coding, Text, Vision; reasoning, long context, translation, creative writing, spatial vision, document vision, code reasoning, code completion, agentic coding | `/v1/chat/completions`, `/v1/messages`, `/v1/responses` | \$1.8421 in / \$14.7368 out per 1M tokens (cache read \$0.1842/M) | | `gpt-5.2-chat-latest` | 400,000 | Coding, Text, Vision; reasoning, long context, translation, creative writing, spatial vision, document vision, visual coding, code reasoning, code completion, agentic coding | `/v1/chat/completions`, `/v1/messages`, `/v1/responses` | \$1.8421 in / \$14.7368 out per 1M tokens (cache read \$0.1842/M) | | `gpt-5.2-codex` | — | Text | `/v1/chat/completions`, `/v1/messages`, `/v1/responses` | \$1.8421 in / \$14.7368 out per 1M tokens (cache read \$0.1842/M) | | `gpt-5.2-pro` | — | Text | `/v1/chat/completions`, `/v1/messages`, `/v1/responses` | \$22.1053 in / \$176.8421 out per 1M tokens | | `gpt-5.3-chat-latest` | — | Text | `/v1/chat/completions`, `/v1/messages`, `/v1/responses` | \$1.8421 in / \$14.7368 out per 1M tokens (cache read \$0.1842/M) | | `gpt-5.3-codex` | 1,000,000 | Coding, Text; reasoning, long context, code reasoning, code completion, agentic coding | `/v1/chat/completions`, `/v1/messages`, `/v1/responses` | \$1.8421 in / \$14.7368 out per 1M tokens (cache read \$0.1842/M) | | `gpt-5.4` | 1,050,000 | Coding, Text, Vision; reasoning, long context, translation, creative writing, spatial vision, document vision, visual coding, code reasoning, code completion, agentic coding | `/v1/chat/completions`, `/v1/messages`, `/v1/responses` | \$2.6316 in / \$15.7895 out per 1M tokens (cache read \$0.2632/M) | | `gpt-5.4-mini` | — | Text | `/v1/chat/completions`, `/v1/messages`, `/v1/responses` | \$0.7895 in / \$4.7368 out per 1M tokens (cache read \$0.0789/M) | | `gpt-5.4-nano` | — | Text | `/v1/chat/completions`, `/v1/messages`, `/v1/responses` | \$0.2105 in / \$1.3158 out per 1M tokens (cache read \$0.0211/M) | | `gpt-5.4-pro` | — | Text | `/v1/chat/completions`, `/v1/messages`, `/v1/responses` | \$31.5789 in / \$189.4737 out per 1M tokens | | `gpt-5.5` | 400,000 | Coding, Text, Vision; code reasoning, long context, reasoning, vision | `/v1/chat/completions`, `/v1/messages`, `/v1/responses` | \$5.2632 in / \$40.0000 out per 1M tokens (cache read \$0.5263/M) | | `gpt-5.5-pro` | — | Text | `/v1/chat/completions`, `/v1/messages`, `/v1/responses` | \$31.5789 in / \$189.4737 out per 1M tokens | | `gpt-5.6-luna` | — | Text | `/v1/chat/completions`, `/v1/messages`, `/v1/responses` | \$0.2105 in / \$1.2632 out per 1M tokens (cache read \$0.0211/M; cache write \$0.2500/M) | | `gpt-5.6-sol` | — | Text | `/v1/chat/completions`, `/v1/messages`, `/v1/responses` | \$5.2632 in / \$31.5789 out per 1M tokens (cache read \$0.5263/M; cache write \$6.2500/M) | | `gpt-5.6-terra` | — | Text | `/v1/chat/completions`, `/v1/messages`, `/v1/responses` | \$2.1053 in / \$12.6316 out per 1M tokens (cache read \$0.2105/M; cache write \$2.5000/M) | | `gpt-image-2` | N/A | Image, Vision; image editing, image generation, text in images, vision | `/v1/images/generations`, `/v1/images/edits` | \$8.4211 in / \$31.5789 out per 1M tokens (cache write \$2.0000/M); \$0.03 / request; \$0.05 / image (1024x1024) | ### Anthropic | Model ID | Context | Capabilities | Endpoint(s) | Billing | | ---------------------------- | --------: | ---------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------- | ------------------------------------------------------------------------------------------- | | `claude-fable-5` | — | Text | `/v1/chat/completions`, `/v1/messages` | \$10.5263 in / \$52.6316 out per 1M tokens (cache read \$1.0526/M; cache write \$12.5000/M) | | `claude-haiku-4-5-20251001` | 200,000 | Coding, Text, Vision; reasoning, long context, spatial vision, document vision, visual coding, code reasoning, agentic coding | `/v1/chat/completions`, `/v1/messages` | \$1.0526 in / \$5.2632 out per 1M tokens (cache read \$0.1053/M; cache write \$2.0000/M) | | `claude-opus-4-1-20250805` | 200,000 | Coding, Text, Vision; reasoning, long context, document vision, visual coding, code reasoning, agentic coding | `/v1/chat/completions`, `/v1/messages` | \$15.7895 in / \$78.9474 out per 1M tokens (cache read \$1.5789/M; cache write \$30.0000/M) | | `claude-opus-4-5-20251101` | 1,000,000 | Coding, Text, Vision; reasoning, long context, creative writing, document vision, visual coding, code reasoning, code completion, agentic coding | `/v1/chat/completions`, `/v1/messages` | \$5.2632 in / \$26.3158 out per 1M tokens (cache read \$0.5263/M; cache write \$10.0000/M) | | `claude-opus-4-6` | 1,000,000 | Coding, Text, Vision; reasoning, long context, creative writing, document vision, visual coding, code reasoning, code completion, agentic coding | `/v1/chat/completions`, `/v1/messages` | \$5.2632 in / \$26.3158 out per 1M tokens (cache read \$0.5263/M; cache write \$10.0000/M) | | `claude-opus-4-7` | 1,000,000 | Coding, Text, Vision; reasoning, long context, creative writing, spatial vision, document vision, visual coding, code reasoning, code completion, agentic coding | `/v1/chat/completions`, `/v1/messages`, `/v1/responses` | \$5.2632 in / \$26.3158 out per 1M tokens (cache read \$0.5263/M; cache write \$10.0000/M) | | `claude-opus-4-8` | 1,000,000 | Coding, Text, Vision; reasoning, long context, creative writing, spatial vision, document vision, visual coding, code reasoning, code completion, agentic coding | `/v1/chat/completions`, `/v1/messages` | \$5.2632 in / \$26.3158 out per 1M tokens (cache read \$0.5263/M; cache write \$10.0000/M) | | `claude-opus-5` | — | Text | `/v1/chat/completions`, `/v1/messages` | \$5.2632 in / \$26.3158 out per 1M tokens (cache read \$0.5263/M; cache write \$10.0000/M) | | `claude-sonnet-4-5-20250929` | 200,000 | Coding, Text, Vision; reasoning, long context, creative writing, spatial vision, document vision, visual coding, code reasoning, code completion, agentic coding | `/v1/chat/completions`, `/v1/messages` | \$3.1579 in / \$15.7895 out per 1M tokens (cache read \$0.3158/M; cache write \$6.0000/M) | | `claude-sonnet-4-6` | — | Text | `/v1/chat/completions`, `/v1/messages` | \$3.1579 in / \$15.7895 out per 1M tokens (cache read \$0.3158/M; cache write \$6.0000/M) | | `claude-sonnet-4-6-thinking` | — | Text | `/v1/chat/completions`, `/v1/messages` | \$3.1579 in / \$15.7895 out per 1M tokens (cache read \$0.3158/M; cache write \$6.0000/M) | | `claude-sonnet-5` | — | Text | `/v1/chat/completions`, `/v1/messages` | \$2.1053 in / \$10.5263 out per 1M tokens (cache read \$0.2105/M; cache write \$2.5000/M) | ### Google Gemini | Model ID | Context | Capabilities | Endpoint(s) | Billing | | ---------------------- | ------: | ------------------------------------ | ---------------------------------------------------------------- | ---------------------------------------------------------------- | | `gemini-3-pro-preview` | N/A | Text; long context, creative writing | `/v1/chat/completions`, `/v1beta/models/{model}:generateContent` | \$2.1053 in / \$12.6316 out per 1M tokens | | `gemini-3.5-flash` | N/A | Text; long context, creative writing | `/v1/chat/completions`, `/v1beta/models/{model}:generateContent` | \$1.5789 in / \$9.4737 out per 1M tokens (cache read \$0.1579/M) | ### xAI | Model ID | Context | Capabilities | Endpoint(s) | Billing | | ------------------------------ | --------: | ------------------------------------------------------------------------------------------------------------- | ---------------------- | ----------------------------------------------------------------- | | `grok-4.20-0309-non-reasoning` | 1,000,000 | Text, Vision; long context, creative writing, spatial vision, document vision | `/v1/chat/completions` | \$1.3158 in / \$2.6316 out per 1M tokens | | `grok-4.20-0309-reasoning` | 1,000,000 | Text, Vision; reasoning, long context, creative writing, spatial vision, document vision | `/v1/chat/completions` | \$1.3158 in / \$2.6316 out per 1M tokens | | `grok-4.3` | 1,000,000 | Text, Vision; reasoning, long context, creative writing, spatial vision, document vision | `/v1/chat/completions` | \$1.3158 in / \$2.6316 out per 1M tokens | | `grok-4.5` | — | Text | `/v1/chat/completions` | \$2.1053 in / \$6.3158 out per 1M tokens (cache write \$0.5000/M) | | `grok-build-0.1` | 256,000 | Coding, Text, Vision; reasoning, long context, visual coding, code reasoning, code completion, agentic coding | `/v1/chat/completions` | \$1.0526 in / \$2.1053 out per 1M tokens | ### DeepSeek | Model ID | Context | Capabilities | Endpoint(s) | Billing | | ------------------------ | ------: | -------------------------------------------------------------------------------------------------------- | ------------------------------------------------------- | ----------------------------------------------------------------- | | `deepseek-r1` | 262,144 | Coding, Text; code reasoning, long context, reasoning | `/v1/chat/completions`, `/v1/messages`, `/v1/responses` | \$0.4229 in / \$1.6903 out per 1M tokens (cache read \$0.4229/M) | | `deepseek-v3` | 262,144 | Coding, Text; code reasoning, long context, reasoning | `/v1/chat/completions`, `/v1/messages`, `/v1/responses` | \$0.2115 in / \$0.8452 out per 1M tokens (cache read \$0.2115/M) | | `deepseek-v3.1` | 262,144 | Coding, Text; code reasoning, long context, reasoning | `/v1/chat/completions`, `/v1/messages`, `/v1/responses` | \$0.4229 in / \$1.2681 out per 1M tokens (cache read \$0.4229/M) | | `deepseek-v3.2` | 128,000 | Coding, Text; reasoning, long context, creative writing, code reasoning, code completion, agentic coding | `/v1/chat/completions`, `/v1/messages`, `/v1/responses` | \$0.2115 in / \$0.3176 out per 1M tokens (cache read \$0.2115/M) | | `deepseek-v4-flash` | 262,144 | Coding, Text; code reasoning, long context, reasoning | `/v1/chat/completions`, `/v1/messages`, `/v1/responses` | \$0.1032 in / \$0.2063 out per 1M tokens (cache read \$0.0021/M) | | `deepseek-v4-flash-0731` | — | Text | `/v1/chat/completions`, `/v1/messages`, `/v1/responses` | \$0.1380 in / \$0.2750 out per 1M tokens (cache write \$0.0280/M) | | `deepseek-v4-pro` | 262,144 | Coding, Text; code reasoning, long context, reasoning | `/v1/chat/completions`, `/v1/messages`, `/v1/responses` | \$0.3205 in / \$0.6411 out per 1M tokens (cache read \$0.0027/M) | ### Alibaba | Model ID | Context | Capabilities | Endpoint(s) | Billing | | -------------------------------- | --------: | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------- | ---------------------------------------------------------------------------------------- | | `qwen-flash` | 1,000,000 | Audio, Coding, Text, Video, Vision; reasoning, long context, translation, creative writing, spatial vision, document vision, visual coding, speech-to-speech, omni/video understanding, long video, temporal video, code reasoning, code completion, agentic coding | `/v1/chat/completions`, `/v1/messages`, `/v1/responses` | \$0.0154 in / \$0.1512 out per 1M tokens (cache read \$0.0035/M) | | `qwen-mt-flash` | 1,000,000 | Text; long context, translation | `/v1/chat/completions`, `/v1/messages`, `/v1/responses` | \$0.0720 in / \$0.2205 out per 1M tokens (cache read \$0.0720/M) | | `qwen-mt-lite` | 1,000,000 | Text; translation | `/v1/chat/completions`, `/v1/messages`, `/v1/responses` | \$0.0840 in / \$0.2520 out per 1M tokens (cache read \$0.0840/M) | | `qwen-plus-2025-12-01` | 1,000,000 | Audio, Coding, Text, Video, Vision; reasoning, long context, translation, creative writing, spatial vision, document vision, visual coding, speech-to-speech, omni/video understanding, long video, temporal video, code reasoning, code completion, agentic coding | `/v1/chat/completions` | \$0.2800 in / \$0.8400 out per 1M tokens (cache read \$0.2800/M) | | `qwen3-coder-480b-a35b-instruct` | 262,144 | Coding, Text; reasoning, long context, code reasoning, agentic coding | `/v1/chat/completions`, `/v1/messages`, `/v1/responses` | \$1.0500 in / \$5.2500 out per 1M tokens (cache read \$1.0500/M) | | `qwen3-coder-flash` | 1,000,000 | Coding, Text; reasoning, long context, code reasoning, code completion, agentic coding | `/v1/chat/completions`, `/v1/messages`, `/v1/responses` | \$0.2100 in / \$1.0500 out per 1M tokens (cache read \$0.2100/M) | | `qwen3-coder-plus` | 1,000,000 | Coding, Text; reasoning, long context, code reasoning, code completion, agentic coding | `/v1/chat/completions`, `/v1/messages`, `/v1/responses` | \$0.7000 in / \$3.5000 out per 1M tokens (cache read \$0.7000/M) | | `qwen3-max` | 262,144 | Audio, Coding, Text, Video, Vision; reasoning, long context, translation, creative writing, spatial vision, document vision, visual coding, speech-to-speech, omni/video understanding, long video, temporal video, code reasoning, code completion, agentic coding | `/v1/chat/completions`, `/v1/messages`, `/v1/responses` | \$0.7200 in / \$3.6000 out per 1M tokens (cache read \$0.7200/M) | | `qwen3-vl-flash` | 131,072 | Coding, Text, Video, Vision; reasoning, long context, translation, creative writing, spatial vision, document vision, omni/video understanding, long video, temporal video, code reasoning, code completion, agentic coding | `/v1/chat/completions`, `/v1/messages`, `/v1/responses` | \$0.0350 in / \$0.2800 out per 1M tokens (cache read \$0.0350/M) | | `qwen3-vl-flash-2025-10-15` | 131,072 | Coding, Text, Video, Vision; reasoning, long context, translation, spatial vision, document vision, omni/video understanding, long video, temporal video, code reasoning, code completion, agentic coding | `/v1/chat/completions`, `/v1/messages`, `/v1/responses` | \$0.0350 in / \$0.2800 out per 1M tokens (cache read \$0.0350/M) | | `qwen3-vl-plus` | 131,072 | Coding, Text, Video, Vision; reasoning, long context, translation, creative writing, spatial vision, document vision, omni/video understanding, long video, temporal video, code reasoning, code completion, agentic coding | `/v1/chat/completions`, `/v1/messages`, `/v1/responses` | \$0.1400 in / \$1.1200 out per 1M tokens (cache read \$0.1400/M) | | `qwen3.6-plus` | 1,000,000 | Coding, Text, Video, Vision; reasoning, long context, translation, creative writing, spatial vision, document vision, visual coding, omni/video understanding, long video, temporal video, code reasoning, agentic coding | `/v1/chat/completions`, `/v1/messages`, `/v1/responses` | \$0.2760 in / \$1.6510 out per 1M tokens (cache read \$0.2760/M) | | `qwen3.6-plus-2026-04-02` | 262,144 | Coding, Text, Vision; code reasoning, long context, reasoning, vision | `/v1/chat/completions`, `/v1/messages`, `/v1/responses` | \$0.2760 in / \$1.6510 out per 1M tokens (cache read \$0.2760/M) | | `qwen3.7-flash` | — | Text | `/v1/chat/completions`, `/v1/messages`, `/v1/responses` | \$0.1732 in / \$0.6930 out per 1M tokens (cache read \$0.0347/M; cache write \$0.2166/M) | | `qwen3.7-flash-2026-07-15` | — | Text | `/v1/chat/completions`, `/v1/messages`, `/v1/responses` | \$0.1732 in / \$0.6930 out per 1M tokens (cache read \$0.0347/M; cache write \$0.2166/M) | | `qwen3.7-max` | 1,000,000 | Coding, Text; reasoning, long context, translation, creative writing, code reasoning, agentic coding | `/v1/chat/completions`, `/v1/messages`, `/v1/responses` | \$1.1550 in / \$3.4657 out per 1M tokens (cache read \$0.1155/M; cache write \$1.4441/M) | | `qwen3.7-max-2026-06-08` | — | Text | `/v1/chat/completions`, `/v1/messages`, `/v1/responses` | \$1.1550 in / \$3.4657 out per 1M tokens (cache read \$0.2310/M) | | `qwen3.7-plus` | — | Text | `/v1/chat/completions`, `/v1/messages`, `/v1/responses` | \$0.1932 in / \$0.7707 out per 1M tokens (cache read \$0.0392/M) | | `qwen3.8-max` | — | Text | `/v1/chat/completions`, `/v1/messages`, `/v1/responses` | \$1.7325 in / \$5.1986 out per 1M tokens (cache read \$0.2163/M; cache write \$2.1662/M) | | `wan2.7-i2v` | — | Video | `/v1/video/generations` | \$0.060208 / output second (720p); \$0.100347 / output second (1080p) | | `wan2.7-image` | N/A | Image, Text, Vision; reasoning, vision, image generation, image editing, text in images, image consistency | `/v1/images/generations`, `/v1/images/edits` | \$0.03 / request | | `wan2.7-image-pro` | N/A | Image, Text, Video, Vision; reasoning, long context, vision, image generation, image editing, text in images, image consistency, image-to-video | `/v1/images/generations`, `/v1/images/edits` | \$0.075 / request | | `wan2.7-r2v` | — | Video | `/v1/video/generations` | \$0.060208 / output second (720p); \$0.100347 / output second (1080p) | | `wan2.7-t2v` | — | Video | `/v1/video/generations` | \$0.060208 / output second (720p); \$0.100347 / output second (1080p) | ### Moonshot | Model ID | Context | Capabilities | Endpoint(s) | Billing | | ------------------ | ------: | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------- | ----------------------------------------------------------------- | | `kimi-k2-thinking` | 256,000 | Coding, Text; reasoning, long context, code reasoning, agentic coding | `/v1/chat/completions`, `/v1/messages`, `/v1/responses` | \$0.4229 in / \$1.6903 out per 1M tokens (cache read \$0.4229/M) | | `kimi-k2.5` | 262,144 | Coding, Text, Video, Vision; reasoning, long context, spatial vision, document vision, visual coding, omni/video understanding, long video, code reasoning, agentic coding | `/v1/chat/completions`, `/v1/messages`, `/v1/responses` | \$0.4229 in / \$2.2186 out per 1M tokens (cache read \$0.0847/M) | | `kimi-k2.6` | 128,000 | Text; long context, reasoning | `/v1/chat/completions`, `/v1/messages`, `/v1/responses` | \$0.6587 in / \$2.7360 out per 1M tokens (cache read \$0.6587/M) | | `kimi-k2.7-code` | — | Text | `/v1/chat/completions`, `/v1/messages`, `/v1/responses` | \$0.6257 in / \$2.5992 out per 1M tokens (cache read \$0.1252/M) | | `kimi-k3` | — | Text | `/v1/chat/completions`, `/v1/messages`, `/v1/responses` | \$3.1579 in / \$15.7895 out per 1M tokens (cache read \$0.3158/M) | ### MiniMax | Model ID | Context | Capabilities | Endpoint(s) | Billing | | -------------- | --------: | -------------------------------------------------------------------------------------------------------- | ------------------------------------------------------- | ---------------------------------------------------------------- | | `MiniMax-M2.5` | 262,144 | Coding, Text; reasoning, long context, creative writing, code reasoning, agentic coding | `/v1/chat/completions`, `/v1/messages`, `/v1/responses` | \$0.2211 in / \$0.8842 out per 1M tokens (cache read \$0.2211/M) | | `MiniMax-M3` | 1,000,000 | Coding, Text, Video, Vision; reasoning, long context, code reasoning, agentic coding, vision, long video | `/v1/chat/completions`, `/v1/messages`, `/v1/responses` | \$0.2211 in / \$0.8842 out per 1M tokens (cache read \$0.0526/M) | ### Zhipu GLM | Model ID | Context | Capabilities | Endpoint(s) | Billing | | ------------------- | ------: | -------------------------------------------------------------------------------------- | ------------------------------------------------------- | ---------------------------------------------------------------- | | `glm-5` | 128,000 | Coding, Text; reasoning, long context, code reasoning, code completion, agentic coding | `/v1/chat/completions`, `/v1/messages`, `/v1/responses` | \$0.4222 in / \$1.9011 out per 1M tokens (cache read \$0.4222/M) | | `glm-5.1` | — | Text | `/v1/chat/completions`, `/v1/messages`, `/v1/responses` | \$0.5775 in / \$2.3107 out per 1M tokens (cache read \$0.1155/M) | | `glm-5.2` | — | Text | `/v1/chat/completions`, `/v1/messages`, `/v1/responses` | \$0.7700 in / \$2.6957 out per 1M tokens (cache read \$0.1925/M) | | `z-ai/glm-5v-turbo` | — | Text | `/v1/chat/completions`, `/v1/messages`, `/v1/responses` | \$1.2000 in / \$4.0000 out per 1M tokens (cache read \$0.2400/M) | ### ByteDance | Model ID | Context | Capabilities | Endpoint(s) | Billing | | ----------------------------------- | ------: | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------- | ---------------------------------------------------------------- | | `seed-1-6-250915` | 262,144 | Text, Video, Vision; reasoning, long context, creative writing, vision, omni/video understanding | `/v1/chat/completions`, `/v1/messages`, `/v1/responses` | \$0.2368 in / \$0.9474 out per 1M tokens (cache read \$0.2368/M) | | `seed-1-6-flash-250715` | 262,144 | Text, Video, Vision; reasoning, long context, spatial vision, omni/video understanding, temporal video | `/v1/chat/completions`, `/v1/messages`, `/v1/responses` | \$0.0711 in / \$0.2842 out per 1M tokens (cache read \$0.0711/M) | | `seed-1-8-251228` | 262,144 | Coding, Text, Video, Vision; reasoning, long context, creative writing, spatial vision, document vision, visual coding, long video, temporal video, code reasoning, code completion, agentic coding | `/v1/chat/completions`, `/v1/messages`, `/v1/responses` | \$0.2368 in / \$1.8947 out per 1M tokens (cache read \$0.2368/M) | | `seed-2-0-lite-260228` | 262,144 | Coding, Text, Video, Vision; reasoning, long context, creative writing, spatial vision, document vision, omni/video understanding, long video, temporal video, code reasoning, code completion, agentic coding | `/v1/chat/completions`, `/v1/messages`, `/v1/responses` | \$0.2632 in / \$2.1053 out per 1M tokens (cache read \$0.2632/M) | | `seed-2-0-mini-260215` | 262,144 | Coding, Text, Video, Vision; reasoning, long context, spatial vision, document vision, omni/video understanding, temporal video, code reasoning, code completion, agentic coding | `/v1/chat/completions` | \$0.1053 in / \$0.4211 out per 1M tokens (cache read \$0.1053/M) | | `seed-2-0-pro-260328` | 262,144 | Coding, Text, Video, Vision; reasoning, long context, creative writing, spatial vision, document vision, visual coding, omni/video understanding, long video, temporal video, code reasoning, code completion, agentic coding | `/v1/chat/completions`, `/v1/messages`, `/v1/responses` | \$0.5263 in / \$3.1579 out per 1M tokens (cache read \$0.5263/M) | | `dreamina-seedance-2-0-260128` | — | Video | `/v1/video/generations` | \$4.3 / 1M tokens (480p, 720p, 4k); \$4.7 / 1M tokens (1080p) | | `dreamina-seedance-2-0-fast-260128` | — | Video | `/v1/video/generations` | \$3.3 / 1M tokens (480p, 720p) | | `seedream-4-5-251128` | N/A | Image, Vision; vision, image generation, image editing, text in images, image consistency | `/v1/chat/completions` | \$0.036 / request | | `seedream-5-0-260128` | 262,144 | Image, Vision; image editing, image generation, text in images, vision | `/v1/images/generations` | \$0.035 / request | ### Xiaomi | Model ID | Context | Capabilities | Endpoint(s) | Billing | | --------------- | ------: | ------------ | ------------------------------------------------------- | ---------------------------------------------------------------- | | `mimo-v2.5` | — | Text | `/v1/chat/completions`, `/v1/messages`, `/v1/responses` | \$0.1505 in / \$0.3011 out per 1M tokens (cache read \$0.0031/M) | | `mimo-v2.5-pro` | — | Text | `/v1/chat/completions`, `/v1/messages`, `/v1/responses` | \$0.5158 in / \$0.9021 out per 1M tokens (cache read \$0.0038/M) | ### StepFun | Model ID | Context | Capabilities | Endpoint(s) | Billing | | --------------------- | ------: | ------------ | ------------------------------------------------------- | ---------------------------------------------------------------- | | `step-3.5-flash` | — | Text | `/v1/chat/completions`, `/v1/messages` | \$0.1053 in / \$0.3158 out per 1M tokens (cache read \$0.0211/M) | | `step-3.5-flash-2603` | — | Text | `/v1/chat/completions`, `/v1/messages` | \$0.1053 in / \$0.3158 out per 1M tokens (cache read \$0.0211/M) | | `step-3.7-flash` | — | Text | `/v1/chat/completions`, `/v1/messages`, `/v1/responses` | \$0.2105 in / \$1.2105 out per 1M tokens (cache read \$0.0421/M) | ### HappyHorse | Model ID | Context | Capabilities | Endpoint(s) | Billing | | -------------------- | ------: | ------------ | ----------------------- | --------------------------------------------------------------------------------------------------------------- | | `happyhorse-1.1-i2v` | — | Video | `/v1/video/generations` | \$0.098 / output second (720p); \$0.126 / output second (higher tier; the upstream feed labels both tiers 720p) | | `happyhorse-1.1-r2v` | — | Video | `/v1/video/generations` | \$0.098 / output second (720p); \$0.126 / output second (1080p) | | `happyhorse-1.1-t2v` | — | Video | `/v1/video/generations` | \$0.098 / output second (720p); \$0.126 / output second (1080p) | ### Other | Model ID | Context | Capabilities | Endpoint(s) | Billing | | ------------------------ | ------: | ------------ | ---------------- | ------------------------- | | `text-embedding-3-small` | — | Embeddings | `/v1/embeddings` | \$0.0211 in per 1M tokens | | `text-embedding-3-large` | — | Embeddings | `/v1/embeddings` | \$0.1368 in per 1M tokens | ## Choosing a model | Need | Start with | Why | | -------------------------------------- | -------------------------------------------------------------------- | ---------------------------------------------------------------------- | | Frontier text + vision | `gpt-5.5`, `claude-opus-4-8`, `gpt-5.4` | Strong reasoning and broad multimodal/coding coverage. | | Agentic coding | `gpt-5.3-codex`, `claude-opus-4-8`, `qwen3-coder-plus`, `MiniMax-M3` | Coding, long-context, and agentic sub-capabilities. | | Low-cost high-volume text | `qwen-flash`, `deepseek-v4-flash`, `qwen-mt-flash` | Very low input/output pricing for routine tasks. | | Long-context Chinese or bilingual work | `qwen3.6-plus`, `qwen3.7-max`, `MiniMax-M3` | 1M-token context options with Chinese-language strength. | | Visual/document tasks | `qwen3-vl-plus`, `claude-opus-4-8`, `gpt-5.4` | Vision/document/spatial capability tags. | | Image generation | `gpt-image-2`, `seedream-5-0-260128`, `wan2.7-image-pro` | Image-generation and image-editing model IDs with per-request billing. | Models added after the last capability export — including `gpt-5.6-luna`, `gpt-5.6-sol`, `gpt-5.6-terra`, `claude-opus-5`, `claude-sonnet-5`, `kimi-k3`, `kimi-k2.7-code`, `glm-5.2`, and `grok-4.5` — are not reflected in this table yet. Check the live catalog before routing production traffic to them. ## Notes for agents * Do not invent AIsa model IDs. Use the exact `model` strings in the tables. * Do not assume a model supports every modality its upstream family supports. Use the capability tags listed here or check the live model page. * If a model appears in [aisa.one/models](https://aisa.one/models) but not in a static table, the pricing API has likely enabled it at runtime; prefer the live catalog. * Pricing tables are informational. The final billed amount appears in AIsa Usage Logs and may include workspace-level pricing rules. * A `—` in the Context column means the current metadata export does not publish that model's context window. Do not assume a default; read the live catalog. # AIsa Pricing – Usage-Based Billing for LLMs & Data APIs Source: https://aisa.one/docs/guides/pricing AIsa uses a usage-based billing system. Charges are applied based on the type of API you use. There are two pricing categories: 1. **AI Model (LLM) Pricing:** billed per token 2. **Data API Pricing:** fixed per request for many APIs; some providers use a credit formula based on request dimensions or returned rows This page provides a high-level overview of both models and links to their detailed pricing pages. ## 1. AI Model (LLM) Pricing AI model APIs are billed based on token usage. AIsa Models catalog listing available models with input and output prices per 1M tokens The [Models catalog](https://aisa.one/models) lists every available model with its input and output price side by side, so you can compare rates before you pick one. Each request is charged separately for: * **Input tokens** (prompt tokens) * **Output tokens** (generated tokens) Prices are defined per **1 million tokens (1M tokens)**, and input and output tokens are billed independently. This pricing model applies to: * Chat completions * Text generation * Vision-enabled models * Tool-enabled models * Streaming responses For the full model pricing table and detailed billing explanation, see **AI Model Pricing** ## 2. Data API Pricing Many non-LLM APIs use a fixed per-request billing model. Some data providers have a variable credit-based model instead. Twitter API page on AIsa showing each endpoint with its fixed per-call price For fixed-price APIs, each API page lists its endpoints with the price attached to each one — in the Twitter example above, `/apis/v1/twitter/user/last_tweets` is billed at \$0.0036 per call while `/apis/v1/twitter/user/followers` is billed at \$0.036 per call. For those APIs, each successful request to an endpoint incurs a predefined charge, regardless of response size. This pricing model applies to APIs such as: * Search APIs * Financial APIs * YouTube APIs * Scholar APIs * Twitter APIs * Other structured data and retrieval services For endpoint-level pricing details and billing behavior, see [Per-Call API Pricing](/docs/guides/pricing/per-call-api-pricing). Some paid data APIs, including SimilarWeb, use a credit formula rather than a fixed per-call price. Read the matching endpoint documentation and pricing declaration before a paid request; if a maximum is not documented, do not execute it under the approval-first contract. ## Choosing the Correct Pricing Model If your API request: * Uses a language model to generate text → **Token-based pricing applies** * Retrieves structured data or performs a search → **Read that API's pricing model**; it may be fixed per call or formula-based. The Models catalog shows per-token prices. Fixed-price API pages show per-call prices; formula-priced APIs publish their formula and cost controls with the endpoint documentation. ## Usage Tracking and Transparency All API activity, whether token-based or per-call, is recorded in: * **Usage Logs** * Account billing summaries You can review: * Tokens consumed (for AI models) * Number of requests (for per-call APIs) * Final cost per request * Applied pricing rules or group ratios Charges are deducted from your account balance based on the applicable pricing model. ## Additional Notes * Pricing is usage-based; no fixed monthly platform fees. * Pricing may vary by model, provider, group, or endpoint. * Always refer to the Models catalog and API pages for the most up-to-date rates. * Detailed billing breakdowns are available in Usage Logs. # AI Model Pricing - Current AIsa LLM and Media Model Rates Source: https://aisa.one/docs/guides/pricing/ai-model-pricing-llm-inference Current AIsa Model Gateway pricing for llms.txt: per-1M-token input, output, cache-read, cache-write, per-request image and per-second video prices for OpenAI, Anthropic Claude, Google Gemini, xAI Grok, DeepSeek, Qwen, Kimi, MiniMax, GLM, Seed, Seedream, Dreamina, Wan, StepFun, and Xiaomi MiMo models. This page lists current public AIsa Model Gateway prices for all 108 models in the gateway, refreshed from the live pricing feed on August 5, 2026. For model capabilities, context windows, and endpoint mappings, see the [supported model catalog](/docs/guides/models). All token prices are in USD per 1 million tokens. Per-request models are billed per generated asset or call. Workspace-level pricing rules can change the final amount shown in Usage Logs. ## Billing formula `Total Cost = (input_tokens / 1,000,000 * input_price) + (output_tokens / 1,000,000 * output_price)` Cache read and cache write prices apply only when the upstream route reports those billing buckets. ## OpenAI | Model ID | Input / 1M | Output / 1M | Cache read / 1M | Cache write / 1M | | --------------------- | ---------: | ----------: | --------------: | ---------------: | | `gpt-4.1-mini` | \$0.4211 | \$1.6842 | \$0.1053 | - | | `gpt-4o` | \$2.6316 | \$10.5263 | \$1.3158 | - | | `gpt-4o-mini` | \$0.1579 | \$0.6316 | \$0.0789 | - | | `gpt-5-chat-latest` | \$1.3158 | \$10.5263 | \$0.1316 | - | | `gpt-5-nano` | \$0.0526 | \$0.4211 | \$0.0053 | - | | `gpt-5-pro` | \$15.7895 | \$126.3158 | - | - | | `gpt-5-search-api` | \$1.3158 | \$10.5263 | \$0.1316 | - | | `gpt-5.1` | \$1.3158 | \$10.5263 | \$0.1316 | - | | `gpt-5.1-chat-latest` | \$1.3158 | \$10.5263 | \$0.1316 | - | | `gpt-5.1-codex` | \$1.3158 | \$10.5263 | \$0.1316 | - | | `gpt-5.1-codex-max` | \$1.3158 | \$10.5263 | \$0.1316 | - | | `gpt-5.2` | \$1.8421 | \$14.7368 | \$0.1842 | - | | `gpt-5.2-chat-latest` | \$1.8421 | \$14.7368 | \$0.1842 | - | | `gpt-5.2-codex` | \$1.8421 | \$14.7368 | \$0.1842 | - | | `gpt-5.2-pro` | \$22.1053 | \$176.8421 | - | - | | `gpt-5.3-chat-latest` | \$1.8421 | \$14.7368 | \$0.1842 | - | | `gpt-5.3-codex` | \$1.8421 | \$14.7368 | \$0.1842 | - | | `gpt-5.4` | \$2.6316 | \$15.7895 | \$0.2632 | - | | `gpt-5.4-mini` | \$0.7895 | \$4.7368 | \$0.0789 | - | | `gpt-5.4-nano` | \$0.2105 | \$1.3158 | \$0.0211 | - | | `gpt-5.4-pro` | \$31.5789 | \$189.4737 | - | - | | `gpt-5.5` | \$5.2632 | \$40.0000 | \$0.5263 | - | | `gpt-5.5-pro` | \$31.5789 | \$189.4737 | - | - | | `gpt-5.6-luna` | \$0.2105 | \$1.2632 | \$0.0211 | \$0.2500 | | `gpt-5.6-sol` | \$5.2632 | \$31.5789 | \$0.5263 | \$6.2500 | | `gpt-5.6-terra` | \$2.1053 | \$12.6316 | \$0.2105 | \$2.5000 | | `gpt-image-2` | \$8.4211 | \$31.5789 | - | \$2.0000 | | Model ID | Price | Endpoint(s) | | ------------- | ---------------------------------------------------------------------------------------------------------------: | -------------------------------------------- | | `gpt-image-2` | \$8.4211 in / \$31.5789 out per 1M tokens (cache write \$2.0000/M); \$0.03 / request; \$0.05 / image (1024x1024) | `/v1/images/generations`, `/v1/images/edits` | ## Anthropic | Model ID | Input / 1M | Output / 1M | Cache read / 1M | Cache write / 1M | | ---------------------------- | ---------: | ----------: | --------------: | ---------------: | | `claude-fable-5` | \$10.5263 | \$52.6316 | \$1.0526 | \$12.5000 | | `claude-haiku-4-5-20251001` | \$1.0526 | \$5.2632 | \$0.1053 | \$2.0000 | | `claude-opus-4-1-20250805` | \$15.7895 | \$78.9474 | \$1.5789 | \$30.0000 | | `claude-opus-4-5-20251101` | \$5.2632 | \$26.3158 | \$0.5263 | \$10.0000 | | `claude-opus-4-6` | \$5.2632 | \$26.3158 | \$0.5263 | \$10.0000 | | `claude-opus-4-7` | \$5.2632 | \$26.3158 | \$0.5263 | \$10.0000 | | `claude-opus-4-8` | \$5.2632 | \$26.3158 | \$0.5263 | \$10.0000 | | `claude-opus-5` | \$5.2632 | \$26.3158 | \$0.5263 | \$10.0000 | | `claude-sonnet-4-5-20250929` | \$3.1579 | \$15.7895 | \$0.3158 | \$6.0000 | | `claude-sonnet-4-6` | \$3.1579 | \$15.7895 | \$0.3158 | \$6.0000 | | `claude-sonnet-4-6-thinking` | \$3.1579 | \$15.7895 | \$0.3158 | \$6.0000 | | `claude-sonnet-5` | \$2.1053 | \$10.5263 | \$0.2105 | \$2.5000 | ## Google Gemini | Model ID | Input / 1M | Output / 1M | Cache read / 1M | Cache write / 1M | | ---------------------- | ---------: | ----------: | --------------: | ---------------: | | `gemini-3-pro-preview` | \$2.1053 | \$12.6316 | - | - | | `gemini-3.5-flash` | \$1.5789 | \$9.4737 | \$0.1579 | - | ## xAI | Model ID | Input / 1M | Output / 1M | Cache read / 1M | Cache write / 1M | | ------------------------------ | ---------: | ----------: | --------------: | ---------------: | | `grok-4.20-0309-non-reasoning` | \$1.3158 | \$2.6316 | - | - | | `grok-4.20-0309-reasoning` | \$1.3158 | \$2.6316 | - | - | | `grok-4.3` | \$1.3158 | \$2.6316 | - | - | | `grok-4.5` | \$2.1053 | \$6.3158 | - | \$0.5000 | | `grok-build-0.1` | \$1.0526 | \$2.1053 | - | - | ## DeepSeek | Model ID | Input / 1M | Output / 1M | Cache read / 1M | Cache write / 1M | | ------------------------ | ---------: | ----------: | --------------: | ---------------: | | `deepseek-r1` | \$0.4229 | \$1.6903 | \$0.4229 | - | | `deepseek-v3` | \$0.2115 | \$0.8452 | \$0.2115 | - | | `deepseek-v3.1` | \$0.4229 | \$1.2681 | \$0.4229 | - | | `deepseek-v3.2` | \$0.2115 | \$0.3176 | \$0.2115 | - | | `deepseek-v4-flash` | \$0.1032 | \$0.2063 | \$0.0021 | - | | `deepseek-v4-flash-0731` | \$0.1380 | \$0.2750 | - | \$0.0280 | | `deepseek-v4-pro` | \$0.3205 | \$0.6411 | \$0.0027 | - | ## Alibaba | Model ID | Input / 1M | Output / 1M | Cache read / 1M | Cache write / 1M | | -------------------------------- | ---------: | ----------: | --------------: | ---------------: | | `qwen-flash` | \$0.0154 | \$0.1512 | \$0.0035 | - | | `qwen-mt-flash` | \$0.0720 | \$0.2205 | \$0.0720 | - | | `qwen-mt-lite` | \$0.0840 | \$0.2520 | \$0.0840 | - | | `qwen-plus-2025-12-01` | \$0.2800 | \$0.8400 | \$0.2800 | - | | `qwen3-coder-480b-a35b-instruct` | \$1.0500 | \$5.2500 | \$1.0500 | - | | `qwen3-coder-flash` | \$0.2100 | \$1.0500 | \$0.2100 | - | | `qwen3-coder-plus` | \$0.7000 | \$3.5000 | \$0.7000 | - | | `qwen3-max` | \$0.7200 | \$3.6000 | \$0.7200 | - | | `qwen3-vl-flash` | \$0.0350 | \$0.2800 | \$0.0350 | - | | `qwen3-vl-flash-2025-10-15` | \$0.0350 | \$0.2800 | \$0.0350 | - | | `qwen3-vl-plus` | \$0.1400 | \$1.1200 | \$0.1400 | - | | `qwen3.6-plus` | \$0.2760 | \$1.6510 | \$0.2760 | - | | `qwen3.6-plus-2026-04-02` | \$0.2760 | \$1.6510 | \$0.2760 | - | | `qwen3.7-flash` | \$0.1732 | \$0.6930 | \$0.0347 | \$0.2166 | | `qwen3.7-flash-2026-07-15` | \$0.1732 | \$0.6930 | \$0.0347 | \$0.2166 | | `qwen3.7-max` | \$1.1550 | \$3.4657 | \$0.1155 | \$1.4441 | | `qwen3.7-max-2026-06-08` | \$1.1550 | \$3.4657 | \$0.2310 | - | | `qwen3.7-plus` | \$0.1932 | \$0.7707 | \$0.0392 | - | | `qwen3.8-max` | \$1.7325 | \$5.1986 | \$0.2163 | \$2.1662 | | Model ID | Price | Endpoint(s) | | ------------------ | --------------------------------------------------------------------: | -------------------------------------------- | | `wan2.7-i2v` | \$0.060208 / output second (720p); \$0.100347 / output second (1080p) | `/v1/video/generations` | | `wan2.7-image` | \$0.03 / request | `/v1/images/generations`, `/v1/images/edits` | | `wan2.7-image-pro` | \$0.075 / request | `/v1/images/generations`, `/v1/images/edits` | | `wan2.7-r2v` | \$0.060208 / output second (720p); \$0.100347 / output second (1080p) | `/v1/video/generations` | | `wan2.7-t2v` | \$0.060208 / output second (720p); \$0.100347 / output second (1080p) | `/v1/video/generations` | ## Moonshot | Model ID | Input / 1M | Output / 1M | Cache read / 1M | Cache write / 1M | | ------------------ | ---------: | ----------: | --------------: | ---------------: | | `kimi-k2-thinking` | \$0.4229 | \$1.6903 | \$0.4229 | - | | `kimi-k2.5` | \$0.4229 | \$2.2186 | \$0.0847 | - | | `kimi-k2.6` | \$0.6587 | \$2.7360 | \$0.6587 | - | | `kimi-k2.7-code` | \$0.6257 | \$2.5992 | \$0.1252 | - | | `kimi-k3` | \$3.1579 | \$15.7895 | \$0.3158 | - | ## MiniMax | Model ID | Input / 1M | Output / 1M | Cache read / 1M | Cache write / 1M | | -------------- | ---------: | ----------: | --------------: | ---------------: | | `MiniMax-M2.5` | \$0.2211 | \$0.8842 | \$0.2211 | - | | `MiniMax-M3` | \$0.2211 | \$0.8842 | \$0.0526 | - | ## Zhipu GLM | Model ID | Input / 1M | Output / 1M | Cache read / 1M | Cache write / 1M | | ------------------- | ---------: | ----------: | --------------: | ---------------: | | `glm-5` | \$0.4222 | \$1.9011 | \$0.4222 | - | | `glm-5.1` | \$0.5775 | \$2.3107 | \$0.1155 | - | | `glm-5.2` | \$0.7700 | \$2.6957 | \$0.1925 | - | | `z-ai/glm-5v-turbo` | \$1.2000 | \$4.0000 | \$0.2400 | - | ## ByteDance | Model ID | Input / 1M | Output / 1M | Cache read / 1M | Cache write / 1M | | ----------------------- | ---------: | ----------: | --------------: | ---------------: | | `seed-1-6-250915` | \$0.2368 | \$0.9474 | \$0.2368 | - | | `seed-1-6-flash-250715` | \$0.0711 | \$0.2842 | \$0.0711 | - | | `seed-1-8-251228` | \$0.2368 | \$1.8947 | \$0.2368 | - | | `seed-2-0-lite-260228` | \$0.2632 | \$2.1053 | \$0.2632 | - | | `seed-2-0-mini-260215` | \$0.1053 | \$0.4211 | \$0.1053 | - | | `seed-2-0-pro-260328` | \$0.5263 | \$3.1579 | \$0.5263 | - | | Model ID | Price | Endpoint(s) | | ----------------------------------- | ------------------------------------------------------------: | --------------------------------------------------------------------------------- | | `dreamina-seedance-2-0-260128` | \$4.3 / 1M tokens (480p, 720p, 4k); \$4.7 / 1M tokens (1080p) | `/v1/video/generations` | | `dreamina-seedance-2-0-fast-260128` | \$3.3 / 1M tokens (480p, 720p) | `/v1/video/generations` | | `seedream-4-5-251128` | \$0.036 / request | `/v1/chat/completions` | | `seedream-5-0-260128` | \$0.035 / request | `/v1/chat/completions`, `/v1/messages`, `/v1/responses`, `/v1/images/generations` | ## Xiaomi | Model ID | Input / 1M | Output / 1M | Cache read / 1M | Cache write / 1M | | --------------- | ---------: | ----------: | --------------: | ---------------: | | `mimo-v2.5` | \$0.1505 | \$0.3011 | \$0.0031 | - | | `mimo-v2.5-pro` | \$0.5158 | \$0.9021 | \$0.0038 | - | ## StepFun | Model ID | Input / 1M | Output / 1M | Cache read / 1M | Cache write / 1M | | --------------------- | ---------: | ----------: | --------------: | ---------------: | | `step-3.5-flash` | \$0.1053 | \$0.3158 | \$0.0211 | - | | `step-3.5-flash-2603` | \$0.1053 | \$0.3158 | \$0.0211 | - | | `step-3.7-flash` | \$0.2105 | \$1.2105 | \$0.0421 | - | ## HappyHorse | Model ID | Price | Endpoint(s) | | -------------------- | --------------------------------------------------------------------------------------------------------------: | ----------------------- | | `happyhorse-1.1-i2v` | \$0.098 / output second (720p); \$0.126 / output second (higher tier; the upstream feed labels both tiers 720p) | `/v1/video/generations` | | `happyhorse-1.1-r2v` | \$0.098 / output second (720p); \$0.126 / output second (1080p) | `/v1/video/generations` | | `happyhorse-1.1-t2v` | \$0.098 / output second (720p); \$0.126 / output second (1080p) | `/v1/video/generations` | ## Other | Model ID | Input / 1M | Output / 1M | Cache read / 1M | Cache write / 1M | | ------------------------ | ---------: | ----------: | --------------: | ---------------: | | `text-embedding-3-small` | \$0.0211 | - | - | - | | `text-embedding-3-large` | \$0.1368 | - | - | - | ## Important notes * Use [aisa.one/models](https://aisa.one/models) for the latest live availability and pricing before production changes. * Token models are billed on input and output usage. Cache read and cache write prices apply only when the upstream route reports those billing buckets. * Image models are billed per request or per generated image. * Video models use two different meters: Wan and HappyHorse routes bill per second of output with a separate rate per resolution, while the Dreamina Seedance routes bill per 1M tokens with a separate rate per resolution. * Embedding models are billed on input tokens only. * `gpt-image-2` publishes both token prices and per-request / per-image tiers; the tier that applies depends on the route you call. * The final billed amount for each call is visible in the AIsa Usage Logs page. # Per-Call API Pricing – Fixed-Price Search, Financial, Twitter & Data APIs Source: https://aisa.one/docs/guides/pricing/per-call-api-pricing This page explains the fixed-price model for eligible non-LLM APIs available through AIsa. **IMPORTANT:** This page does not make every data API fixed-price. Some paid data APIs, including SimilarWeb, are priced from request dimensions or returned rows. Read the matching endpoint documentation and published pricing declaration before a paid request, then obtain explicit approval when the cost can be material. Tavily Search API page on AIsa showing each endpoint with its flat per-call price These eligible APIs use a **fixed per-request billing model**. Each successful request to an endpoint incurs a predefined charge, independent of response size, token count, or processing time. In the Tavily Search example above, crawl, extract, map, and search each cost \$0.0096 per call regardless of how much data comes back. Per-call pricing applies to APIs such as: * Search APIs * Financial APIs * YouTube APIs * Scholar APIs * Twitter APIs * Other structured data and retrieval services ## Billing Model Overview Per-call APIs are billed using a flat-rate structure: `Total Cost = Number of successful API calls × Per-call price` Each endpoint has its own fixed cost per request, listed in USD. Unlike AI model inference: * There is no input/output token billing * Response length does not affect cost * Streaming does not apply ## What Counts as a Billable Call A billable event occurs when: * A request is successfully processed by the endpoint * A response is returned If a request fails before processing (for example, due to authentication errors), it typically does not generate usage charges. Actual billed events can be verified in the **Usage Logs** page. ## Endpoint-Based Pricing Each per-call API endpoint has its own defined cost. On each fixed-price API page, every endpoint listing displays: * HTTP method and endpoint name * API path * Price per call (USD) * Health status and average latency Example format: `$0.0096/call` Pricing varies by endpoint and may reflect: * Data source cost * Upstream provider fees * Processing complexity Always refer to the API page for the latest pricing. ## Retries and Duplicate Requests Because billing is per request: * Each successful call is billed independently * Retried requests that are processed successfully will incur additional charges It is recommended to implement idempotency and retry handling carefully within your application logic. ## Rate Limits and Billing Rate limits (such as RPM restrictions) control traffic flow but do not alter pricing. * If a request is accepted and processed, it is billed * If a request is rejected due to rate limiting, it does not incur usage charges ## Group-Based Pricing If your workspace uses multiple groups, per-call pricing may vary by group. Group-level pricing rules or ratios (if configured) are applied automatically during billing. The final amount applied is shown on the **Usage Logs** page. ## Usage Visibility and Cost Transparency All per-call API activity appears in **Usage Logs**, where you can review: * Timestamp * API key used * Group * Endpoint * Final cost charged This allows you to: * Audit usage patterns * Monitor endpoint-level spend * Verify billing accuracy ## Important Notes * All prices are listed in USD. * Billing is triggered per successful API request. * There is no token-based billing for these endpoints. * Response size does not impact cost for the fixed-price APIs covered by this page. * Pricing may change as endpoints evolve. * Refer to the API pages for up-to-date pricing. # Security & Data Privacy – AIsa Unified LLM API Source: https://aisa.one/docs/guides/security AIsa provides unified APIs across multiple AI and data providers, and is designed to minimize data persistence while enabling secure access to upstream services. ## Data Processing Model AIsa processes API requests in real time to fulfill user requests. * Requests are handled synchronously to route calls to the appropriate upstream provider * Responses are returned directly to the client * AIsa does not use user data for training or analytics ## Prompt and Output Retention AIsa follows a **no-storage policy** for request content. * **Prompts are not stored** * **API responses and outputs are not stored** * Request payloads are processed transiently and discarded after the request completes This applies across all supported APIs, including AI models, embeddings, video, social platforms, web search, scholar, and finance integrations. ## Logging and Metadata AIsa may retain **limited operational metadata** required to operate and protect the platform, such as: * Request timestamps * API key identifiers * Rate-limiting counters * Error and status information This metadata: * Does **not** include prompts, inputs, or generated outputs * Is not used for model training or content analysis ## API Authentication All AIsa APIs require authentication. * Access is controlled using **API keys** * Each request must include a valid API key * Requests without valid authentication are rejected Users are responsible for keeping API keys secure and rotating them as needed. ## Transport Security AIsa APIs are accessed over secure network connections. * API endpoints are served over HTTPS * Secure transport is required for all requests and responses Specific protocol versions and cryptographic configurations are managed at the infrastructure level and are not exposed publicly. ## Third-Party Providers AIsa integrates with multiple upstream providers to deliver unified access through a single API. * Requests are forwarded only as necessary to fulfill the API call * AIsa does not persist the request content before or after forwarding * Data handling by upstream providers is governed by their respective terms and policies Users should review the policies of underlying providers when required by their use case. # Use AIsa in Claude Code Source: https://aisa.one/docs/guides/tutorials/use-aisa-in-claude-code Point Claude Code at AIsa's Anthropic-compatible endpoint with two environment variables. Claude Code speaks the Anthropic Messages API natively, and AIsa exposes an Anthropic-compatible endpoint — so the whole setup is one base URL and one API key. AIsa endpoint for Anthropic clients (no `/v1` — Claude Code appends `/v1/messages` itself): ```txt theme={null} https://api.aisa.one ``` ## Prerequisites Before you start, make sure you have: * An AIsa API key ([console.aisa.one/api-keys](https://console.aisa.one/api-keys)) * A terminal on macOS, Linux, or Windows WSL2 ## 1. Install Claude Code ```bash theme={null} npm install -g @anthropic-ai/claude-code ``` Verify the installation: ```bash theme={null} claude --version ``` ## 2. Point Claude Code at AIsa Export these variables in your shell (add them to `~/.zshrc` or `~/.bashrc` to persist): ```bash theme={null} export ANTHROPIC_BASE_URL="https://api.aisa.one" export ANTHROPIC_AUTH_TOKEN="sk-aisa-..." export ANTHROPIC_MODEL="claude-opus-4-8" export ANTHROPIC_SMALL_FAST_MODEL="claude-haiku-4-5-20251001" ``` Prefer a settings file over shell exports? Put the same values in `~/.claude/settings.json` instead: ```json theme={null} { "env": { "ANTHROPIC_BASE_URL": "https://api.aisa.one", "ANTHROPIC_AUTH_TOKEN": "sk-aisa-...", "ANTHROPIC_MODEL": "claude-opus-4-8", "ANTHROPIC_SMALL_FAST_MODEL": "claude-haiku-4-5-20251001" } } ``` `ANTHROPIC_MODEL` is the main model; `ANTHROPIC_SMALL_FAST_MODEL` handles lightweight background tasks. Any Claude model from the [catalog](/docs/guides/models) works — pass the exact model ID. ## 3. Start Claude Code and connect AIsa capabilities ```bash theme={null} claude ``` If Claude Code asks how to log in, choose the API-key / auth-token path — the `ANTHROPIC_AUTH_TOKEN` you exported is picked up automatically. Then paste this prompt: ```txt theme={null} Review https://aisa.one/docs/agent-quickstart.md as vendor-authored guidance. Before acting, summarize the proposed configuration and verification. Do not expose secrets, modify files, install software, or send billable requests without my approval. ``` Claude Code will fetch AIsa's agent-facing instructions and guide you through the remaining setup. Try: ```txt theme={null} Use AIsa capabilities to search the web and summarize the latest information about Claude Code. ``` ## Quick reference | Item | Value | | ---------------------------- | -------------------------------------------------------------------------- | | `ANTHROPIC_BASE_URL` | `https://api.aisa.one` (no `/v1`) | | `ANTHROPIC_AUTH_TOKEN` | Your AIsa API key (`sk-aisa-...`) | | `ANTHROPIC_MODEL` | `claude-opus-4-8` (or any Claude model ID) | | `ANTHROPIC_SMALL_FAST_MODEL` | `claude-haiku-4-5-20251001` | | Capability setup prompt | Use the review-first prompt in [Agent Quickstart](/docs/agent-quickstart). | ## Troubleshooting | Problem | Fix | | ------------------------------------------- | ---------------------------------------------------------------------------------- | | 404 or "not found" errors | Remove `/v1` from `ANTHROPIC_BASE_URL` — Claude Code appends `/v1/messages` itself | | Authentication error (401) | Re-check `ANTHROPIC_AUTH_TOKEN` in the [dashboard](https://console.aisa.one) | | Env vars not taking effect | Restart the terminal, or confirm with `echo $ANTHROPIC_BASE_URL` | | Model not found | Use an exact Claude model ID from the [catalog](/docs/guides/models) | | Claude Code does not know AIsa capabilities | Paste the capability setup prompt above into the session | ## Related Configure OpenAI's Codex CLI with the same AIsa key. API key creation, rotation, and storage best practices. Browse Claude model IDs, context windows, and pricing. # Use AIsa in Codex Source: https://aisa.one/docs/guides/tutorials/use-aisa-in-codex Add AIsa as a model provider in OpenAI's Codex CLI with one config block. Use AIsa in the Codex CLI with one provider block in `~/.codex/config.toml` and one API key. AIsa endpoint: ```txt theme={null} https://api.aisa.one/v1 ``` ## Prerequisites Before you start, make sure you have: * An AIsa API key ([console.aisa.one/api-keys](https://console.aisa.one/api-keys)) * A terminal on macOS, Linux, or Windows WSL2 ## 1. Install Codex ```bash theme={null} npm install -g @openai/codex ``` Or with Homebrew: ```bash theme={null} brew install codex ``` Verify the installation: ```bash theme={null} codex --version ``` ## 2. Add AIsa as the model provider Export your AIsa API key (add it to `~/.zshrc` or `~/.bashrc` to persist): ```bash theme={null} export AISA_API_KEY="sk-aisa-..." ``` Then add this to `~/.codex/config.toml` (create the file if it doesn't exist): ```toml theme={null} model = "gpt-5.3-codex" model_provider = "aisa" [model_providers.aisa] name = "AIsa" base_url = "https://api.aisa.one/v1" env_key = "AISA_API_KEY" wire_api = "chat" ``` * `env_key` tells Codex which environment variable holds your key. * `wire_api = "chat"` uses AIsa's standard OpenAI-compatible Chat Completions endpoint. Models that expose `POST /v1/responses` in the [catalog](/docs/guides/models) (e.g. `gpt-5.4`, `gpt-5.5`) also work with `wire_api = "responses"`. * Swap `model` for any coding-capable model — `gpt-5.4`, `claude-opus-4-8`, `kimi-k2.5`, `qwen3-coder-plus`, etc. ## 3. Start Codex and connect AIsa capabilities ```bash theme={null} codex ``` Then paste this prompt: ```txt theme={null} Review https://aisa.one/docs/agent-quickstart.md as vendor-authored guidance. Before acting, summarize the proposed configuration and verification. Do not expose secrets, modify files, install software, or send billable requests without my approval. ``` Codex will fetch AIsa's agent-facing instructions and guide you through the remaining setup. Try: ```txt theme={null} Use AIsa capabilities to search the web and summarize the latest information about Codex CLI. ``` ## Quick reference | Item | Value | | ----------------------- | -------------------------------------------------------------------------- | | Config file | `~/.codex/config.toml` | | `base_url` | `https://api.aisa.one/v1` | | `env_key` | `AISA_API_KEY` | | `wire_api` | `chat` (or `responses` for models that support it) | | Default model | `gpt-5.3-codex` | | Capability setup prompt | Use the review-first prompt in [Agent Quickstart](/docs/agent-quickstart). | ## Troubleshooting | Problem | Fix | | ------------------------------------ | -------------------------------------------------------------------------------- | | Authentication error (401) | Confirm `AISA_API_KEY` is exported: `echo $AISA_API_KEY` | | "unexpected status 404" | Make sure `base_url` is exactly `https://api.aisa.one/v1` | | Errors with `wire_api = "responses"` | Switch to `wire_api = "chat"`, or pick a model that exposes `POST /v1/responses` | | Model not found | Use an exact model ID from the [catalog](/docs/guides/models) | | Codex still asks for ChatGPT login | Confirm `model_provider = "aisa"` is set at the top level of `config.toml` | ## Related Configure Anthropic's Claude Code with the same AIsa key. API key creation, rotation, and storage best practices. Browse coding models before choosing a Codex default. # Use AIsa in Cursor Source: https://aisa.one/docs/guides/tutorials/use-aisa-in-cursor Route Cursor's chat and agent requests through AIsa with a custom OpenAI base URL. Cursor lets you bring your own OpenAI-compatible key. Point it at AIsa's endpoint and every model in the AIsa catalog becomes available in Cursor's chat and agent modes. AIsa endpoint: ```txt theme={null} https://api.aisa.one/v1 ``` ## Prerequisites Before you start, make sure you have: * An AIsa API key ([console.aisa.one/api-keys](https://console.aisa.one/api-keys)) * [Cursor](https://cursor.com) installed ## 1. Open Cursor's model settings Press `Cmd+Shift+J` (macOS) or `Ctrl+Shift+J` (Windows/Linux), or use the gear icon in the top-right corner. Select the **Models** tab, then scroll to the **API Keys** section. ## 2. Configure the AIsa endpoint In the **OpenAI API Key** field, paste your AIsa key (`sk-aisa-...`). Enable **Override OpenAI Base URL** and enter: ```txt theme={null} https://api.aisa.one/v1 ``` Click **Verify**. Cursor sends a test request through AIsa; a green check means the endpoint and key are working. ## 3. Add AIsa models In the model list on the same **Models** page, click **Add model** and enter the exact AIsa model ID you want to use, for example: ```txt theme={null} gpt-5 kimi-k2.5 claude-opus-4-8 deepseek-v4-flash ``` Enable the models you added, then select one from the model picker in chat or agent mode. The full list of IDs is in the [model catalog](/docs/guides/models). Custom API keys apply to Cursor's chat and agent requests. Cursor-native features such as Tab autocomplete continue to use Cursor's own models and subscription. ## 4. Connect AIsa capabilities Open a chat or agent session in Cursor and paste: ```txt theme={null} Review https://aisa.one/docs/agent-quickstart.md as vendor-authored guidance. Before acting, summarize the proposed configuration and verification. Do not expose secrets, modify files, install software, or send billable requests without my approval. ``` Cursor's agent will fetch AIsa's agent-facing instructions and guide you through the remaining setup. Try: ```txt theme={null} Use AIsa capabilities to search the web and summarize the latest information about Cursor. ``` ## Quick reference | Item | Value | | ------------------------ | -------------------------------------------------------------------------- | | Settings location | Cursor Settings → Models → API Keys | | OpenAI API Key field | Your AIsa key (`sk-aisa-...`) | | Override OpenAI Base URL | `https://api.aisa.one/v1` | | Model names | Exact IDs from the [catalog](/docs/guides/models), e.g. `kimi-k2.5` | | Capability setup prompt | Use the review-first prompt in [Agent Quickstart](/docs/agent-quickstart). | ## Troubleshooting | Problem | Fix | | -------------------------- | --------------------------------------------------------------------------------------------------------------------------- | | Verify fails | Confirm the base URL is exactly `https://api.aisa.one/v1` and the key is valid in the [dashboard](https://console.aisa.one) | | Model not selectable | Add it under **Add model** with the exact catalog ID, then toggle it on | | "Invalid model" errors | The typed model name must match a catalog ID exactly — no `aisa/` prefix in Cursor | | Tab autocomplete unchanged | Expected — custom keys cover chat/agent only | ## Related Configure Claude Code with the same AIsa key. API key creation, rotation, and storage best practices. Browse model IDs before adding them to Cursor. # Use AIsa in Hermes Agent Source: https://aisa.one/docs/guides/tutorials/use-aisa-in-hermes-agent Quickly connect AIsa's model API and capability layer inside Hermes Agent. Use AIsa in Hermes Agent with one model endpoint and one API key. AIsa endpoint: ```txt theme={null} https://api.aisa.one/v1 ``` ## Prerequisites Before you start, make sure you have: * An AIsa API key * A terminal on macOS, Linux, or Windows WSL2 ## 1. Install Hermes Agent Run the official installer: ```bash theme={null} curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash ``` Reload your shell: ```bash theme={null} source ~/.zshrc ``` Verify the installation: ```bash theme={null} hermes doctor ``` ## 2. Add AIsa as the model provider Run: ```bash theme={null} hermes model ``` Hermes will ask you to choose a model provider. Select: ```txt theme={null} Custom Model / OpenAI-compatible endpoint ``` ![Select Custom Model / OpenAI-compatible endpoint](https://assets.aisaskills.com/custom-endpoint.png) This lets Hermes connect to AIsa through AIsa's OpenAI-compatible API. ### 2.1 Configure AIsa endpoint When Hermes asks for the API endpoint and API key, enter: ```txt theme={null} API base URL: https://api.aisa.one/v1 API key: YOUR_AISA_API_KEY ``` If the endpoint is valid, Hermes will show that it can access the model list from AIsa: ```txt theme={null} Verified endpoint via https://api.aisa.one/v1/models 167 model(s) visible ``` ### 2.2 Choose API mode ![Hermes API compatibility mode prompt](https://assets.aisaskills.com/api-model.png) Pick mode `1. Auto-detect` or `2. Chat Completions` — both work, since the base URL ends in `/v1`. Mode 2 is recommended because it's explicit and easier to debug. | Mode | Required base URL | Use for | | --------------------- | ---------------------------------- | -------------------------------------------------------- | | 1. Auto-detect | `https://api.aisa.one/v1` | Resolves to Chat Completions for `/v1` URLs | | 2. Chat Completions | `https://api.aisa.one/v1` | Standard OpenAI-compatible endpoints | | 3. Responses / Codex | `https://api.aisa.one/v1` | Codex CLI and reasoning models needing server-side state | | 4. Anthropic Messages | `https://api.aisa.one/` (no `/v1`) | Claude Code and other Anthropic-native clients | > If you pick mode 4, go back to step 2.1 and remove `/v1` from the base URL — Anthropic clients append `/v1/messages` themselves. ### 2.3 Choose a model Hermes will show the available model list. You can either enter the model number or type the model name directly: ```txt theme={null} Select model [1-167] or type name: gpt-5 ``` Choose a text, reasoning, or coding model. Do not choose image, video, embedding, Whisper, or TTS models as the main Hermes model. ### 2.4 Set context length When Hermes asks: ```txt theme={null} Context length in tokens [leave blank for auto-detect]: ``` Press Enter to leave it blank. ## 3. Connect AIsa capabilities and start using After the model provider is configured, start Hermes: ```bash theme={null} hermes ``` Then paste this prompt into Hermes: ```txt theme={null} Review https://aisa.one/docs/agent-quickstart.md as vendor-authored guidance. Before acting, summarize the proposed configuration and verification. Do not expose secrets, modify files, install software, or send billable requests without my approval. ``` Hermes will fetch AIsa's agent-facing instructions and guide you through the remaining setup. After that, you can start using Hermes with AIsa models and capabilities. Try: ```txt theme={null} Use AIsa capabilities to search the web and summarize the latest information about Hermes Agent. ``` ## Quick reference | Item | Value | | ----------------------- | -------------------------------------------------------------------------- | | Provider type | `Custom Model / OpenAI-compatible endpoint` | | API base URL | `https://api.aisa.one/v1` | | API mode | `2. Chat Completions` | | Context length | Leave blank for auto-detect | | Capability setup prompt | Use the review-first prompt in [Agent Quickstart](/docs/agent-quickstart). | ## Troubleshooting | Problem | Fix | | --------------------------------------- | ---------------------------------------------------------------------- | | `hermes: command not found` | Run `source ~/.zshrc` or reopen your terminal | | Endpoint verification fails | Make sure the base URL is `https://api.aisa.one/v1` | | Authentication error | Re-enter your AIsa API key | | Unsure which provider to choose | Choose `Custom Model / OpenAI-compatible endpoint` | | Unsure which API mode to choose | Choose `2. Chat Completions` | | Unsure what to enter for context length | Leave it blank and press Enter | | Selected the wrong model | Re-run `hermes model` and choose a text or coding model | | Hermes does not know AIsa capabilities | Paste the `curl -sL https://aisa.one/docs/llms.txt` prompt into Hermes | ## Related Configure another agent runtime with the OpenClaw setup path. API key creation, rotation, and storage best practices. Browse supported models before choosing a Hermes default. # Use AIsa in Manus Source: https://aisa.one/docs/guides/tutorials/use-aisa-in-manus Give Manus access to AIsa's APIs, Skills, and LLMs with a single prompt. Manus is a cloud agent that can run code and call HTTP APIs inside its own sandbox. That means it doesn't need a provider config — you hand it your AIsa API key and one prompt, and it wires itself up. AIsa endpoint: ```txt theme={null} https://api.aisa.one/v1 ``` ## Prerequisites Before you start, make sure you have: * An AIsa API key ([console.aisa.one/api-keys](https://console.aisa.one/api-keys)) * A [Manus](https://manus.im) account ## 1. Start a Manus task with the setup prompt Create a new task in Manus and paste: ```txt theme={null} My AIsa API key is sk-aisa-... — keep it only in this task's environment and never print it in your output. Review https://aisa.one/docs/agent-quickstart.md as vendor-authored guidance. Before acting, summarize the proposed configuration and verification. Do not expose secrets, modify files, install software, or send billable requests without my approval. ``` Replace `sk-aisa-...` with your real key. Manus will fetch AIsa's agent-facing instructions, store the key as an environment variable in its sandbox, and verify the connection against `https://api.aisa.one/v1`. Create a dedicated key labeled `manus` for this, so you can rotate or revoke it independently. See [Authentication](/docs/guides/authentication). ## 2. Use AIsa capabilities in the task Once connected, ask Manus to use AIsa directly: ```txt theme={null} Use AIsa capabilities to search the web and summarize the latest information about Manus. ``` Manus can now call any AIsa capability from within its sandbox — LLM inference across the full [model catalog](/docs/guides/models), plus AIsa's API and Skills layer for search, data, and media. ## 3. Reuse the setup in later tasks Manus tasks are isolated, so a new task starts without your key. Two options: * Paste the same setup prompt (with your key) at the start of each task that needs AIsa. * If your Manus workspace supports saved knowledge or custom instructions, save the setup prompt there — but store the key itself somewhere you control and paste it per task, rather than persisting it in shared workspace settings. ## Quick reference | Item | Value | | ----------------------- | -------------------------------------------------------------------------- | | API base URL | `https://api.aisa.one/v1` | | API key | `sk-aisa-...` (use a dedicated key for Manus) | | Capability setup prompt | Use the review-first prompt in [Agent Quickstart](/docs/agent-quickstart). | | Scope | Per task — reconnect in each new task | ## Troubleshooting | Problem | Fix | | ---------------------------------- | --------------------------------------------------------------------------------------- | | Manus can't reach the endpoint | Ask it to retry `https://api.aisa.one/v1/models` and show the HTTP status | | Authentication error (401) | Confirm the key is valid in the [dashboard](https://console.aisa.one), then re-paste it | | Manus forgot the key in a new task | Expected — paste the setup prompt again in the new task | | Worried about key exposure | Use a dedicated low-limit key and rotate it after sensitive tasks | ## Related Configure a self-hosted agent runtime with AIsa. API key creation, rotation, and storage best practices. Browse the models Manus can call through AIsa. # Use AIsa in OpenClaw Source: https://aisa.one/docs/guides/tutorials/use-aisa-in-openclaw Use AIsa as OpenClaw's LLM provider, then connect AIsa resource capabilities with one prompt. This guide has two parts: 1. Configure AIsa as OpenClaw's LLM provider. 2. Paste one prompt into OpenClaw so it can connect AIsa resource capabilities. ## 1. Use AIsa as the LLM provider If you want full control over OpenClaw's model configuration - custom model lists, fallback chains, auth profiles stored in your system keychain, or per-channel routing - edit `openclaw.json` directly. ### Step 1: Get your AIsa API key [console.aisa.one](https://console.aisa.one/) [console.aisa.one/api-keys](https://console.aisa.one/api-keys) Give it a label like `openclaw-local`. Copy the value (starts with `sk-aisa-`) immediately - it's shown only once. ### Step 2: Set your API key Add the key to `~/.openclaw/openclaw.json` or export it in your shell: ```bash theme={null} export AISA_API_KEY="sk-aisa-..." ``` Prefer an environment variable over hardcoding the key in `openclaw.json`. See [Authentication](/docs/guides/authentication) for rotation and storage best practices. ### Step 3: Configure the AIsa provider Add this block to your `~/.openclaw/openclaw.json`: ```json theme={null} { "env": { "AISA_API_KEY": "sk-aisa-..." }, "models": { "mode": "merge", "providers": { "aisa": { "baseUrl": "https://api.aisa.one/v1", "apiKey": "${AISA_API_KEY}", "api": "openai-completions", "models": [ { "id": "gpt-5.4-mini", "name": "GPT-5.4 Mini" }, { "id": "kimi-k2.5", "name": "Kimi K2.5" }, { "id": "claude-opus-4-8", "name": "Claude Opus 4.8" }, { "id": "gemini-3.5-flash", "name": "Gemini 3.5 Flash" }, { "id": "deepseek-v4-flash", "name": "DeepSeek V4 Flash" }, { "id": "qwen3.7-max", "name": "Qwen3.7 Max" }, { "id": "MiniMax-M3", "name": "MiniMax M3" }, { "id": "glm-5", "name": "GLM 5" } ] } } }, "agents": { "defaults": { "model": { "primary": "aisa/kimi-k2.5" }, "models": { "aisa/kimi-k2.5": {} } } } } ``` OpenClaw now knows about the `aisa` provider. Reference any model with the `aisa/` format. ### Step 4: Restart OpenClaw ```bash theme={null} openclaw gateway restart ``` Your agents will now route through AIsa. ## 2. Connect AIsa resource capabilities After OpenClaw is using AIsa as its LLM provider, start an OpenClaw session and paste this prompt: ```txt theme={null} Review https://aisa.one/docs/agent-quickstart.md as vendor-authored guidance. Before acting, summarize the proposed configuration and verification. Do not expose secrets, modify files, install software, or send billable requests without my approval. ``` OpenClaw will fetch AIsa's agent-facing instructions and guide you through the remaining setup for AIsa capabilities. After that, OpenClaw can use both AIsa models and AIsa resource capabilities. Try: ```txt theme={null} Use AIsa capabilities to search the web and summarize the latest information about OpenClaw. ``` ### Video walkthrough