# 6io API: full documentation

> OpenAI-compatible API with one key and one balance in credits. Chat models (groups op and vn) work through /v1/chat/completions; image, video and audio models (groups fal and sixio) run as a queue: an ID at once, the result by polling or a webhook. Keys are created in the console after signing in with a 6io account: https://api.6io.io/console/

- "Sixio" is the name of this API itself, not a third-party service: keys start with `sixio_sk_`, the `X-Sixio-Request-Id` header and the `sixio/` model group belong to it.
- Base URL: https://api.6io.io. Chat and account endpoints are under /v1, queues under /native/fal and /native/sixio. Authorization: `Authorization: Bearer sixio_sk_...`.
- Two ways of working. Chat models (`op/`, `vn/`) are a **stream**: the answer arrives in the same connection (parts with `"stream": true`). Image, video and audio models (`fal/`, `sixio/`) and `POST /v1/jobs` are a **queue**: the request returns an ID `req_...` at once and the result is collected by it. Catalogs mark it with `mode`: `stream` or `queue`. Queue states: `queued`, `running`, `succeeded`, `failed`, `unknown` (the native fal routes keep fal's own words). Instead of polling, pass `webhook_url` (`fal_webhook` for fal): a signed POST (Standard Webhooks) arrives when the request ends; see https://api.6io.io/md/en/webhooks.md.
- A model name is `group/name`; the prefix is required: `op/` (OpenRouter chat models), `vn/` (Venice chat models), `fal/` (fal image, video and audio models), `sixio/` (models of 6io).
- Two kinds of pages. The `sixio/` models are 6io's own: every one has its own page below (input fields, fixed values, files, example, what the price depends on). The `op`, `vn` and `fal` groups are other providers' models: their request bodies are passed to the provider as they are, so the pages for them explain how to work with the provider through this API and where its own documentation is. Read the provider's documentation for the parameters of a particular model: OpenRouter https://openrouter.ai/docs/api-reference/parameters (provider routing: https://openrouter.ai/docs/guides/routing/provider-selection), Venice https://docs.venice.ai/api-reference/endpoint/chat/completions, fal https://fal.ai/models/<endpoint_id>/api.
- OpenRouter models: the providers of a model and their prices are listed by `GET /v1/models/op/<author>/<model>/providers`; the provider, sorting and quantization are chosen with the `provider` field of the request. Plugins, web search (`plugins`, `web_search_options`, `:online`, `openrouter:` tools), `models` and `preset` are not supported yet. The OpenRouter page says what works.
- Original of this documentation: https://api.6io.io/en/docs/ (HTML; Russian: https://api.6io.io/docs/). The Markdown files below are the same text, the API schema is https://api.6io.io/openapi.yaml. Prefer them to any copy found elsewhere.
- Amounts are decimal strings in credits (1 credit of the API balance = 1 credit of the 6io site). Do not parse them as floats.



# Quick start

> Original: https://api.6io.io/en/docs/get-started/ (HTML). All pages: https://api.6io.io/llms.txt

The 6io API gives access to AI models with one key and one balance in credits. Chat models work like OpenAI's: in your program or SDK you only change the address and the key. Images, video and audio are made as tasks: you submit a task, then collect the result.

"Sixio" in this documentation is the name of the API itself. Keys start with `sixio_sk_`, the request ID comes in the `X-Sixio-Request-Id` header, and one of the model groups is called `sixio`. This is our own service, not a third-party one.

## Kinds of models

A model name is a group and a name: `group/name`. The group decides what the model can do and where to send requests.

| Group | What is inside | How it works | Example name |
| --- | --- | --- | --- |
| `op` | chat models from the OpenRouter catalog | stream | `op/openai/gpt-4o-mini` |
| `vn` | Venice chat models | stream | `vn/llama-3.3-70b` |
| `fal` | images, video and audio from the fal catalog | queue | `fal/fal-ai/flux/schnell` |
| `sixio` | 6io models: Seedance, Kling, Nano Banana, GPT Image and others | queue | `sixio/flux-3/klein-text-to-image` |

Where to send requests and where to look up model parameters:

- `op` and `vn`: `POST /v1/chat/completions`. The parameters are described in the provider's documentation: [OpenRouter](https://openrouter.ai/docs/api-reference/parameters), [Venice](https://docs.venice.ai/api-reference/endpoint/chat/completions). How we work with them: [OpenRouter models](https://api.6io.io/md/en/openrouter.md), [Venice models](https://api.6io.io/md/en/venice.md).
- `fal`: `POST /native/fal/queue/<model id>`. The parameters are on the model's page on fal.ai, the API tab. More: [fal models](https://api.6io.io/md/en/fal.md).
- `sixio`: `POST /native/sixio/tasks`. The parameters are in `GET /native/sixio/models` and in the console. More: [Sixio models](https://api.6io.io/md/en/sixio.md).

The prefix is required. A model without it, or with an unknown prefix, answers `404 model_not_found`.

Request bodies for `op`, `vn` and `fal` models go to the provider as they are. So this documentation describes only what we add: prices, balance, errors, limits and retries. What the parameters of a particular model mean is in the provider's documentation, linked in the table above.

## Stream and queue

Models work in one of two ways.

- **Stream.** The answer arrives in the same connection: whole, or in parts as it is generated (`"stream": true`). Chat of `op` and `vn` works this way.
- **Queue.** The request returns an ID `req_…` at once, and you collect the result by it when it is ready: with a `GET` request or with a notification to your address ([webhooks](https://api.6io.io/md/en/webhooks.md)). `fal`, `sixio` and [background jobs](https://api.6io.io/md/en/jobs.md) (chat through the queue) work this way. Images and video take seconds to minutes, so there is no reason to keep a connection open.

In the catalogs and in the console every model has a `mode` mark: `stream` or `queue`. States in the queue are named the same everywhere: `queued` (waiting), `running` (in progress), `succeeded` (done), `failed` (not done), `unknown` (the outcome is being checked, the money is not closed yet). The exception is `fal`: its SDKs understand only fal's words (`IN_QUEUE`, `IN_PROGRESS`, `COMPLETED`), so they stayed there.

## Getting started

1. Open the [console](https://api.6io.io/console/) and sign in with a 6io account, or create one. The account is shared with 6io: the same email, password and credits.
2. Top up the API balance. On the Overview tab enter how many site credits to transfer. The API balance is also in credits, but it is a separate wallet: one site credit gives one API credit.
3. On the Keys tab press "Create key". The key is shown once, so save it right away. You can create several keys, each with its own expiry or none.
4. Put the address `https://api.6io.io/v1` and this key into your program.

## The first request

```bash
curl https://api.6io.io/v1/chat/completions \
  -H "Authorization: Bearer sixio_sk_..." \
  -H "Content-Type: application/json" \
  -d '{
    "model": "op/openai/gpt-4o-mini",
    "messages": [{"role": "user", "content": "Hello!"}],
    "max_tokens": 100
  }'
```

Python, the official OpenAI SDK (`pip install openai`):

```python
from openai import OpenAI

client = OpenAI(base_url="https://api.6io.io/v1", api_key="sixio_sk_...")
reply = client.chat.completions.create(
    model="op/openai/gpt-4o-mini",
    messages=[{"role": "user", "content": "Hello!"}],
    max_tokens=100,
)
print(reply.choices[0].message.content)
```

Node.js (`npm install openai`):

```javascript
import OpenAI from "openai";

const client = new OpenAI({ baseURL: "https://api.6io.io/v1", apiKey: "sixio_sk_..." });
const reply = await client.chat.completions.create({
  model: "op/openai/gpt-4o-mini",
  messages: [{ role: "user", content: "Hello!" }],
  max_tokens: 100,
});
console.log(reply.choices[0].message.content);
```

The response comes in the OpenAI format. Its `model` is the name you sent, and the `X-Sixio-Request-Id` header holds the request ID, a string like `req_8fK2xQ1mZpVwT9sJdL4nAg`. With the ID you can look up what the request cost.

## What it cost

The balance:

```bash
curl https://api.6io.io/v1/balance -H "Authorization: Bearer sixio_sk_..."
```

```json
{
  "currency": "credits",
  "balance": "9.986728000000",
  "reserved": "0.000000000000",
  "available": "9.986728000000"
}
```

One request by its ID:

```bash
curl https://api.6io.io/v1/requests/req_8fK2xQ1mZpVwT9sJdL4nAg -H "Authorization: Bearer sixio_sk_..."
```

```json
{
  "id": "req_8fK2xQ1mZpVwT9sJdL4nAg",
  "object": "request",
  "model": "op/openai/gpt-4o-mini",
  "status": "succeeded",
  "billing_status": "settled",
  "reserved": "0.500000000000",
  "charged_credits": "0.013272000000",
  "created_at": "2026-10-26T12:00:01Z",
  "finished_at": "2026-10-26T12:00:03Z"
}
```

The console shows the same: the Requests tab is the history with state and amount, Spending is spending by day and model, Models has the prices. The Playground tab sends a real paid request from the browser with your key.

## What next

- [Chat](https://api.6io.io/md/en/chat.md): a request, streaming, prices, free models.
- [OpenRouter models](https://api.6io.io/md/en/openrouter.md) and [Venice models](https://api.6io.io/md/en/venice.md): providers and prices, sorting, plugins, specifics.
- [fal models](https://api.6io.io/md/en/fal.md) and [Sixio models](https://api.6io.io/md/en/sixio.md): images, video and audio as tasks.
- [Background jobs](https://api.6io.io/md/en/jobs.md): a long chat without an open connection.
- [Webhooks](https://api.6io.io/md/en/webhooks.md): learn about the end of a request without polling the status.
- [Balance and prices](https://api.6io.io/md/en/billing.md): how the price is calculated and what a reserve is.
- [Retries and failures](https://api.6io.io/md/en/retries.md): how not to pay twice.
- [Errors and limits](https://api.6io.io/md/en/errors-and-limits.md): the table of codes.

By using the API you accept the [terms of use](https://api.6io.io/md/en/terms.md): the service is provided "as is", and you are responsible for the content of requests and the use of responses.


# Chat

> Original: https://api.6io.io/en/docs/chat/ (HTML). All pages: https://api.6io.io/llms.txt

Chat works over the OpenAI protocol: `POST /v1/chat/completions`. Any SDK or program where you can change the address and the key will do. The models are the groups `op` ([OpenRouter](https://api.6io.io/md/en/openrouter.md)) and `vn` ([Venice](https://api.6io.io/md/en/venice.md)).

## A request

```bash
curl https://api.6io.io/v1/chat/completions \
  -H "Authorization: Bearer sixio_sk_..." \
  -H "Content-Type: application/json" \
  -d '{
    "model": "op/openai/gpt-4o-mini",
    "messages": [
      {"role": "system", "content": "Answer briefly."},
      {"role": "user", "content": "What is Idempotency-Key for?"}
    ],
    "temperature": 0.3,
    "max_tokens": 200
  }'
```

The parameters (`temperature`, `max_tokens`, `tools`, `response_format` and others) go to the provider as they are. What they mean and which models understand them is in the provider's documentation: [OpenRouter](https://openrouter.ai/docs/api-reference/parameters) for `op`, [Venice](https://docs.venice.ai/api-reference/endpoint/chat/completions) for `vn`.

The response comes in the OpenAI format. `model` holds the name you sent (`op/…`), and the request ID is in the `X-Sixio-Request-Id` header.

Set `max_tokens`. Before sending, we reserve money for the longest answer you allowed, and the smaller `max_tokens` is, the smaller the reserve. Only what was actually spent is charged. More in [Balance and prices](https://api.6io.io/md/en/billing.md).

## Streaming

With `"stream": true` the answer arrives as it is generated, as SSE.

```python
from openai import OpenAI

client = OpenAI(base_url="https://api.6io.io/v1", api_key="sixio_sk_...")
stream = client.chat.completions.create(
    model="op/openai/gpt-4o-mini",
    messages=[{"role": "user", "content": "Tell a short fairy tale"}],
    max_tokens=300,
    stream=True,
)
for chunk in stream:
    if chunk.choices:  # the last chunk carries only usage, no text
        print(chunk.choices[0].delta.content or "", end="", flush=True)
```

- The last chunk has `usage`. Its `usage.cost` is the cost at the provider in dollars, not our charge. The amount in credits is in `GET /v1/requests/{id}`.
- If you close the connection early, the generation at the provider may already be running. It will be paid for.
- If there is a proxy between you and the API (nginx and the like), turn off response buffering. We send the `X-Accel-Buffering: no` header.

## Catalog and prices

`GET /v1/models` returns the chat models in the OpenAI format. Each one has an added `pricing` field:

```json
{
  "id": "op/openai/gpt-4o-mini",
  "object": "model",
  "owned_by": "openai",
  "pricing": {
    "currency": "credits",
    "prompt_per_million": "11.850000000000",
    "completion_per_million": "47.400000000000",
    "request": "0.000000000000"
  }
}
```

| Field | Meaning |
| --- | --- |
| `prompt_per_million` | the price of a million input tokens, credits |
| `completion_per_million` | the price of a million output tokens, credits |
| `request` | the fee for the request itself, if the model has one |

The list holds chat models only. For fal and Sixio models see `GET /native/fal/models` and `GET /native/sixio/models`. Models with a floating price ("dynamic" at the provider) are not sold.

The final price depends on how many tokens were actually spent, so it can differ from the estimate made from the catalog.

## Free models

Models with a price of 0 in the catalog (at OpenRouter such names have the suffix `:free`) are called like all the others, and the charge for them is zero. The condition: the API balance must be above zero. With a zero balance or in debt the answer is `402 insufficient_funds`.

To find them in the catalog:

```python
import requests

models = requests.get(
    "https://api.6io.io/v1/models",
    headers={"Authorization": "Bearer sixio_sk_..."},
).json()["data"]

free = [
    m["id"] for m in models
    if float(m["pricing"]["prompt_per_million"]) == 0 and float(m["pricing"]["completion_per_million"]) == 0
]
print(free)
```

The provider's quota for free models is shared by all its clients, so they may answer `503 upstream_busy`. In that case nothing is charged: retry after `Retry-After`.

## Groups op and vn

Chat is the same for both groups, but each has its own specifics:

- [OpenRouter models (op)](https://api.6io.io/md/en/openrouter.md): how to find a model's providers and their prices, choose a provider and the sorting, what about plugins and web search.
- [Venice models (vn)](https://api.6io.io/md/en/venice.md): the system prompt, paid search, the price.

## What is not supported yet

These requests are refused before any charge with `400 unsupported_parameter`:

- web search and the provider's paid server tools: the fields `plugins` and `web_search_options`, the model suffix `:online`, `tools` of the type `openrouter:…`;
- choosing a model around the `model` field: the fields `models` (a list of fallback models) and `preset`;
- input that is not text: images, audio and files in `messages`.

Function calling (`tools`) and the other parameters work as at the provider.


# OpenRouter models (group op)

> Original: https://api.6io.io/en/docs/openrouter/ (HTML). All pages: https://api.6io.io/llms.txt

The `op` group gives access to the chat models in the [OpenRouter](https://openrouter.ai/models) catalog. A model name is `op/<author>/<model>`, for example `op/openai/gpt-4o-mini`. Requests and responses are OpenAI-compatible: `POST /v1/chat/completions` (see [Chat](https://api.6io.io/md/en/chat.md)).

The request body is passed to OpenRouter as it is, so the parameters of a model are described in the OpenRouter documentation: [Parameters](https://openrouter.ai/docs/api-reference/parameters) and [Provider routing](https://openrouter.ai/docs/guides/routing/provider-selection). This page covers only what is different here: how to find a model and its providers, what is supported and what is not.

## Finding a model

- `GET /v1/models` returns every model on sale with prices in credits. OpenRouter models start with `op/`.
- Names are the same as on [openrouter.ai/models](https://openrouter.ai/models); only the `op/` prefix is added.
- Free variants (`…:free`) are on sale too, but only while the API balance is above zero: see [Chat](https://api.6io.io/md/en/chat.md).
- A suffix works only where that variant is a separate entry of the catalog (as `:free` is). The OpenRouter shortcut suffixes `:nitro`, `:floor` and `:online` do not work: the answer is `404 model_not_found`. Use `provider.sort` instead of `:nitro` and `:floor` (below).

## Providers of a model: list and prices

One model is usually run by several providers that differ in price, numeric precision and speed. The list with prices in credits:

```bash
curl https://api.6io.io/v1/models/op/meta-llama/llama-3.3-70b-instruct/providers \
  -H "Authorization: Bearer sixio_sk_..."
```

Response (shortened):

```json
{
  "id": "op/meta-llama/llama-3.3-70b-instruct",
  "name": "Meta: Llama 3.3 70B Instruct",
  "context": 131072,
  "pricing": {"currency": "credits", "prompt_per_million": "9.480000000000", "completion_per_million": "30.810000000000", "request": "0.000000000000"},
  "providers": [
    {
      "name": "DeepInfra",
      "tag": "deepinfra/turbo",
      "quantization": "fp8",
      "context": 131072,
      "max_output": 16384,
      "uptime_30m": 99.8,
      "default": true,
      "pricing": {"currency": "credits", "prompt_per_million": "9.480000000000", "completion_per_million": "30.810000000000", "request": "0.000000000000"}
    }
  ]
}
```

- Providers are listed from the cheapest. `default: true` marks the one a request goes to first when you do not choose a provider.
- `tag` is what goes into `provider.order`, `only` and `ignore`. A short name (`deepinfra`) matches all variants of that provider (`deepinfra/turbo`).
- `quantization` is the numeric precision (`fp8`, `fp16`, `bf16`, `int4`…), `uptime_30m` is the availability over the last 30 minutes, in percent.
- This works for `op/` models only. `vn/` has no provider list: Venice runs its own models.

The same data is in the console: the Models tab, click a model.

## Choosing a provider

Without a choice, a request goes to the cheapest provider with precision fp8 or better (`fp8`, `mxfp8`, `fp16`, `bf16`, `fp32`), and to the next cheapest one if that fails. Closed models do not state a precision, so no precision filter is added for them.

Your own choice is the `provider` field of the request body, in the OpenRouter format:

```json
{
  "model": "op/meta-llama/llama-3.3-70b-instruct",
  "messages": [{"role": "user", "content": "Hello"}],
  "provider": {"order": ["novita", "deepinfra"], "allow_fallbacks": false}
}
```

| `provider` field | What it does |
| --- | --- |
| `order` | which providers to try, and in what order |
| `only` | only these providers |
| `ignore` | every provider except these |
| `allow_fallbacks` | `false`: do not move on to other providers when the chosen ones are unavailable |
| `quantizations` | allowed precision: `int4`, `int8`, `fp4`, `fp6`, `fp8`, `fp16`, `bf16`, `fp32`, `unknown` and the others in the OpenRouter docs |
| `sort` | how to rank providers: `price`, `throughput` or `latency` (more below) |
| `require_parameters` | `true`: only providers that support every parameter of the request |
| `data_collection` | `deny`: only providers that do not store your data |
| `zdr` | `true`: only providers with zero data retention |
| `max_price` | price ceiling (`prompt`, `completion`, `request`, `image`); **in OpenRouter's units and dollars, not in credits**, see their documentation |
| `preferred_min_throughput`, `preferred_max_latency` | preferred speed and latency (a soft condition) |

How `provider` is handled here:

- If you set neither `sort` nor `order`, we add `sort: "price"`.
- If you set none of `quantizations`, `only` and `order`, we add a filter for precision fp8 or better (only when the model has such a provider).
- Everything else is passed on as it is.
- The reserve is calculated with the prices of the provider the request goes to first. When that is not known in advance (for example, `order` is set), the highest price among the suitable providers is used. The actual cost is always what is charged.

Examples:

```json
{"provider": {"sort": "throughput"}}
{"provider": {"sort": "latency"}}
{"provider": {"only": ["deepinfra"], "allow_fallbacks": false}}
{"provider": {"quantizations": ["fp16", "bf16"]}}
{"provider": {"ignore": ["novita"]}}
```

## Sorting

- `"sort": "price"`: the cheapest provider (already the default here). OpenRouter's `:floor` suffix does the same.
- `"sort": "throughput"`: the fastest in tokens per second. OpenRouter's `:nitro` suffix does the same.
- `"sort": "latency"`: the lowest time to the first token.
- The object form `{"sort": {"by": "throughput", "partition": "none"}}` is accepted too: `partition` says whether providers are ranked inside each model or all together. It matters only with several models, and the `models` field is not supported here, so a string is usually enough.

## Plugins and web search

**Not supported yet.** These requests are refused before any charge with `400 unsupported_parameter`:

- the `plugins` field (web search `{"id": "web"}`, PDF parsing and the other OpenRouter plugins);
- the `web_search_options` field (the `:online` model suffix gives `404 model_not_found`);
- OpenRouter server tools in `tools`: types `openrouter:…`;
- the `models` field (a list of fallback models) and `preset`.

The reason is money. Web search and plugins cost extra on top of the tokens (per OpenRouter's documentation, Exa search is currently $0.007 per request plus $0.001 for each result beyond ten), and that amount is not part of the reserve. Until it is, such requests cannot be accepted.

What you can do now:

- search the web yourself and put the text you found into `messages`;
- use plain function calling (`tools` of type `function`): it works as in OpenAI;
- instead of `models`, send the request with `provider.order` and `allow_fallbacks`, and retry with another model in your own code on failure.

## What works as in OpenRouter

All other request parameters are passed on as they are: `temperature`, `top_p`, `max_tokens`, `stop`, `tools` and `tool_choice`, `response_format` (structured output), `reasoning` and more. Which of them a given model and provider understand is shown by `GET https://openrouter.ai/api/v1/models/<author>/<model>/endpoints` (the `supported_parameters` field) or the model page on openrouter.ai.

## Money

The price in credits is calculated from the provider's cost (`usage.cost` in the response); see [Balance and prices](https://api.6io.io/md/en/billing.md). Free models and provider errors are covered in [Chat](https://api.6io.io/md/en/chat.md) and [Retries and failures](https://api.6io.io/md/en/retries.md).


# Venice models (group vn)

> Original: https://api.6io.io/en/docs/venice/ (HTML). All pages: https://api.6io.io/llms.txt

The `vn` group gives access to the chat models of [Venice](https://docs.venice.ai/). A model name is `vn/<Venice model ID>`, for example `vn/llama-3.3-70b`. Requests and responses are OpenAI-compatible: `POST /v1/chat/completions` (see [Chat](https://api.6io.io/md/en/chat.md)).

The request body is passed to Venice as it is, so the parameters are described in the Venice documentation: [Chat Completions](https://docs.venice.ai/api-reference/endpoint/chat/completions) and [API Specification](https://docs.venice.ai/api-reference/api-spec) (the Venice-specific `venice_parameters` are there too). The list of Venice models is in [List Models](https://docs.venice.ai/api-reference/endpoint/models/list) and its prices in [Pricing](https://docs.venice.ai/overview/pricing). Here you get the same models with prices in credits.

## Finding a model

`GET /v1/models` returns every model on sale with prices in credits. Venice models start with `vn/`. There is no provider choice as in OpenRouter: Venice runs its own models.

## How it differs from a plain chat

- **The Venice system prompt is off.** By default Venice adds its own prompt, about 1500 tokens on every request, and you would pay for them. Turn it on with `venice_parameters.include_venice_system_prompt: true`.
- **Paid search is not accepted.** Web search, page scraping and X search (`venice_parameters.enable_web_search`, `enable_web_scraping`, `enable_x_search`) and suffixes in the model name (`model:parameter=value`) are refused for now with `400 unsupported_parameter` or `404 model_not_found`: their cost is not part of the reserve.
- **Models with client-side encryption** (`e2ee-…`) are not on sale.
- **All other `venice_parameters` and request parameters** are passed on as they are.
- **Price.** Venice reports the cost in the `cost` field of the response (`usd` and `diem`). If the cost is not in dollars (`diem` is not zero), you get the result at once and the money for the request is closed after a check (status `billing_pending`, then `billing_review`); see [Balance and prices](https://api.6io.io/md/en/billing.md).

Free models (price 0) work while the API balance is above zero: see [Chat](https://api.6io.io/md/en/chat.md).


# fal models

> Original: https://api.6io.io/en/docs/fal/ (HTML). All pages: https://api.6io.io/llms.txt

The `fal` group opens the fal catalog: images, video, audio and other models. A model name is `fal/<the model id at fal>`, for example `fal/fal-ai/flux/schnell`. Generation runs as a task: the request returns an ID at once, with it you learn the status and collect the result when it is ready. fal calls this a queue, hence `queue` in the addresses. The addresses start with `https://api.6io.io/native/fal`, the authorization is the same: `Authorization: Bearer sixio_sk_...`.

The body of the task goes to fal as it is. The fields of a model are on its page at fal.ai, the API tab: `https://fal.ai/models/<model id>/api`, for example [fal-ai/flux/schnell](https://fal.ai/models/fal-ai/flux/schnell/api).

## A full example

```python
import time
import requests

API = "https://api.6io.io/native/fal"
H = {"Authorization": "Bearer sixio_sk_..."}
MODEL = "fal-ai/flux/schnell"

# 1. the price of a unit (optional)
print(requests.get(f"{API}/price/{MODEL}", headers=H).json())

# 2. submit the task
job = requests.post(
    f"{API}/queue/{MODEL}",
    headers=H,
    json={"prompt": "a red circle on white background", "image_size": {"width": 1024, "height": 1024}},
).json()

# 3. wait until the status becomes COMPLETED
while True:
    st = requests.get(job["status_url"], headers=H).json()
    if st["status"] == "COMPLETED":
        break
    time.sleep(2)

# 4. collect the result
if st.get("error"):
    raise RuntimeError(st["error"])
result = requests.get(job["response_url"], headers=H).json()
print(result["images"][0]["url"])
```

Download the file at once or save the link: file links are valid for a limited time (see below).

## Catalog and price

```bash
curl "https://api.6io.io/native/fal/models?q=flux&limit=5" -H "Authorization: Bearer sixio_sk_..."
curl "https://api.6io.io/native/fal/price/fal-ai/flux/schnell" -H "Authorization: Bearer sixio_sk_..."
```

The catalog is big, so it is paged: search by `q` and take the next page by `next_cursor`.

The answer about the price:

```json
{
  "id": "fal/fal-ai/flux/schnell",
  "currency": "credits",
  "unit": "megapixels",
  "price_per_unit": "0.240000000000",
  "note": "The final charge depends on the billable units of the finished request (megapixels)"
}
```

`unit` is what the price is set for, `price_per_unit` is the price of one unit in credits (the markup is already included). Models with the units `images`, `megapixels`, `seconds` and `videos` are supported. For the others (for example, payment by compute time) submitting answers `400 unsupported_model`. A model that fal does not have is `404 model_not_found`.

## Submitting a task

```bash
curl -X POST "https://api.6io.io/native/fal/queue/fal-ai/flux/schnell" \
  -H "Authorization: Bearer sixio_sk_..." \
  -H "Content-Type: application/json" \
  -d '{"prompt": "a red circle on white background", "image_size": {"width": 1024, "height": 1024}}'
```

The answer:

```json
{
  "request_id": "req_8fK2xQ1mZpVwT9sJdL4nAg",
  "status": "IN_QUEUE",
  "status_url": "https://api.6io.io/native/fal/requests/req_8fK2xQ1mZpVwT9sJdL4nAg/status",
  "response_url": "https://api.6io.io/native/fal/requests/req_8fK2xQ1mZpVwT9sJdL4nAg",
  "cancel_url": "https://api.6io.io/native/fal/requests/req_8fK2xQ1mZpVwT9sJdL4nAg/cancel"
}
```

`request_id` and the links are ours, not fal's: the task belongs to your account, and nobody else's can be opened. Of the query string parameters only `fal_webhook` is accepted, the address for a [notification](https://api.6io.io/md/en/webhooks.md) about the end of the task; the others are not supported. The `Idempotency-Key` header works as in chat: see [Retries and failures](https://api.6io.io/md/en/retries.md).

## A notification instead of polling

Add `?fal_webhook=<address>` (the address encoded) to the submit address, and we send the outcome to it when fal ends the task. The body of the notification is built like a fal webhook (`request_id`, `status` `OK` or `ERROR`, `payload`), but it is signed with our secret by Standard Webhooks, and the file links are ours. Details, signature verification and retries are on the [Webhooks](https://api.6io.io/md/en/webhooks.md) page.

## Status, result, cancel

- `GET status_url`: `IN_QUEUE`, `IN_PROGRESS` or `COMPLETED` (fal's words here, as in its SDK; in Sixio and jobs the states are `queued`, `running`, `succeeded`, `failed`). If fal ended the task with an error, the answer has an `error` field.
- `GET response_url`: the model's result in the fal format. While the task is not ready, the answer is as at fal (`400`, "still in progress").
- `PUT cancel_url`: cancel. `200` means the task was taken off the line and will not run, and the money is returned. `202` means the signal was sent to a running task: it may have reached the end, and then it is paid for.

**File links in the result lead to our server** and are valid for a limited time (14 days by default). Download what you need to keep longer.

## Money

1. Before submitting, an estimate is reserved: the price of a unit × the expected number of units (the number of images, the size in megapixels rounded up, the video length, 5 seconds by default).
2. The final amount is charged by fal's data on the units actually billed. They appear a few minutes after completion. Until then the request is in the state `billing_pending`; this is normal, and you get the result at once.
3. A task that fal ended with an error is not paid for: the reserve is returned after a short time.

Only a limited number of tasks can run at the same time. Images, video and audio have their own limit, separate from the chat limit. Details are in [Errors and limits](https://api.6io.io/md/en/errors-and-limits.md).


# Sixio models

> Original: https://api.6io.io/en/docs/sixio/ (HTML). All pages: https://api.6io.io/llms.txt

The `sixio` group opens the 6io image and video models: Seedance, Kling, Grok Imagine, WAN, LTX-2, HappyHorse, MiniMax, PixVerse, Nano Banana, GPT Image, Flux, Qwen Image, Seedream and others. These are the same generations as on the 6io site: the same parameter checks and the same price.

A model name is `sixio/<name>`, for example `sixio/flux-3/klein-text-to-image`. Generation runs as tasks: you submit a task, poll the status and collect the result. The addresses start with `https://api.6io.io/native/sixio`, the authorization is the same: `Authorization: Bearer sixio_sk_...`.

Every model has its own page: the `input` fields, the values the model sets itself, files, an example and what the price depends on. These pages are meant for AI agents; the list is at `https://api.6io.io/md/en/sixio-models.md`. The live catalog with prices is `GET /native/sixio/models`.

## A full example

```python
import time
import requests

API = "https://api.6io.io/native/sixio"
H = {"Authorization": "Bearer sixio_sk_..."}

# 1. submit the task
task = requests.post(f"{API}/tasks", headers=H, json={
    "model": "sixio/flux-3/klein-text-to-image",
    "input": {"prompt": "a red circle on a white background", "aspectRatio": "1:1", "resolution": "1K"},
}).json()

# 2. wait for the end
while True:
    state = requests.get(task["status_url"], headers=H).json()
    if state["status"] in ("succeeded", "failed"):
        break
    time.sleep(3)

# 3. collect the files
if state["status"] == "succeeded":
    print(state["result"]["urls"])
else:
    print(state["error"]["message"])
```

If the input does not fit (`422 invalid_input` with a reason) or there is not enough money (`402 insufficient_funds`), the task is not created: an error comes instead of `status_url`, and nothing is charged. The error codes are in [Errors and limits](https://api.6io.io/md/en/errors-and-limits.md).

## The catalog

```bash
curl "https://api.6io.io/native/sixio/models" -H "Authorization: Bearer sixio_sk_..."
```

For every model the answer has:

- `id`, the name for a request (`sixio/...`), and `kind`, `image` or `video`;
- `example_input`, an example of the `input` field where there is one;
- `price`, the model's price in advance, in credits: `unit` is what the price is set for (`per image`, `per second`, `per video`), `from` and `to` are the lowest and the highest price in that unit, `options` is the price by variant (resolution, length, sound).

`price` is for reference. The price charged is the 6io price for your exact input (length, resolution, sound, number of images) with the group markup. The input fields of each model, their types and an example call are visible in the console: open the model on the Models tab.

## The input fields

`input` holds the generation parameters in the form 6io accepts for this model. Field names are camelCase: `aspectRatio`, `imageUrls`, `referenceImageUrls`, `audio` and so on. Files are passed as public `http(s)` links.

- Some fields are set by the model itself and cannot be overridden. For example, for `sixio/bytedance/seedance-2-fast` the `quality` tier is always `fast`, and for `sixio/nano-banana-pro` the `model` field is that model.
- To edit a picture with Flux 3 Klein or Qwen Image 2.1, send the same model (`sixio/flux-3/klein-text-to-image`, `sixio/qwen2-1/text-to-image`) with the source pictures in `sourceImageUrls`.
- Extending and upscaling a clip (`sixio/grok-imagine/extend`, `sixio/grok-imagine/upscale`, `sixio/pixverse-v6/extend`) take the source in the `originalVideoId` field. It holds the `id` of your earlier finished sixio task, a string like `req_…` (a number will not do). A foreign or wrong ID answers `422 invalid_input`.
- The length of video and audio for the price is measured by the server. Fields where a client could name it itself are not accepted: `inputVideoSeconds` of Seedance and MiniMax H3 and `durationHint` of Kling Avatar give `400 unsupported_parameter`. For Kling Motion the `videoDuration` field is required; give any number from 3 to 30: it is ignored.

Wrong values are refused at once with `422 invalid_input` and a reason. No money is reserved then.

## Files by link

Images, audio and video are passed as public `http(s)` links. Where the file itself sets the price (the length of a video or audio), we do not trust the link: we download the file, check it and work with a copy from then on. These are the fields:

- `referenceVideoUrls` of Seedance 2, Seedance 2.5 and MiniMax H3;
- `videoUrl` of `sixio/happyhorse/video-edit`;
- `imageUrl` and `videoUrl` of `sixio/kling-2.6/motion-control`;
- `imageUrl` and `audioUrl` of `sixio/kling/ai-avatar-standard` and `sixio/kling/ai-avatar-pro`.

An example for Kling Motion:

```json
{
  "model": "sixio/kling-2.6/motion-control",
  "input": {
    "prompt": "The character dances",
    "imageUrl": "https://example.com/character.png",
    "videoUrl": "https://example.com/motion.mp4",
    "orientation": "video",
    "mode": "720p",
    "videoDuration": 5
  }
}
```

The rules:

- The link must lead to a public address and return the file with a 200 answer without a login. Your own server, cloud storage or a link from the result of an earlier sixio task will do. Addresses in private networks are not accepted.
- Size: an image up to 10 MB, a video up to 100 MB, audio up to 50 MB. Video is MP4, MOV or WebM, an image is JPG, PNG or WebP. If the link has no extension, the format is taken from the content or the `Content-Type` header.
- The field takes no more links than the model accepts: up to 3 video references for Seedance 2 and MiniMax H3, up to 10 for Seedance 2.5. For MiniMax H3 their total length is up to 15 seconds, longer is `422 invalid_input`.
- A link to a file that already lies on a 6io server (for example, uploaded on the site) is passed as it is, without a copy. Only a file of your own account is accepted.
- The copy stays with us for 15 minutes at most and is deleted as soon as the task ends (done or failed). You do not get a link to the copy. On a retry send the original link.
- The file is downloaded before the money is reserved. If the link did not open, the file did not fit or is too big, the `422 invalid_input` answer names the field and the reason, and no money is reserved.
- An account can hold a limited number of copies at the same time (12 files and 300 MB by default). Above that the answer is `429 rate_limit_exceeded`: retry when the running tasks end.

## Submitting a task

```bash
curl -X POST "https://api.6io.io/native/sixio/tasks" \
  -H "Authorization: Bearer sixio_sk_..." \
  -H "Content-Type: application/json" \
  -d '{"model": "sixio/flux-3/klein-text-to-image", "input": {"prompt": "a red circle on a white background", "aspectRatio": "1:1", "resolution": "1K"}}'
```

Three fields are allowed in the body: `model`, `input` and an optional `webhook_url`, the address where we report the end of the task so that you need not poll the status ([webhooks](https://api.6io.io/md/en/webhooks.md)). Other fields are not accepted. The answer:

```json
{
  "id": "req_8fK2xQ1mZpVwT9sJdL4nAg",
  "object": "task",
  "model": "sixio/flux-3/klein-text-to-image",
  "status": "queued",
  "status_url": "https://api.6io.io/native/sixio/tasks/req_8fK2xQ1mZpVwT9sJdL4nAg"
}
```

The `id` is ours, the task belongs to your account, and nobody else's can be opened. The `Idempotency-Key` header works as in chat: a retry with the same key does not create a second task (see [Retries and failures](https://api.6io.io/md/en/retries.md)).

## Status and result

`GET status_url` shows the state of the task at the moment of the request. The `status` field:

| `status` | Meaning |
| --- | --- |
| `queued` | the task is accepted and waits to start |
| `running` | the task is in progress |
| `succeeded` | done, `result.urls` holds the links to the files (all of them if there are several images) |
| `failed` | the task was not done, the reason is in `error.message` |
| `unknown` | the state could not be read, the money is being checked: ask again later |

The answer also has `created_at`, `finished_at` and `billing` (the state of the money and the charged amount in credits).

**File links lead to our server** and are valid for a limited time, 14 days by default. Download what you need to keep longer: we do not store results.

## Money

1. The price of a task is the 6io price for your input with the group markup. It is reserved on submit. If the available funds are lower, the answer is `402 insufficient_funds`.
2. A finished task charges exactly the reserve.
3. If the task was not done (`fail`), the reserve is returned in full.
4. If the input is refused (`422 invalid_input`) or the service is temporarily unavailable (`503 service_unavailable`), the task is not created and no money is spent.

The number of tasks at the same time is limited. Images and video have their own limit, separate from the chat limit. Details are in [Errors and limits](https://api.6io.io/md/en/errors-and-limits.md).

## Safety filters

Where the model allows it, the provider's own content filters are off, as on the 6io site. The content of a request and its consequences stay your responsibility (see the [terms of use](https://api.6io.io/md/en/terms.md)).


# Background jobs

> Original: https://api.6io.io/en/docs/jobs/ (HTML). All pages: https://api.6io.io/llms.txt

`POST /v1/jobs` starts an operation in the background. You get a `202` answer and a job ID at once, then ask for the state yourself and collect the finished result. It is handy when a request is long or you do not want to keep a connection open.

For now there is one operation, `chat.completions` (chat of the `op` and `vn` groups). Images and video through `fal` and `sixio` already work as tasks: see [fal models](https://api.6io.io/md/en/fal.md) and [Sixio models](https://api.6io.io/md/en/sixio.md).

## A full example

```python
import time
import requests

API = "https://api.6io.io/v1"
H = {"Authorization": "Bearer sixio_sk_..."}

job = requests.post(f"{API}/jobs", headers=H, json={
    "model": "op/openai/gpt-4o-mini",
    "operation": "chat.completions",
    "input": {"messages": [{"role": "user", "content": "Hello!"}], "max_tokens": 200},
}).json()

while True:
    state = requests.get(job["status_url"], headers=H).json()
    if state["status"] != "running":
        break
    time.sleep(2)

if state["status"] == "succeeded":
    result = requests.get(job["result_url"], headers=H).json()
    print(result["choices"][0]["message"]["content"])
else:
    print(state["status"], state.get("error"))
```

## Create a job

`input` is the body of an ordinary chat request without the `model` field (the model goes next to `operation`). Streaming (`stream`) is not supported in jobs: use `POST /v1/chat/completions` for it. Paid tools and non-text input are refused just as in ordinary chat. The `Idempotency-Key` header works as everywhere. To avoid polling the state, add `webhook_url`: when the job ends, we send a notification to that address ([webhooks](https://api.6io.io/md/en/webhooks.md)).

The answer is `202`, and the `Location` header points to the state:

```json
{
  "id": "req_8fK2xQ1mZpVwT9sJdL4nAg",
  "object": "job",
  "operation": "chat.completions",
  "model": "op/openai/gpt-4o-mini",
  "status": "running",
  "status_url": "https://api.6io.io/v1/jobs/req_8fK2xQ1mZpVwT9sJdL4nAg",
  "result_url": "https://api.6io.io/v1/jobs/req_8fK2xQ1mZpVwT9sJdL4nAg/result"
}
```

The job ID equals `X-Sixio-Request-Id`, so its money is visible in `GET /v1/requests/{id}` as well. If there is no free place, the answer comes at once (`429`): the job does not wait for one. While the service restarts, new jobs get `503` with `Retry-After`.

## State

`GET /v1/jobs/{id}` returns `status`:

| `status` | Meaning |
| --- | --- |
| `running` | the job is in progress |
| `succeeded` | done, the result can be collected |
| `failed` | not done, the reason is in `error`, no money is charged |
| `unknown` | the provider did not confirm the outcome (a dropped connection, overload): there is no result, the money is checked and closed later |

The `billing` field holds the state of the money and the charged amount in credits.

## The result

`GET /v1/jobs/{id}/result` returns an ordinary chat answer. Reading starts nothing and charges nothing.

- While the job is running, the answer is `202` with a link to the state and `Retry-After`.
- The result is kept for a limited time (a day by default). Collect it in that time: after that, `410 result_expired`.
- For `failed` and `unknown` the answer is `409` with the code `job_failed` or `job_outcome_unknown`.
- Sometimes the outcome was unknown and the check showed that the provider did the work. The job becomes `succeeded` and is paid for, but we have no answer: `409 result_unavailable`.
- An answer larger than 4 MB is also paid for but not stored: `409 result_too_large`. Send such requests as an ordinary `POST /v1/chat/completions`.
- If the result cannot be read for the moment, the answer is `503` with `Retry-After`: read again.

## Cancel

Jobs cannot be cancelled: a chat cannot be cancelled once it is sent to the provider, and closing the connection does not stop it.

## Money

As in ordinary chat: a reserve before the start, a charge by the actual cost after the answer.

- The provider refused because of your request: the reserve is returned.
- The provider refused because of the request rate (`429`) or could not be reached: no work was done, the reserve is returned, and the job ends with the error `upstream_busy`. You can send it again.
- The outcome is unknown (a timeout, `5xx`, a drop after sending): the reserve stays while we check the cost. A paid request is not sent again. The same happens to a job that did not finish within the provider's timeout, for example when the service restarts.

What to do on failures is in [Retries and failures](https://api.6io.io/md/en/retries.md).


# Webhooks

> Original: https://api.6io.io/en/docs/webhooks/ (HTML). All pages: https://api.6io.io/llms.txt

Images, video, audio and background jobs run as a queue: the request returns an ID at once, and the result is ready later. To avoid asking for the status every few seconds, give the address of your server. When the request ends, we send a `POST` with the outcome to it.

Polling is not cancelled by this. A notification can fail to arrive (your server was down, a network fault), and the status by ID can always be fetched with a `GET`. Treat the notification as the fast way to learn about the end, and `GET` as the way to check.

## How to pass the address

| What you start | Where to put the address |
| --- | --- |
| a [Sixio](https://api.6io.io/md/en/sixio.md) model (`POST /native/sixio/tasks`) | the `webhook_url` field in the body, next to `model` and `input` |
| a [background job](https://api.6io.io/md/en/jobs.md) (`POST /v1/jobs`) | the `webhook_url` field in the body |
| a [fal](https://api.6io.io/md/en/fal.md) model (`POST /native/fal/queue/...`) | the `fal_webhook` query parameter, as at fal itself |

Chat `POST /v1/chat/completions` answers in the same connection and has no notifications.

```bash
curl -X POST "https://api.6io.io/native/sixio/tasks" \
  -H "Authorization: Bearer sixio_sk_..." \
  -H "Content-Type: application/json" \
  -d '{
    "model": "sixio/flux-3/klein-text-to-image",
    "input": {"prompt": "a red circle on a white background", "aspectRatio": "1:1", "resolution": "1K"},
    "webhook_url": "https://example.com/hooks/6io"
  }'
```

For fal the address goes in the query string and must be encoded: `?fal_webhook=https%3A%2F%2Fexample.com%2Fhooks%2F6io`.

### Which address fits

The address is checked before money is reserved. An unsuitable one gives `400 invalid_webhook_url`, and nothing is started.

- `https` only. At most 2048 characters, no login or password.
- Public internet only. Addresses in private networks (`10.x`, `192.168.x`, `localhost`), service and reserved addresses are refused. The check is repeated at connect time, so swapping the address through DNS does not work.
- Not the address of this API and not 6io.
- We do not follow redirects. Give the final address, without a redirect from `http` to `https` and without a slash the server would add.

To test reception on your own computer, open a temporary public address on it (any tunnel, for example `ngrok` or `cloudflared`) and pass that.

## What arrives

A `POST` to your address, the body is JSON, `Content-Type: application/json`. The format is [Standard Webhooks](https://www.standardwebhooks.com/): there are ready libraries for verifying the signature in many languages.

Headers:

| Header | Meaning |
| --- | --- |
| `webhook-id` | the notification ID, like `msg_req_…`; it does not change on retries |
| `webhook-timestamp` | the sending time, Unix seconds |
| `webhook-signature` | the signature, like `v1,<base64>` (if there are several, separated by spaces) |
| `X-Sixio-Request-Id` | the ID of your request |

The body:

```json
{
  "type": "request.finished",
  "timestamp": "2026-10-27T09:12:44Z",
  "data": { "...": "the same as the status GET of this request returns" }
}
```

`type` is always `request.finished`. `data` holds what the status request returns.

**Sixio** is like `GET /native/sixio/tasks/{id}`:

```json
{
  "id": "req_8fK2xQ1mZpVwT9sJdL4nAg",
  "object": "task",
  "model": "sixio/flux-3/klein-text-to-image",
  "status": "succeeded",
  "created_at": "2026-10-27T09:12:10Z",
  "finished_at": "2026-10-27T09:12:44Z",
  "billing": { "status": "settled", "charged_credits": "3.200000000000" },
  "status_url": "https://api.6io.io/native/sixio/tasks/req_8fK2xQ1mZpVwT9sJdL4nAg",
  "result": { "urls": ["https://api.6io.io/api/download/…"] }
}
```

**A background job** is like `GET /v1/jobs/{id}` (the chat answer itself is collected at `result_url`).

**fal** is in the shape of a fal webhook:

```json
{
  "request_id": "req_8fK2xQ1mZpVwT9sJdL4nAg",
  "status": "OK",
  "outcome": "succeeded",
  "payload": { "images": [{ "url": "https://api.6io.io/api/download/…" }] },
  "status_url": "https://api.6io.io/native/fal/requests/req_8fK2xQ1mZpVwT9sJdL4nAg/status",
  "response_url": "https://api.6io.io/native/fal/requests/req_8fK2xQ1mZpVwT9sJdL4nAg"
}
```

`status` is `OK` or `ERROR` (with `ERROR` there is `error` and `payload` is `null`). `outcome` is our state word. A result larger than 256 KB is not put into the notification: `payload` is `null`, and `payload_error` tells you to fetch it at `response_url`.

The state in `status` (`outcome` for fal): `succeeded` means done, `failed` means not done, `unknown` means the outcome is not confirmed yet and the money is being checked: the notification is sent once with this word, and you look at the outcome later in `GET /v1/requests/{id}`.

## How to verify the signature

Do not trust a request until you have verified the signature: anyone can write to your address.

The signing secret is in the console, on the Keys tab, the "Notification signing" block. It starts with `whsec_`, is shared by all keys of the account and is changed with the "Rotate the secret" button (the old one stops working at once).

The signed string is `webhook-id` + `.` + `webhook-timestamp` + `.` + the body. The signature is HMAC-SHA256 with the key from the secret (the part after `whsec_` is base64), the result in base64. Take the body as bytes, as it arrived: if you parse the JSON and build it again, the signature will not match. Reject notifications whose time differs from yours by more than 5 minutes.

Python:

```python
import base64, hashlib, hmac, time


def verify(secret: str, headers: dict, body: bytes) -> bool:
    msg_id = headers["webhook-id"]
    timestamp = headers["webhook-timestamp"]
    if abs(time.time() - int(timestamp)) > 300:
        return False  # too old (or from the future)
    key = base64.b64decode(secret.removeprefix("whsec_"))
    signed = f"{msg_id}.{timestamp}.".encode() + body
    expected = base64.b64encode(hmac.new(key, signed, hashlib.sha256).digest()).decode()
    return any(
        hmac.compare_digest(expected, s.removeprefix("v1,"))
        for s in headers["webhook-signature"].split()
        if s.startswith("v1,")
    )
```

A receiver on Flask:

```python
from flask import Flask, request

app = Flask(__name__)
SECRET = "whsec_..."  # from the console


@app.post("/hooks/6io")
def hook():
    if not verify(SECRET, request.headers, request.get_data()):
        return "bad signature", 400
    event = request.get_json()
    data = event["data"]
    print(data.get("id") or data.get("request_id"), data.get("status"))
    return "", 204
```

Node.js:

```javascript
import crypto from "node:crypto";

export function verify(secret, headers, rawBody) {
  const id = headers["webhook-id"];
  const timestamp = headers["webhook-timestamp"];
  if (Math.abs(Date.now() / 1000 - Number(timestamp)) > 300) return false; // too old (or from the future)
  const key = Buffer.from(secret.replace(/^whsec_/, ""), "base64");
  const expected = crypto.createHmac("sha256", key).update(`${id}.${timestamp}.`).update(rawBody).digest("base64");
  return headers["webhook-signature"].split(" ").some((s) => {
    if (!s.startsWith("v1,")) return false;
    const got = Buffer.from(s.slice(3));
    const want = Buffer.from(expected);
    return got.length === want.length && crypto.timingSafeEqual(got, want);
  });
}
```

In Express take the body as a `Buffer` (`express.raw({ type: "application/json" })`), not parsed JSON.

## What your receiver should do

- Answer with any `2xx` code within 10 seconds. The body of the answer is ignored. Do the heavy work after answering.
- Be ready for a repeat. The same notification (the same `webhook-id`) can arrive twice: your server may not have managed to answer and we retried. Remember the `webhook-id` values you have handled, or make the handling safe to repeat.
- Do not treat the body as a snapshot of the moment of the end. On a retry it is built again and reflects the state at the time of sending.

## Retries

If there is no `2xx` answer (an error, `4xx`, `5xx`, a timeout, the address unreachable), we send again. There are seven attempts in all, and the pauses between them grow:

| Attempt | How long after the previous one |
| --- | --- |
| 1 | at once, when the request ended |
| 2 | 5 seconds |
| 3 | 5 minutes |
| 4 | 30 minutes |
| 5 | 2 hours |
| 6 | 5 hours |
| 7 | 10 hours |

About 17.5 hours in all. The answer `410 Gone` means "do not send any more": there are no retries. After the last failed attempt the notification is not sent, and the outcome has to be fetched with a `GET`.

## If the notification did not arrive

In the status answer (`GET /native/sixio/tasks/{id}`, `GET /v1/jobs/{id}`, `GET /native/fal/requests/{id}/status`) a request with an address has a `webhook` field:

```json
"webhook": { "status": "pending", "attempts": 2, "last_code": 503 }
```

`status` is `pending` (not delivered yet, attempts are going), `delivered` (the receiver answered `2xx`) or `failed` (the attempts are over). `attempts` is how many attempts were made, `last_code` is the code of the receiver's last answer (`null` if there was none).

## Limits

- The address is set in each request separately; there is no address for the whole account yet.
- A notification arrives once per request, when it left "running". There are no intermediate events (for example, "started").
- One address per request.


# Balance and prices

> Original: https://api.6io.io/en/docs/billing/ (HTML). All pages: https://api.6io.io/llms.txt

## The balance

The API balance is credits in a separate wallet. It cannot be spent on the 6io site, and it is topped up with site credits. Amounts in answers are decimal strings with twelve digits after the point, for example `"0.013272000000"`.

```bash
curl https://api.6io.io/v1/balance -H "Authorization: Bearer sixio_sk_..."
```

```json
{
  "currency": "credits",
  "balance": "9.986728000000",
  "reserved": "0.000000000000",
  "available": "9.986728000000"
}
```

- `balance` is how many credits are on the account;
- `reserved` is how much is set aside now for running requests;
- `available` is how much can be spent on new requests (`balance` minus `reserved`).

### How to top up

Only with site credits: in the console, on the Overview tab, enter how many credits to transfer. Credits are bought on the 6io site. One site credit gives one API credit.

- The transfer is available after the first payment on the site. Bonus credits from registration cannot be transferred by themselves: before a payment the console answers `payment_required`.
- The transfer is one operation: the credits are taken and added together, or nothing happens.
- The amount is not returned to site credits.

## How the price is calculated

The price in credits = the cost at the provider in dollars × a multiplier (credits per dollar) × (1 + the group markup). 6io sets the multiplier and the markup, they are not shown separately: the catalog's `pricing` already includes both. The amount is rounded once, at the end, to twelve digits, not for every token.

For the `sixio` group the price of a model is the 6io price for your input (length, resolution, number of images) with the group markup.

The multiplier and the markup are remembered at the moment a request is accepted. If we change them later, requests already accepted are not recalculated.

## How a paid request goes

1. **The reserve.** Before sending to the provider, 6io sets aside an estimate: the size of your request plus `max_tokens` (a default value is taken if it is not set). If the available funds are not enough, the answer is `402 insufficient_funds`, and the request never reaches the provider.
2. **A charge by the actual cost.** After the answer the reserve is replaced by the real amount: what the request actually cost at the provider. The difference goes back to the balance.

An example. You sent a chat request. The reserve is 0.5 credits. The answer is short and cost 0.013272 credits. The balance dropped by 0.013272, and the other 0.486728 is available again.

For `fal` models the final amount comes from fal's data on the units actually billed (they appear a few minutes later), for `sixio` exactly the reserve is charged.

## If the money was not enough

The actual cost is sometimes higher than the reserve, for example with a very long answer. Then the whole actual cost is charged, and the balance may go negative. While it is negative, new paid requests are closed (`402 insufficient_funds`). Requests already sent to the provider keep running and are accounted for. Top up the balance to continue.

## The state of a request

`GET /v1/requests/{id}` shows the state of a request and its money. Take the ID from the `X-Sixio-Request-Id` header or from the `id` field of the answer: it is a string like `req_…`, not a number.

| Field | Meaning |
| --- | --- |
| `status` | `running`: in progress; `succeeded`; `failed`; `unknown`: the outcome is not known yet |
| `billing_status` | `reserved`: the money is in the reserve; `settled`: charged; `released`: the reserve is lifted, nothing is charged; `billing_pending`: waiting for the amount to be confirmed; `billing_review`: an administrator is looking into it |
| `reserved` | the amount of the reserve, credits |
| `charged_credits` | the amount charged, credits, once the request is closed |

## What happens to the money if a request fails

| What happened | The money |
| --- | --- |
| The provider refused because of your parameters (`4xx`) | the reserve is lifted, nothing is charged |
| The provider refused because of the request rate or could not be reached (`503 upstream_busy`) | the reserve is lifted, you can simply retry |
| The provider did not answer or answered with a server error (`502`/`503 upstream_unavailable`) | the reserve stays: the generation may have happened, and we check the cost at the provider |
| A fal task or a sixio task ended with an error | the reserve is lifted |

If the amount of a request could not be confirmed automatically within a day, it goes to manual review. The reserve stays meanwhile, and an administrator decides. What to do in such cases is in [Retries and failures](https://api.6io.io/md/en/retries.md).


# Retries and failures

> Original: https://api.6io.io/en/docs/retries/ (HTML). All pages: https://api.6io.io/llms.txt

Networks and providers sometimes fail. This page says what to do so as not to lose money or pay twice.

We do not retry a paid request ourselves: if the provider did not answer, the generation may still have happened. So the retrying is up to you, and it is safe with the `Idempotency-Key` header.

## Idempotency-Key

Add the `Idempotency-Key` header to a paid request: any unique string up to 255 characters, for example a UUID. If the request breaks off and you send it again with the same key, a second generation does not start and the money is not charged a second time.

```bash
curl https://api.6io.io/v1/chat/completions \
  -H "Authorization: Bearer sixio_sk_..." \
  -H "Idempotency-Key: 6f1d3a52-8b0e-4c1c-9a4e-2f1f0f8b7c11" \
  -H "Content-Type: application/json" \
  -d '{"model": "op/openai/gpt-4o-mini", "messages": [{"role": "user", "content": "Hello!"}]}'
```

| What you sent | The answer |
| --- | --- |
| a new key | ordinary processing |
| the same key and the same request | `409 idempotent_request_exists`, the `X-Sixio-Request-Id` header holds the ID of the first request; there is no new generation |
| the same key, a different request | `422 idempotency_key_reused` |
| the same key after a refusal with no charge (for example, `503 upstream_busy` or a provider `4xx`) | ordinary processing: the key is freed together with the reserve |

The key works within your account. One key is one job, not one attempt: on a retry take the same one.

A finished answer is not returned on a retry: we do not store the texts of requests and answers. After a `409` you can look at the state of the first request with `GET /v1/requests/{id}`, but the text of the answer can no longer be fetched. If you need the answer reliably, use [background jobs](https://api.6io.io/md/en/jobs.md): their result is kept for a day.

## What to do on an error

| What you see | What happened | The money | What to do |
| --- | --- | --- | --- |
| `429` and `Retry-After` | an account or IP limit was hit | not charged | wait `Retry-After` seconds and retry |
| `503 upstream_busy` | the provider did not accept the request because of the rate, or could not be reached | not charged | retry after `Retry-After` |
| `503 service_unavailable` | the service is temporarily unavailable | not charged | retry in a few seconds |
| `402 insufficient_funds` | the available funds are not enough | not charged | top up the balance |
| `4xx` from the model | something is wrong in the request | the reserve is lifted | fix the request |
| `502` or `503 upstream_unavailable` | the provider did not answer, the generation may have gone through | the reserve is held | do not retry blindly: look at `GET /v1/requests/{id}` or retry with the same `Idempotency-Key` |
| the connection dropped after sending | you do not know whether the request arrived | possibly charged | retry with the same `Idempotency-Key`: a `409` answer shows the ID of the first request |

## A safe retry in code

```python
import time
import uuid

import requests

API = "https://api.6io.io/v1"
H = {"Authorization": "Bearer sixio_sk_..."}
body = {
    "model": "op/openai/gpt-4o-mini",
    "messages": [{"role": "user", "content": "Hello!"}],
    "max_tokens": 100,
}
key = str(uuid.uuid4())  # one key per job, not per attempt

for attempt in range(4):
    try:
        r = requests.post(f"{API}/chat/completions", headers={**H, "Idempotency-Key": key}, json=body, timeout=120)
    except requests.RequestException:
        time.sleep(2)  # a drop: the outcome is unknown, a retry with the same key is safe
        continue
    if r.status_code == 409:  # such a request has already been accepted
        print("already accepted, ID:", r.headers["X-Sixio-Request-Id"])
        break
    if r.status_code in (429, 503):  # nothing is charged, or the outcome is being checked (then the next answer will be 409)
        time.sleep(int(r.headers.get("Retry-After", "5")))
        continue
    print(r.status_code, r.json())
    break
```

## If the outcome stays unknown

A request with an unknown outcome is not lost. We check at the provider what it cost and close the money: we charge the actual cost or lift the reserve. You can see it in `billing_status` (`billing_pending`, then `billing_review`). If the amount could not be confirmed automatically within a day, the request goes to manual review. The reserve stays meanwhile, and an administrator decides.


# Errors and limits

> Original: https://api.6io.io/en/docs/errors-and-limits/ (HTML). All pages: https://api.6io.io/llms.txt

## The error format

As at OpenAI, so SDKs parse it themselves:

```json
{"error": {"message": "Not enough funds on the API balance for this request", "type": "insufficient_funds", "code": "insufficient_funds"}}
```

For programs `code` is what matters: write conditions on it. The `message` text may change.

A provider's answer to an error in your parameters (for example, a model's `400`) comes as it is.

## Codes

### Key and account

| HTTP | `code` | What happened |
| --- | --- | --- |
| 401 | `invalid_api_key` | there is no key in the header, it is wrong, revoked or expired |
| 403 | `account_blocked` | the account is blocked |
| 403 | `account_restricted` | the account is in restricted mode and paid requests are closed; write to support |

### Request

| HTTP | `code` | What happened |
| --- | --- | --- |
| 400 | `invalid_body`, `unsupported_parameter`, `invalid_idempotency_key` | the request is not parsed or uses something not supported yet |
| 400 | `invalid_webhook_url` | the notification address does not fit: not `https`, a private network, the address of this API, too long or not a string |
| 404 | `model_not_found` | an unknown prefix, no such model, or it is not sold |
| 404 | `not_found` | the request, job or task is not found or belongs to another account |
| 413 | `request_too_large` | the request body is too big |

### Money and retries

| HTTP | `code` | What happened |
| --- | --- | --- |
| 402 | `insufficient_funds` | the available funds are not enough, the balance is negative or (for a free model) zero |
| 409 | `idempotent_request_exists` | a request with this `Idempotency-Key` has already been accepted |
| 422 | `idempotency_key_reused` | the same `Idempotency-Key` with a different body |

### Limits

| HTTP | `code` | What happened |
| --- | --- | --- |
| 429 | `rate_limit_exceeded` | too often |
| 429 | `concurrency_limit_exceeded` | all places for simultaneous requests are taken (separately for chat and for images, video and audio) |
| 429 | `too_many_waiting_requests` | too many requests are waiting for a free place |
| 429 | `too_many_unsettled_requests` | too many requests are not yet closed in money |
| 429 | `ip_rate_limit_exceeded`, `ip_blocked`, `too_many_connections` | too many requests or connections from one IP, or the IP is blocked for a while |

### Provider and service

| HTTP | `code` | What happened |
| --- | --- | --- |
| 503 | `service_unavailable` | the service is temporarily unavailable, no money is charged for the request |
| 503 | `upstream_busy` | the provider did not accept the request because of the rate, or could not be reached: nothing is charged, retry after `Retry-After` |
| 502, 503 | `upstream_unavailable` | the provider did not answer, the outcome is being checked, the reserve is held |

### fal and Sixio models

| HTTP | `code` | What happened |
| --- | --- | --- |
| 400 | `invalid_endpoint` | fal: a wrong model ID |
| 400 | `unsupported_model` | fal: the model's price unit is not supported yet |
| 422 | `invalid_input` | Sixio: the task parameters are refused or a file by link is not accepted (the link did not open, it is not a public address, too big, the wrong type). The task is not accepted, no money was reserved |

### Background jobs

| HTTP | `code` | What happened |
| --- | --- | --- |
| 400 | `unsupported_operation` | there is no such operation |
| 409 | `job_failed`, `job_outcome_unknown`, `result_unavailable`, `result_too_large` | there is no result: the job was not done, the outcome is being checked, or the provider did the work but the answer did not reach us or is above the storage limit |
| 410 | `result_expired` | the result's storage time is over |

What to do with each of them is in [Retries and failures](https://api.6io.io/md/en/retries.md).

## Limits

Limits apply to the whole account: all its keys share one limit, and the number of keys does not raise it. The kinds are:

- **rate** of paid requests: the average speed and a burst;
- **simultaneous requests**: how many generations run in parallel;
- **waiting**: if there is no place, a request waits a few seconds before it gets `429`. It does not become a deferred job with a `202` answer;
- **not closed in money**: how many requests are already sent but their amount is not confirmed;
- **reading** (`/models`, `/balance`, `/requests`): counted separately, so frequent status checks do not eat the generation limit.

All `429` answers carry a `Retry-After` header in seconds and a reason code. It is a retry interval, not a promise that a place frees up exactly then. Your own limits and their use are visible in the console, on the Overview tab. The limit values depend on the account and can be changed on request to support.


# API terms of use

> Original: https://api.6io.io/en/docs/terms/ (HTML). All pages: https://api.6io.io/llms.txt

By creating a key or sending requests to the API you accept these terms.

1. **What the 6io API is.** It is a 6io service: one access point to AI models and the infrastructure for working with them — accepting and sending requests, queues and background jobs, error handling, limits, cost accounting and a balance in credits. The models themselves are built and run by their developers and providers: the models' answers, their work, availability and rules do not depend on us.
2. **Liability.** We bear no responsibility whatsoever for users and providers: neither for the content of requests and answers, nor for the actions of users, nor for the work, quality, availability, rules and decisions of providers (refusal, blocking, changing or switching off models), nor for the consequences of using the answers you receive.
3. **Risks.** You use the API at your own risk and take on all risks connected with using the service and the models' answers.
4. **Your duties.** You are responsible for the content of your requests, for obeying the law and the providers' rules, and for keeping your keys safe: anything done with your key is considered done by you. If you give a link to a file, you confirm that you may use it; to process the task we download the file and keep a copy for at most 15 minutes, and the copy is deleted when the task ends.
5. **Money.** Charges are described in "Balance and charges".
6. **Restrictions.** We may change the API, prices, limits and the list of models, and may restrict or switch off keys and access.
7. **As is.** The service is provided "as is", with no guarantee of uninterrupted work or of any result.


# sixio/bytedance/seedance-2

> Generated from the live model catalog. Index of Sixio models: https://api.6io.io/md/en/sixio-models.md. All pages: https://api.6io.io/llms.txt

Video model of the 6io platform (group `sixio`). Video generation model. Accepts: a text prompt, images (links), videos (links), audio (links). Has a switch for generated sound.

## How to call it

Submit a task, poll it, download the files. The same three steps work for every `sixio/` model; the full flow, errors and money are in https://api.6io.io/md/en/sixio.md.

```bash
curl -X POST https://api.6io.io/native/sixio/tasks \
  -H "Authorization: Bearer sixio_sk_..." \
  -H "Content-Type: application/json" \
  -d '{"model":"sixio/bytedance/seedance-2","input":{"prompt":"A paper boat floats down a rainy street","aspectRatio":"16:9","resolution":"720p","duration":5,"audio":true}}'
```

Then `GET https://api.6io.io/native/sixio/tasks/<id>` until `status` is `succeeded` (the files are in `result.urls`) or `failed` (the reason is in `error.message`). To be notified instead of polling, add `webhook_url` to the body: https://api.6io.io/md/en/webhooks.md. Result links are valid for 14 days by default.

## Input fields

The `input` object takes these fields (camelCase names). Values the model does not accept are refused with `422 invalid_input` before any money is reserved.

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `prompt` | string | yes | Text prompt describing what to generate. |
| `aspectRatio` | string | no | Aspect ratio of the result, for example "16:9" or "1:1". |
| `resolution` | string | no | Output resolution, for example "720p" or "1K". |
| `duration` | integer | no | Length of the video, in seconds. |
| `firstFrameUrl` | string | no |  |
| `lastFrameUrl` | string | no |  |
| `referenceImageUrls` | array<string> | no | Public http(s) links to reference images. |
| `referenceVideoUrls` | array<string> | no | Public http(s) links to reference videos. The server downloads and measures them: the price depends on their length. |
| `referenceAudioUrls` | array<string> | no |  |
| `audio` | boolean | no |  |
| `webSearch` | boolean | no |  |

Set by the model itself (do not send, they cannot be overridden): `quality` = `"standard"`.

Not accepted through the API (the request is refused with `400 unsupported_parameter`): `inputVideoSeconds`. The server measures what the price depends on by itself.

## Files

The server downloads these files from your public links, checks them and works with a copy (kept for at most 15 minutes, deleted when the task ends):

- `referenceVideoUrls`: video, up to 3 links, each file up to 100 MB (MP4, MOV, WebM).

Details and errors: https://api.6io.io/md/en/sixio.md (section "Files by link").

## Example input

```json
{
  "model": "sixio/bytedance/seedance-2",
  "input": {
    "prompt": "A paper boat floats down a rainy street",
    "aspectRatio": "16:9",
    "resolution": "720p",
    "duration": 5,
    "audio": true
  }
}
```

## What the price depends on

The price depends on the variant of the request. Priced variants: `1080p no video input`, `1080p with video input`, `480p no video input`, `480p with video input`, `4K no video input`, `4K with video input`, `720p no video input`, `720p with video input`.
The current price in credits (with the options) is `price` of this model in `GET https://api.6io.io/native/sixio/models`; the price charged is the one of the site for your exact input. Check `price` before sending if the cost matters.


# sixio/bytedance/seedance-2-fast

> Generated from the live model catalog. Index of Sixio models: https://api.6io.io/md/en/sixio-models.md. All pages: https://api.6io.io/llms.txt

Video model of the 6io platform (group `sixio`). Video generation model. Accepts: a text prompt, images (links), videos (links), audio (links). Has a switch for generated sound.

## How to call it

Submit a task, poll it, download the files. The same three steps work for every `sixio/` model; the full flow, errors and money are in https://api.6io.io/md/en/sixio.md.

```bash
curl -X POST https://api.6io.io/native/sixio/tasks \
  -H "Authorization: Bearer sixio_sk_..." \
  -H "Content-Type: application/json" \
  -d '{"model":"sixio/bytedance/seedance-2-fast","input":{"prompt":"A paper boat floats down a rainy street"}}'
```

Then `GET https://api.6io.io/native/sixio/tasks/<id>` until `status` is `succeeded` (the files are in `result.urls`) or `failed` (the reason is in `error.message`). To be notified instead of polling, add `webhook_url` to the body: https://api.6io.io/md/en/webhooks.md. Result links are valid for 14 days by default.

## Input fields

The `input` object takes these fields (camelCase names). Values the model does not accept are refused with `422 invalid_input` before any money is reserved.

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `prompt` | string | yes | Text prompt describing what to generate. |
| `aspectRatio` | string | no | Aspect ratio of the result, for example "16:9" or "1:1". |
| `resolution` | string | no | Output resolution, for example "720p" or "1K". |
| `duration` | integer | no | Length of the video, in seconds. |
| `firstFrameUrl` | string | no |  |
| `lastFrameUrl` | string | no |  |
| `referenceImageUrls` | array<string> | no | Public http(s) links to reference images. |
| `referenceVideoUrls` | array<string> | no | Public http(s) links to reference videos. The server downloads and measures them: the price depends on their length. |
| `referenceAudioUrls` | array<string> | no |  |
| `audio` | boolean | no |  |
| `webSearch` | boolean | no |  |

Set by the model itself (do not send, they cannot be overridden): `quality` = `"fast"`.

Not accepted through the API (the request is refused with `400 unsupported_parameter`): `inputVideoSeconds`. The server measures what the price depends on by itself.

## Files

The server downloads these files from your public links, checks them and works with a copy (kept for at most 15 minutes, deleted when the task ends):

- `referenceVideoUrls`: video, up to 3 links, each file up to 100 MB (MP4, MOV, WebM).

Details and errors: https://api.6io.io/md/en/sixio.md (section "Files by link").

## Example input

```json
{
  "model": "sixio/bytedance/seedance-2-fast",
  "input": {
    "prompt": "A paper boat floats down a rainy street"
  }
}
```

This example contains the required fields only.

## What the price depends on

The price depends on the variant of the request. Priced variants: `480p no video input`, `480p with video input`, `720p no video input`, `720p with video input`.
The current price in credits (with the options) is `price` of this model in `GET https://api.6io.io/native/sixio/models`; the price charged is the one of the site for your exact input. Check `price` before sending if the cost matters.


# sixio/bytedance/seedance-2-mini

> Generated from the live model catalog. Index of Sixio models: https://api.6io.io/md/en/sixio-models.md. All pages: https://api.6io.io/llms.txt

Video model of the 6io platform (group `sixio`). Video generation model. Accepts: a text prompt, images (links), videos (links), audio (links). Has a switch for generated sound.

## How to call it

Submit a task, poll it, download the files. The same three steps work for every `sixio/` model; the full flow, errors and money are in https://api.6io.io/md/en/sixio.md.

```bash
curl -X POST https://api.6io.io/native/sixio/tasks \
  -H "Authorization: Bearer sixio_sk_..." \
  -H "Content-Type: application/json" \
  -d '{"model":"sixio/bytedance/seedance-2-mini","input":{"prompt":"A paper boat floats down a rainy street"}}'
```

Then `GET https://api.6io.io/native/sixio/tasks/<id>` until `status` is `succeeded` (the files are in `result.urls`) or `failed` (the reason is in `error.message`). To be notified instead of polling, add `webhook_url` to the body: https://api.6io.io/md/en/webhooks.md. Result links are valid for 14 days by default.

## Input fields

The `input` object takes these fields (camelCase names). Values the model does not accept are refused with `422 invalid_input` before any money is reserved.

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `prompt` | string | yes | Text prompt describing what to generate. |
| `aspectRatio` | string | no | Aspect ratio of the result, for example "16:9" or "1:1". |
| `resolution` | string | no | Output resolution, for example "720p" or "1K". |
| `duration` | integer | no | Length of the video, in seconds. |
| `firstFrameUrl` | string | no |  |
| `lastFrameUrl` | string | no |  |
| `referenceImageUrls` | array<string> | no | Public http(s) links to reference images. |
| `referenceVideoUrls` | array<string> | no | Public http(s) links to reference videos. The server downloads and measures them: the price depends on their length. |
| `referenceAudioUrls` | array<string> | no |  |
| `audio` | boolean | no |  |
| `webSearch` | boolean | no |  |

Set by the model itself (do not send, they cannot be overridden): `quality` = `"mini"`.

Not accepted through the API (the request is refused with `400 unsupported_parameter`): `inputVideoSeconds`. The server measures what the price depends on by itself.

## Files

The server downloads these files from your public links, checks them and works with a copy (kept for at most 15 minutes, deleted when the task ends):

- `referenceVideoUrls`: video, up to 3 links, each file up to 100 MB (MP4, MOV, WebM).

Details and errors: https://api.6io.io/md/en/sixio.md (section "Files by link").

## Example input

```json
{
  "model": "sixio/bytedance/seedance-2-mini",
  "input": {
    "prompt": "A paper boat floats down a rainy street"
  }
}
```

This example contains the required fields only.

## What the price depends on

The price depends on the variant of the request. Priced variants: `480P no video`, `480P with video`, `720P no video`, `720P with video`.
The current price in credits (with the options) is `price` of this model in `GET https://api.6io.io/native/sixio/models`; the price charged is the one of the site for your exact input. Check `price` before sending if the cost matters.


# sixio/bytedance/seedance-2-5

> Generated from the live model catalog. Index of Sixio models: https://api.6io.io/md/en/sixio-models.md. All pages: https://api.6io.io/llms.txt

Video model of the 6io platform (group `sixio`). Video generation model. Accepts: a text prompt, images (links), videos (links), audio (links). Has a switch for generated sound.

## How to call it

Submit a task, poll it, download the files. The same three steps work for every `sixio/` model; the full flow, errors and money are in https://api.6io.io/md/en/sixio.md.

```bash
curl -X POST https://api.6io.io/native/sixio/tasks \
  -H "Authorization: Bearer sixio_sk_..." \
  -H "Content-Type: application/json" \
  -d '{"model":"sixio/bytedance/seedance-2-5","input":{"prompt":"A paper boat floats down a rainy street","aspectRatio":"16:9","resolution":"720p","duration":5}}'
```

Then `GET https://api.6io.io/native/sixio/tasks/<id>` until `status` is `succeeded` (the files are in `result.urls`) or `failed` (the reason is in `error.message`). To be notified instead of polling, add `webhook_url` to the body: https://api.6io.io/md/en/webhooks.md. Result links are valid for 14 days by default.

## Input fields

The `input` object takes these fields (camelCase names). Values the model does not accept are refused with `422 invalid_input` before any money is reserved.

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `prompt` | string | yes | Text prompt describing what to generate. |
| `aspectRatio` | string | no | Aspect ratio of the result, for example "16:9" or "1:1". |
| `resolution` | string | no | Output resolution, for example "720p" or "1K". |
| `duration` | integer | no | Length of the video, in seconds. |
| `outputFormat` | string | no |  |
| `firstFrameUrl` | string | no |  |
| `lastFrameUrl` | string | no |  |
| `referenceImageUrls` | array<string> | no | Public http(s) links to reference images. |
| `referenceVideoUrls` | array<string> | no | Public http(s) links to reference videos. The server downloads and measures them: the price depends on their length. |
| `referenceAudioUrls` | array<string> | no |  |
| `audio` | boolean | no |  |
| `webSearch` | boolean | no |  |

Not accepted through the API (the request is refused with `400 unsupported_parameter`): `inputVideoSeconds`. The server measures what the price depends on by itself.

## Files

The server downloads these files from your public links, checks them and works with a copy (kept for at most 15 minutes, deleted when the task ends):

- `referenceVideoUrls`: video, up to 10 links, each file up to 100 MB (MP4, MOV, WebM).

Details and errors: https://api.6io.io/md/en/sixio.md (section "Files by link").

## Example input

```json
{
  "model": "sixio/bytedance/seedance-2-5",
  "input": {
    "prompt": "A paper boat floats down a rainy street",
    "aspectRatio": "16:9",
    "resolution": "720p",
    "duration": 5
  }
}
```

## What the price depends on

The price depends on the variant of the request. Priced variants: `1080p no video`, `1080p with video`, `480p no video`, `480p with video`, `720p no video`, `720p with video`.
The current price in credits (with the options) is `price` of this model in `GET https://api.6io.io/native/sixio/models`; the price charged is the one of the site for your exact input. Check `price` before sending if the cost matters.


# sixio/grok-imagine/text-to-video

> Generated from the live model catalog. Index of Sixio models: https://api.6io.io/md/en/sixio-models.md. All pages: https://api.6io.io/llms.txt

Video model of the 6io platform (group `sixio`). Text to video: generates a video from a text prompt. Accepts: a text prompt, images (links).

## How to call it

Submit a task, poll it, download the files. The same three steps work for every `sixio/` model; the full flow, errors and money are in https://api.6io.io/md/en/sixio.md.

```bash
curl -X POST https://api.6io.io/native/sixio/tasks \
  -H "Authorization: Bearer sixio_sk_..." \
  -H "Content-Type: application/json" \
  -d '{"model":"sixio/grok-imagine/text-to-video","input":{"prompt":"A paper boat floats down a rainy street","aspectRatio":"16:9","mode":"normal","duration":"6","resolution":"720p"}}'
```

Then `GET https://api.6io.io/native/sixio/tasks/<id>` until `status` is `succeeded` (the files are in `result.urls`) or `failed` (the reason is in `error.message`). To be notified instead of polling, add `webhook_url` to the body: https://api.6io.io/md/en/webhooks.md. Result links are valid for 14 days by default.

## Input fields

The `input` object takes these fields (camelCase names). Values the model does not accept are refused with `422 invalid_input` before any money is reserved.

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `prompt` | string | yes | Text prompt describing what to generate. |
| `aspectRatio` | string | no | Aspect ratio of the result, for example "16:9" or "1:1". |
| `mode` | string | no |  |
| `duration` | string | no | Length of the video, in seconds. |
| `resolution` | string | no | Output resolution, for example "720p" or "1K". |
| `imageUrls` | array<string> | no | Public http(s) links to the input images. |

Not accepted through the API (the request is refused with `400 unsupported_parameter`): `grokTaskId`, `grokImageIndex`. The server measures what the price depends on by itself.

## Example input

```json
{
  "model": "sixio/grok-imagine/text-to-video",
  "input": {
    "prompt": "A paper boat floats down a rainy street",
    "aspectRatio": "16:9",
    "mode": "normal",
    "duration": "6",
    "resolution": "720p"
  }
}
```

## What the price depends on

The price depends on the variant of the request. Priced variants: `text-to-video, 1080p`, `text-to-video, 480p`, `text-to-video, 720p`.
The current price in credits (with the options) is `price` of this model in `GET https://api.6io.io/native/sixio/models`; the price charged is the one of the site for your exact input. Check `price` before sending if the cost matters.


# sixio/grok-imagine/image-to-video

> Generated from the live model catalog. Index of Sixio models: https://api.6io.io/md/en/sixio-models.md. All pages: https://api.6io.io/llms.txt

Video model of the 6io platform (group `sixio`). Image to video: animates an input image (or images) following a prompt. Accepts: a text prompt, images (links).

## How to call it

Submit a task, poll it, download the files. The same three steps work for every `sixio/` model; the full flow, errors and money are in https://api.6io.io/md/en/sixio.md.

```bash
curl -X POST https://api.6io.io/native/sixio/tasks \
  -H "Authorization: Bearer sixio_sk_..." \
  -H "Content-Type: application/json" \
  -d '{"model":"sixio/grok-imagine/image-to-video","input":{"prompt":"The boat starts to drift","imageUrls":["https://example.com/boat.png"],"duration":"6","resolution":"480p"}}'
```

Then `GET https://api.6io.io/native/sixio/tasks/<id>` until `status` is `succeeded` (the files are in `result.urls`) or `failed` (the reason is in `error.message`). To be notified instead of polling, add `webhook_url` to the body: https://api.6io.io/md/en/webhooks.md. Result links are valid for 14 days by default.

## Input fields

The `input` object takes these fields (camelCase names). Values the model does not accept are refused with `422 invalid_input` before any money is reserved.

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `prompt` | string | yes | Text prompt describing what to generate. |
| `aspectRatio` | string | no | Aspect ratio of the result, for example "16:9" or "1:1". |
| `mode` | string | no |  |
| `duration` | string | no | Length of the video, in seconds. |
| `resolution` | string | no | Output resolution, for example "720p" or "1K". |
| `imageUrls` | array<string> | no | Public http(s) links to the input images. |

Not accepted through the API (the request is refused with `400 unsupported_parameter`): `grokTaskId`, `grokImageIndex`. The server measures what the price depends on by itself.

## Example input

```json
{
  "model": "sixio/grok-imagine/image-to-video",
  "input": {
    "prompt": "The boat starts to drift",
    "imageUrls": [
      "https://example.com/boat.png"
    ],
    "duration": "6",
    "resolution": "480p"
  }
}
```

## What the price depends on

The price depends on the variant of the request. Priced variants: `image-to-video, 1080p`, `image-to-video, 480p`, `image-to-video, 720p`.
The current price in credits (with the options) is `price` of this model in `GET https://api.6io.io/native/sixio/models`; the price charged is the one of the site for your exact input. Check `price` before sending if the cost matters.


# sixio/grok-imagine/extend

> Generated from the live model catalog. Index of Sixio models: https://api.6io.io/md/en/sixio-models.md. All pages: https://api.6io.io/llms.txt

Video model of the 6io platform (group `sixio`). Extends an earlier finished video task of yours. Accepts: a text prompt.

## How to call it

Submit a task, poll it, download the files. The same three steps work for every `sixio/` model; the full flow, errors and money are in https://api.6io.io/md/en/sixio.md.

```bash
curl -X POST https://api.6io.io/native/sixio/tasks \
  -H "Authorization: Bearer sixio_sk_..." \
  -H "Content-Type: application/json" \
  -d '{"model":"sixio/grok-imagine/extend","input":{"originalVideoId":"req_xxxxxxxxxxxxxxxxxxxxxx","prompt":"The boat sails into the sunset","extendTimes":"6"}}'
```

Then `GET https://api.6io.io/native/sixio/tasks/<id>` until `status` is `succeeded` (the files are in `result.urls`) or `failed` (the reason is in `error.message`). To be notified instead of polling, add `webhook_url` to the body: https://api.6io.io/md/en/webhooks.md. Result links are valid for 14 days by default.

## Input fields

The `input` object takes these fields (camelCase names). Values the model does not accept are refused with `422 invalid_input` before any money is reserved.

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `originalVideoId` | string | yes | The id of your earlier finished sixio task, a string like req_… (not a number) |
| `prompt` | string | yes | Text prompt describing what to generate. |
| `extendTimes` | string | no |  |
| `extendAt` | integer | no |  |

`originalVideoId` is the `id` of your earlier finished `sixio/` video task, a string like `req_…`. A number, a foreign or an unknown id is refused with `422 invalid_input`.

## Example input

```json
{
  "model": "sixio/grok-imagine/extend",
  "input": {
    "originalVideoId": "req_xxxxxxxxxxxxxxxxxxxxxx",
    "prompt": "The boat sails into the sunset",
    "extendTimes": "6"
  }
}
```

## What the price depends on

The price depends on the variant of the request. Priced variants: `10s 480p`, `10s 720p`, `6s 480p`, `6s 720p`.
The current price in credits (with the options) is `price` of this model in `GET https://api.6io.io/native/sixio/models`; the price charged is the one of the site for your exact input. Check `price` before sending if the cost matters.


# sixio/grok-imagine/upscale

> Generated from the live model catalog. Index of Sixio models: https://api.6io.io/md/en/sixio-models.md. All pages: https://api.6io.io/llms.txt

Video model of the 6io platform (group `sixio`). Upscales an earlier finished video task of yours. 

## How to call it

Submit a task, poll it, download the files. The same three steps work for every `sixio/` model; the full flow, errors and money are in https://api.6io.io/md/en/sixio.md.

```bash
curl -X POST https://api.6io.io/native/sixio/tasks \
  -H "Authorization: Bearer sixio_sk_..." \
  -H "Content-Type: application/json" \
  -d '{"model":"sixio/grok-imagine/upscale","input":{"originalVideoId":"req_xxxxxxxxxxxxxxxxxxxxxx","resolution":"1080p"}}'
```

Then `GET https://api.6io.io/native/sixio/tasks/<id>` until `status` is `succeeded` (the files are in `result.urls`) or `failed` (the reason is in `error.message`). To be notified instead of polling, add `webhook_url` to the body: https://api.6io.io/md/en/webhooks.md. Result links are valid for 14 days by default.

## Input fields

The `input` object takes these fields (camelCase names). Values the model does not accept are refused with `422 invalid_input` before any money is reserved.

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `originalVideoId` | string | yes | The id of your earlier finished sixio task, a string like req_… (not a number) |
| `resolution` | string | no | Output resolution, for example "720p" or "1K". |

`originalVideoId` is the `id` of your earlier finished `sixio/` video task, a string like `req_…`. A number, a foreign or an unknown id is refused with `422 invalid_input`.

## Example input

```json
{
  "model": "sixio/grok-imagine/upscale",
  "input": {
    "originalVideoId": "req_xxxxxxxxxxxxxxxxxxxxxx",
    "resolution": "1080p"
  }
}
```

## What the price depends on

The price depends on the variant of the request. Priced variants: `upscale, 480P → 1080P`, `upscale, 480p→720p`, `upscale, 720P → 1080P`.
The current price in credits (with the options) is `price` of this model in `GET https://api.6io.io/native/sixio/models`; the price charged is the one of the site for your exact input. Check `price` before sending if the cost matters.


# sixio/happyhorse/text-to-video

> Generated from the live model catalog. Index of Sixio models: https://api.6io.io/md/en/sixio-models.md. All pages: https://api.6io.io/llms.txt

Video model of the 6io platform (group `sixio`). Text to video: generates a video from a text prompt. Accepts: a text prompt, images (links), videos (links).

## How to call it

Submit a task, poll it, download the files. The same three steps work for every `sixio/` model; the full flow, errors and money are in https://api.6io.io/md/en/sixio.md.

```bash
curl -X POST https://api.6io.io/native/sixio/tasks \
  -H "Authorization: Bearer sixio_sk_..." \
  -H "Content-Type: application/json" \
  -d '{"model":"sixio/happyhorse/text-to-video","input":{}}'
```

Then `GET https://api.6io.io/native/sixio/tasks/<id>` until `status` is `succeeded` (the files are in `result.urls`) or `failed` (the reason is in `error.message`). To be notified instead of polling, add `webhook_url` to the body: https://api.6io.io/md/en/webhooks.md. Result links are valid for 14 days by default.

## Input fields

The `input` object takes these fields (camelCase names). Values the model does not accept are refused with `422 invalid_input` before any money is reserved.

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `prompt` | string | no | Text prompt describing what to generate. |
| `duration` | integer | no | Length of the video, in seconds. |
| `resolution` | string | no | Output resolution, for example "720p" or "1K". |
| `aspectRatio` | string | no | Aspect ratio of the result, for example "16:9" or "1:1". |
| `seed` | integer | no | Seed for reproducible results. |
| `imageUrl` | string | no | Public http(s) link to the input image. |
| `referenceImages` | array<string> | no |  |
| `videoUrl` | string | no | Public http(s) link to the input video. |
| `audioSetting` | string | no |  |
| `trimStart` | number | no |  |
| `trimDuration` | integer | no |  |

## Example input

```json
{
  "model": "sixio/happyhorse/text-to-video",
  "input": {}
}
```

This example contains the required fields only.

## What the price depends on

The price depends on the variant of the request. Priced variants: `text-to-video, 1080p`, `text-to-video, 720p`.
The current price in credits (with the options) is `price` of this model in `GET https://api.6io.io/native/sixio/models`; the price charged is the one of the site for your exact input. Check `price` before sending if the cost matters.


# sixio/happyhorse/image-to-video

> Generated from the live model catalog. Index of Sixio models: https://api.6io.io/md/en/sixio-models.md. All pages: https://api.6io.io/llms.txt

Video model of the 6io platform (group `sixio`). Image to video: animates an input image (or images) following a prompt. Accepts: a text prompt, images (links), videos (links).

## How to call it

Submit a task, poll it, download the files. The same three steps work for every `sixio/` model; the full flow, errors and money are in https://api.6io.io/md/en/sixio.md.

```bash
curl -X POST https://api.6io.io/native/sixio/tasks \
  -H "Authorization: Bearer sixio_sk_..." \
  -H "Content-Type: application/json" \
  -d '{"model":"sixio/happyhorse/image-to-video","input":{}}'
```

Then `GET https://api.6io.io/native/sixio/tasks/<id>` until `status` is `succeeded` (the files are in `result.urls`) or `failed` (the reason is in `error.message`). To be notified instead of polling, add `webhook_url` to the body: https://api.6io.io/md/en/webhooks.md. Result links are valid for 14 days by default.

## Input fields

The `input` object takes these fields (camelCase names). Values the model does not accept are refused with `422 invalid_input` before any money is reserved.

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `prompt` | string | no | Text prompt describing what to generate. |
| `duration` | integer | no | Length of the video, in seconds. |
| `resolution` | string | no | Output resolution, for example "720p" or "1K". |
| `aspectRatio` | string | no | Aspect ratio of the result, for example "16:9" or "1:1". |
| `seed` | integer | no | Seed for reproducible results. |
| `imageUrl` | string | no | Public http(s) link to the input image. |
| `referenceImages` | array<string> | no |  |
| `videoUrl` | string | no | Public http(s) link to the input video. |
| `audioSetting` | string | no |  |
| `trimStart` | number | no |  |
| `trimDuration` | integer | no |  |

## Example input

```json
{
  "model": "sixio/happyhorse/image-to-video",
  "input": {}
}
```

This example contains the required fields only.

## What the price depends on

The price depends on the variant of the request. Priced variants: `image-to-video, 1080p`, `image-to-video, 720p`.
The current price in credits (with the options) is `price` of this model in `GET https://api.6io.io/native/sixio/models`; the price charged is the one of the site for your exact input. Check `price` before sending if the cost matters.


# sixio/happyhorse/reference-to-video

> Generated from the live model catalog. Index of Sixio models: https://api.6io.io/md/en/sixio-models.md. All pages: https://api.6io.io/llms.txt

Video model of the 6io platform (group `sixio`). Reference to video: generates a video guided by reference images, videos or audio. Accepts: a text prompt, images (links), videos (links).

## How to call it

Submit a task, poll it, download the files. The same three steps work for every `sixio/` model; the full flow, errors and money are in https://api.6io.io/md/en/sixio.md.

```bash
curl -X POST https://api.6io.io/native/sixio/tasks \
  -H "Authorization: Bearer sixio_sk_..." \
  -H "Content-Type: application/json" \
  -d '{"model":"sixio/happyhorse/reference-to-video","input":{}}'
```

Then `GET https://api.6io.io/native/sixio/tasks/<id>` until `status` is `succeeded` (the files are in `result.urls`) or `failed` (the reason is in `error.message`). To be notified instead of polling, add `webhook_url` to the body: https://api.6io.io/md/en/webhooks.md. Result links are valid for 14 days by default.

## Input fields

The `input` object takes these fields (camelCase names). Values the model does not accept are refused with `422 invalid_input` before any money is reserved.

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `prompt` | string | no | Text prompt describing what to generate. |
| `duration` | integer | no | Length of the video, in seconds. |
| `resolution` | string | no | Output resolution, for example "720p" or "1K". |
| `aspectRatio` | string | no | Aspect ratio of the result, for example "16:9" or "1:1". |
| `seed` | integer | no | Seed for reproducible results. |
| `imageUrl` | string | no | Public http(s) link to the input image. |
| `referenceImages` | array<string> | no |  |
| `videoUrl` | string | no | Public http(s) link to the input video. |
| `audioSetting` | string | no |  |
| `trimStart` | number | no |  |
| `trimDuration` | integer | no |  |

## Example input

```json
{
  "model": "sixio/happyhorse/reference-to-video",
  "input": {}
}
```

This example contains the required fields only.

## What the price depends on

The price depends on the variant of the request. Priced variants: `reference-to-video, 1080p`, `reference-to-video, 720p`.
The current price in credits (with the options) is `price` of this model in `GET https://api.6io.io/native/sixio/models`; the price charged is the one of the site for your exact input. Check `price` before sending if the cost matters.


# sixio/happyhorse/video-edit

> Generated from the live model catalog. Index of Sixio models: https://api.6io.io/md/en/sixio-models.md. All pages: https://api.6io.io/llms.txt

Video model of the 6io platform (group `sixio`). Video editing: edits an input video following a prompt. Accepts: a text prompt, images (links), videos (links).

## How to call it

Submit a task, poll it, download the files. The same three steps work for every `sixio/` model; the full flow, errors and money are in https://api.6io.io/md/en/sixio.md.

```bash
curl -X POST https://api.6io.io/native/sixio/tasks \
  -H "Authorization: Bearer sixio_sk_..." \
  -H "Content-Type: application/json" \
  -d '{"model":"sixio/happyhorse/video-edit","input":{}}'
```

Then `GET https://api.6io.io/native/sixio/tasks/<id>` until `status` is `succeeded` (the files are in `result.urls`) or `failed` (the reason is in `error.message`). To be notified instead of polling, add `webhook_url` to the body: https://api.6io.io/md/en/webhooks.md. Result links are valid for 14 days by default.

## Input fields

The `input` object takes these fields (camelCase names). Values the model does not accept are refused with `422 invalid_input` before any money is reserved.

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `prompt` | string | no | Text prompt describing what to generate. |
| `duration` | integer | no | Length of the video, in seconds. |
| `resolution` | string | no | Output resolution, for example "720p" or "1K". |
| `aspectRatio` | string | no | Aspect ratio of the result, for example "16:9" or "1:1". |
| `seed` | integer | no | Seed for reproducible results. |
| `imageUrl` | string | no | Public http(s) link to the input image. |
| `referenceImages` | array<string> | no |  |
| `videoUrl` | string | no | Public http(s) link to the input video. |
| `audioSetting` | string | no |  |
| `trimStart` | number | no |  |
| `trimDuration` | integer | no |  |

## Files

The server downloads these files from your public links, checks them and works with a copy (kept for at most 15 minutes, deleted when the task ends):

- `videoUrl`: video, one link, each file up to 100 MB (MP4, MOV, WebM).

Details and errors: https://api.6io.io/md/en/sixio.md (section "Files by link").

## Example input

```json
{
  "model": "sixio/happyhorse/video-edit",
  "input": {}
}
```

This example contains the required fields only.

## What the price depends on

The price depends on the variant of the request. Priced variants: `video-edit, 1080p`, `video-edit, 720p`.
The current price in credits (with the options) is `price` of this model in `GET https://api.6io.io/native/sixio/models`; the price charged is the one of the site for your exact input. Check `price` before sending if the cost matters.


# sixio/kling-2.6/motion-control

> Generated from the live model catalog. Index of Sixio models: https://api.6io.io/md/en/sixio-models.md. All pages: https://api.6io.io/llms.txt

Video model of the 6io platform (group `sixio`). Motion control: a character image performs the motion of a reference video. Accepts: a text prompt, images (links), videos (links).

## How to call it

Submit a task, poll it, download the files. The same three steps work for every `sixio/` model; the full flow, errors and money are in https://api.6io.io/md/en/sixio.md.

```bash
curl -X POST https://api.6io.io/native/sixio/tasks \
  -H "Authorization: Bearer sixio_sk_..." \
  -H "Content-Type: application/json" \
  -d '{"model":"sixio/kling-2.6/motion-control","input":{"prompt":"The character dances","imageUrl":"https://example.com/character.png","videoUrl":"https://example.com/motion.mp4","orientation":"video","mode":"720p","videoDuration":5}}'
```

Then `GET https://api.6io.io/native/sixio/tasks/<id>` until `status` is `succeeded` (the files are in `result.urls`) or `failed` (the reason is in `error.message`). To be notified instead of polling, add `webhook_url` to the body: https://api.6io.io/md/en/webhooks.md. Result links are valid for 14 days by default.

## Input fields

The `input` object takes these fields (camelCase names). Values the model does not accept are refused with `422 invalid_input` before any money is reserved.

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `prompt` | string | no | Text prompt describing what to generate. |
| `imageUrl` | string | yes | Public http(s) link to the input image. |
| `videoUrl` | string | yes | Public http(s) link to the input video. |
| `orientation` | string | no |  |
| `mode` | string | no |  |
| `videoDuration` | integer | yes |  |
| `trimStart` | number | no |  |
| `trimDuration` | integer | no |  |

## Files

The server downloads these files from your public links, checks them and works with a copy (kept for at most 15 minutes, deleted when the task ends):

- `imageUrl`: image, one link, each file up to 10 MB (JPG, PNG, WebP).
- `videoUrl`: video, one link, each file up to 100 MB (MP4, MOV, WebM).

Details and errors: https://api.6io.io/md/en/sixio.md (section "Files by link").

## Example input

```json
{
  "model": "sixio/kling-2.6/motion-control",
  "input": {
    "prompt": "The character dances",
    "imageUrl": "https://example.com/character.png",
    "videoUrl": "https://example.com/motion.mp4",
    "orientation": "video",
    "mode": "720p",
    "videoDuration": 5
  }
}
```

## What the price depends on

The price depends on the variant of the request. Priced variants: `720p`, `1080p`.
The current price in credits (with the options) is `price` of this model in `GET https://api.6io.io/native/sixio/models`; the price charged is the one of the site for your exact input. Check `price` before sending if the cost matters.


# sixio/kling/ai-avatar-standard

> Generated from the live model catalog. Index of Sixio models: https://api.6io.io/md/en/sixio-models.md. All pages: https://api.6io.io/llms.txt

Video model of the 6io platform (group `sixio`). AI avatar: a portrait image speaks the supplied audio. Accepts: a text prompt, images (links), audio (links).

## How to call it

Submit a task, poll it, download the files. The same three steps work for every `sixio/` model; the full flow, errors and money are in https://api.6io.io/md/en/sixio.md.

```bash
curl -X POST https://api.6io.io/native/sixio/tasks \
  -H "Authorization: Bearer sixio_sk_..." \
  -H "Content-Type: application/json" \
  -d '{"model":"sixio/kling/ai-avatar-standard","input":{"prompt":"A calm presenter speaks to the camera","imageUrl":"https://example.com/portrait.png","audioUrl":"https://example.com/speech.mp3"}}'
```

Then `GET https://api.6io.io/native/sixio/tasks/<id>` until `status` is `succeeded` (the files are in `result.urls`) or `failed` (the reason is in `error.message`). To be notified instead of polling, add `webhook_url` to the body: https://api.6io.io/md/en/webhooks.md. Result links are valid for 14 days by default.

## Input fields

The `input` object takes these fields (camelCase names). Values the model does not accept are refused with `422 invalid_input` before any money is reserved.

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `prompt` | string | no | Text prompt describing what to generate. |
| `imageUrl` | string | no | Public http(s) link to the input image. |
| `audioUrl` | string | no | Public http(s) link to the input audio. |

Set by the model itself (do not send, they cannot be overridden): `mode` = `"std"`.

Not accepted through the API (the request is refused with `400 unsupported_parameter`): `durationHint`. The server measures what the price depends on by itself.

## Files

The server downloads these files from your public links, checks them and works with a copy (kept for at most 15 minutes, deleted when the task ends):

- `imageUrl`: image, one link, each file up to 10 MB (JPG, PNG, WebP).
- `audioUrl`: audio, one link, each file up to 50 MB.

Details and errors: https://api.6io.io/md/en/sixio.md (section "Files by link").

## Example input

```json
{
  "model": "sixio/kling/ai-avatar-standard",
  "input": {
    "prompt": "A calm presenter speaks to the camera",
    "imageUrl": "https://example.com/portrait.png",
    "audioUrl": "https://example.com/speech.mp3"
  }
}
```

## What the price depends on

The price depends on the variant of the request. Priced variants: `720p`.
The current price in credits (with the options) is `price` of this model in `GET https://api.6io.io/native/sixio/models`; the price charged is the one of the site for your exact input. Check `price` before sending if the cost matters.


# sixio/kling/ai-avatar-pro

> Generated from the live model catalog. Index of Sixio models: https://api.6io.io/md/en/sixio-models.md. All pages: https://api.6io.io/llms.txt

Video model of the 6io platform (group `sixio`). AI avatar: a portrait image speaks the supplied audio. Accepts: a text prompt, images (links), audio (links).

## How to call it

Submit a task, poll it, download the files. The same three steps work for every `sixio/` model; the full flow, errors and money are in https://api.6io.io/md/en/sixio.md.

```bash
curl -X POST https://api.6io.io/native/sixio/tasks \
  -H "Authorization: Bearer sixio_sk_..." \
  -H "Content-Type: application/json" \
  -d '{"model":"sixio/kling/ai-avatar-pro","input":{}}'
```

Then `GET https://api.6io.io/native/sixio/tasks/<id>` until `status` is `succeeded` (the files are in `result.urls`) or `failed` (the reason is in `error.message`). To be notified instead of polling, add `webhook_url` to the body: https://api.6io.io/md/en/webhooks.md. Result links are valid for 14 days by default.

## Input fields

The `input` object takes these fields (camelCase names). Values the model does not accept are refused with `422 invalid_input` before any money is reserved.

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `prompt` | string | no | Text prompt describing what to generate. |
| `imageUrl` | string | no | Public http(s) link to the input image. |
| `audioUrl` | string | no | Public http(s) link to the input audio. |

Set by the model itself (do not send, they cannot be overridden): `mode` = `"pro"`.

Not accepted through the API (the request is refused with `400 unsupported_parameter`): `durationHint`. The server measures what the price depends on by itself.

## Files

The server downloads these files from your public links, checks them and works with a copy (kept for at most 15 minutes, deleted when the task ends):

- `imageUrl`: image, one link, each file up to 10 MB (JPG, PNG, WebP).
- `audioUrl`: audio, one link, each file up to 50 MB.

Details and errors: https://api.6io.io/md/en/sixio.md (section "Files by link").

## Example input

```json
{
  "model": "sixio/kling/ai-avatar-pro",
  "input": {}
}
```

This example contains the required fields only.

## What the price depends on

The price depends on the variant of the request. Priced variants: `1080p`.
The current price in credits (with the options) is `price` of this model in `GET https://api.6io.io/native/sixio/models`; the price charged is the one of the site for your exact input. Check `price` before sending if the cost matters.


# sixio/kling-3.0/video

> Generated from the live model catalog. Index of Sixio models: https://api.6io.io/md/en/sixio-models.md. All pages: https://api.6io.io/llms.txt

Video model of the 6io platform (group `sixio`). Video generation model. Accepts: a text prompt, images (links). Has a switch for generated sound.

## How to call it

Submit a task, poll it, download the files. The same three steps work for every `sixio/` model; the full flow, errors and money are in https://api.6io.io/md/en/sixio.md.

```bash
curl -X POST https://api.6io.io/native/sixio/tasks \
  -H "Authorization: Bearer sixio_sk_..." \
  -H "Content-Type: application/json" \
  -d '{"model":"sixio/kling-3.0/video","input":{"prompt":"A paper boat floats down a rainy street","mode":"std","aspectRatio":"16:9","duration":"5","sound":true}}'
```

Then `GET https://api.6io.io/native/sixio/tasks/<id>` until `status` is `succeeded` (the files are in `result.urls`) or `failed` (the reason is in `error.message`). To be notified instead of polling, add `webhook_url` to the body: https://api.6io.io/md/en/webhooks.md. Result links are valid for 14 days by default.

## Input fields

The `input` object takes these fields (camelCase names). Values the model does not accept are refused with `422 invalid_input` before any money is reserved.

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `prompt` | string | no | Text prompt describing what to generate. |
| `imageUrls` | array<string> | no | Public http(s) links to the input images. |
| `mode` | string | no |  |
| `aspectRatio` | string | no | Aspect ratio of the result, for example "16:9" or "1:1". |
| `duration` | string | no | Length of the video, in seconds. |
| `multiShots` | boolean | no |  |
| `multiPrompt` | array<object> | no |  |
| `sound` | boolean | no |  |
| `elements` | array<object> | no |  |
| `resolution` | string | no | Output resolution, for example "720p" or "1K". |

## Example input

```json
{
  "model": "sixio/kling-3.0/video",
  "input": {
    "prompt": "A paper boat floats down a rainy street",
    "mode": "std",
    "aspectRatio": "16:9",
    "duration": "5",
    "sound": true
  }
}
```

## What the price depends on

The price depends on the variant of the request. Priced variants: `video, with audio-1080P`, `video, with audio-4K`, `video, with audio-720P`, `video, without audio-1080P`, `video, without audio-4K`, `video, without audio-720P`.
The current price in credits (with the options) is `price` of this model in `GET https://api.6io.io/native/sixio/models`; the price charged is the one of the site for your exact input. Check `price` before sending if the cost matters.


# sixio/kling/v3-turbo-image-to-video

> Generated from the live model catalog. Index of Sixio models: https://api.6io.io/md/en/sixio-models.md. All pages: https://api.6io.io/llms.txt

Video model of the 6io platform (group `sixio`). Image to video: animates an input image (or images) following a prompt. Accepts: a text prompt, images (links). Has a switch for generated sound.

## How to call it

Submit a task, poll it, download the files. The same three steps work for every `sixio/` model; the full flow, errors and money are in https://api.6io.io/md/en/sixio.md.

```bash
curl -X POST https://api.6io.io/native/sixio/tasks \
  -H "Authorization: Bearer sixio_sk_..." \
  -H "Content-Type: application/json" \
  -d '{"model":"sixio/kling/v3-turbo-image-to-video","input":{}}'
```

Then `GET https://api.6io.io/native/sixio/tasks/<id>` until `status` is `succeeded` (the files are in `result.urls`) or `failed` (the reason is in `error.message`). To be notified instead of polling, add `webhook_url` to the body: https://api.6io.io/md/en/webhooks.md. Result links are valid for 14 days by default.

## Input fields

The `input` object takes these fields (camelCase names). Values the model does not accept are refused with `422 invalid_input` before any money is reserved.

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `prompt` | string | no | Text prompt describing what to generate. |
| `imageUrls` | array<string> | no | Public http(s) links to the input images. |
| `aspectRatio` | string | no | Aspect ratio of the result, for example "16:9" or "1:1". |
| `duration` | string | no | Length of the video, in seconds. |
| `multiShots` | boolean | no |  |
| `multiPrompt` | array<object> | no |  |
| `sound` | boolean | no |  |
| `elements` | array<object> | no |  |
| `resolution` | string | no | Output resolution, for example "720p" or "1K". |

Set by the model itself (do not send, they cannot be overridden): `mode` = `"turbo"`.

## Example input

```json
{
  "model": "sixio/kling/v3-turbo-image-to-video",
  "input": {}
}
```

This example contains the required fields only.

## What the price depends on

The price depends on the variant of the request. Priced variants: `image-to-video, 1080P`, `image-to-video, 720P`.
The current price in credits (with the options) is `price` of this model in `GET https://api.6io.io/native/sixio/models`; the price charged is the one of the site for your exact input. Check `price` before sending if the cost matters.


# sixio/ltx/ltx-2/fast/text-to-video

> Generated from the live model catalog. Index of Sixio models: https://api.6io.io/md/en/sixio-models.md. All pages: https://api.6io.io/llms.txt

Video model of the 6io platform (group `sixio`). Text to video: generates a video from a text prompt. Accepts: a text prompt, images (links). Has a switch for generated sound.

## How to call it

Submit a task, poll it, download the files. The same three steps work for every `sixio/` model; the full flow, errors and money are in https://api.6io.io/md/en/sixio.md.

```bash
curl -X POST https://api.6io.io/native/sixio/tasks \
  -H "Authorization: Bearer sixio_sk_..." \
  -H "Content-Type: application/json" \
  -d '{"model":"sixio/ltx/ltx-2/fast/text-to-video","input":{"prompt":"A paper boat floats down a rainy street","duration":6,"resolution":"1080p"}}'
```

Then `GET https://api.6io.io/native/sixio/tasks/<id>` until `status` is `succeeded` (the files are in `result.urls`) or `failed` (the reason is in `error.message`). To be notified instead of polling, add `webhook_url` to the body: https://api.6io.io/md/en/webhooks.md. Result links are valid for 14 days by default.

## Input fields

The `input` object takes these fields (camelCase names). Values the model does not accept are refused with `422 invalid_input` before any money is reserved.

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `prompt` | string | yes | Text prompt describing what to generate. |
| `imageUrl` | string | no | Public http(s) link to the input image. |
| `duration` | integer | no | Length of the video, in seconds. |
| `resolution` | string | no | Output resolution, for example "720p" or "1K". |
| `audio` | boolean | no |  |

Set by the model itself (do not send, they cannot be overridden): `isImage2Video` = `false`, `tier` = `"fast"`.

## Example input

```json
{
  "model": "sixio/ltx/ltx-2/fast/text-to-video",
  "input": {
    "prompt": "A paper boat floats down a rainy street",
    "duration": 6,
    "resolution": "1080p"
  }
}
```

## What the price depends on

The price depends on the variant of the request. Priced variants: `1080p`, `1440p`, `2160p`.
The current price in credits (with the options) is `price` of this model in `GET https://api.6io.io/native/sixio/models`; the price charged is the one of the site for your exact input. Check `price` before sending if the cost matters.


# sixio/ltx/ltx-2/fast/image-to-video

> Generated from the live model catalog. Index of Sixio models: https://api.6io.io/md/en/sixio-models.md. All pages: https://api.6io.io/llms.txt

Video model of the 6io platform (group `sixio`). Image to video: animates an input image (or images) following a prompt. Accepts: a text prompt, images (links). Has a switch for generated sound.

## How to call it

Submit a task, poll it, download the files. The same three steps work for every `sixio/` model; the full flow, errors and money are in https://api.6io.io/md/en/sixio.md.

```bash
curl -X POST https://api.6io.io/native/sixio/tasks \
  -H "Authorization: Bearer sixio_sk_..." \
  -H "Content-Type: application/json" \
  -d '{"model":"sixio/ltx/ltx-2/fast/image-to-video","input":{"prompt":"A paper boat floats down a rainy street"}}'
```

Then `GET https://api.6io.io/native/sixio/tasks/<id>` until `status` is `succeeded` (the files are in `result.urls`) or `failed` (the reason is in `error.message`). To be notified instead of polling, add `webhook_url` to the body: https://api.6io.io/md/en/webhooks.md. Result links are valid for 14 days by default.

## Input fields

The `input` object takes these fields (camelCase names). Values the model does not accept are refused with `422 invalid_input` before any money is reserved.

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `prompt` | string | yes | Text prompt describing what to generate. |
| `imageUrl` | string | no | Public http(s) link to the input image. |
| `duration` | integer | no | Length of the video, in seconds. |
| `resolution` | string | no | Output resolution, for example "720p" or "1K". |
| `audio` | boolean | no |  |

Set by the model itself (do not send, they cannot be overridden): `isImage2Video` = `true`, `tier` = `"fast"`.

## Example input

```json
{
  "model": "sixio/ltx/ltx-2/fast/image-to-video",
  "input": {
    "prompt": "A paper boat floats down a rainy street"
  }
}
```

This example contains the required fields only.

## What the price depends on

The price depends on the variant of the request. Priced variants: `1080p`, `1440p`, `2160p`.
The current price in credits (with the options) is `price` of this model in `GET https://api.6io.io/native/sixio/models`; the price charged is the one of the site for your exact input. Check `price` before sending if the cost matters.


# sixio/ltx/ltx-2/pro/text-to-video

> Generated from the live model catalog. Index of Sixio models: https://api.6io.io/md/en/sixio-models.md. All pages: https://api.6io.io/llms.txt

Video model of the 6io platform (group `sixio`). Text to video: generates a video from a text prompt. Accepts: a text prompt, images (links). Has a switch for generated sound.

## How to call it

Submit a task, poll it, download the files. The same three steps work for every `sixio/` model; the full flow, errors and money are in https://api.6io.io/md/en/sixio.md.

```bash
curl -X POST https://api.6io.io/native/sixio/tasks \
  -H "Authorization: Bearer sixio_sk_..." \
  -H "Content-Type: application/json" \
  -d '{"model":"sixio/ltx/ltx-2/pro/text-to-video","input":{"prompt":"A paper boat floats down a rainy street"}}'
```

Then `GET https://api.6io.io/native/sixio/tasks/<id>` until `status` is `succeeded` (the files are in `result.urls`) or `failed` (the reason is in `error.message`). To be notified instead of polling, add `webhook_url` to the body: https://api.6io.io/md/en/webhooks.md. Result links are valid for 14 days by default.

## Input fields

The `input` object takes these fields (camelCase names). Values the model does not accept are refused with `422 invalid_input` before any money is reserved.

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `prompt` | string | yes | Text prompt describing what to generate. |
| `imageUrl` | string | no | Public http(s) link to the input image. |
| `duration` | integer | no | Length of the video, in seconds. |
| `resolution` | string | no | Output resolution, for example "720p" or "1K". |
| `audio` | boolean | no |  |

Set by the model itself (do not send, they cannot be overridden): `isImage2Video` = `false`, `tier` = `"pro"`.

## Example input

```json
{
  "model": "sixio/ltx/ltx-2/pro/text-to-video",
  "input": {
    "prompt": "A paper boat floats down a rainy street"
  }
}
```

This example contains the required fields only.

## What the price depends on

The price depends on the variant of the request. Priced variants: `1080p`, `1440p`, `2160p`.
The current price in credits (with the options) is `price` of this model in `GET https://api.6io.io/native/sixio/models`; the price charged is the one of the site for your exact input. Check `price` before sending if the cost matters.


# sixio/ltx/ltx-2/pro/image-to-video

> Generated from the live model catalog. Index of Sixio models: https://api.6io.io/md/en/sixio-models.md. All pages: https://api.6io.io/llms.txt

Video model of the 6io platform (group `sixio`). Image to video: animates an input image (or images) following a prompt. Accepts: a text prompt, images (links). Has a switch for generated sound.

## How to call it

Submit a task, poll it, download the files. The same three steps work for every `sixio/` model; the full flow, errors and money are in https://api.6io.io/md/en/sixio.md.

```bash
curl -X POST https://api.6io.io/native/sixio/tasks \
  -H "Authorization: Bearer sixio_sk_..." \
  -H "Content-Type: application/json" \
  -d '{"model":"sixio/ltx/ltx-2/pro/image-to-video","input":{"prompt":"A paper boat floats down a rainy street"}}'
```

Then `GET https://api.6io.io/native/sixio/tasks/<id>` until `status` is `succeeded` (the files are in `result.urls`) or `failed` (the reason is in `error.message`). To be notified instead of polling, add `webhook_url` to the body: https://api.6io.io/md/en/webhooks.md. Result links are valid for 14 days by default.

## Input fields

The `input` object takes these fields (camelCase names). Values the model does not accept are refused with `422 invalid_input` before any money is reserved.

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `prompt` | string | yes | Text prompt describing what to generate. |
| `imageUrl` | string | no | Public http(s) link to the input image. |
| `duration` | integer | no | Length of the video, in seconds. |
| `resolution` | string | no | Output resolution, for example "720p" or "1K". |
| `audio` | boolean | no |  |

Set by the model itself (do not send, they cannot be overridden): `isImage2Video` = `true`, `tier` = `"pro"`.

## Example input

```json
{
  "model": "sixio/ltx/ltx-2/pro/image-to-video",
  "input": {
    "prompt": "A paper boat floats down a rainy street"
  }
}
```

This example contains the required fields only.

## What the price depends on

The price depends on the variant of the request. Priced variants: `1080p`, `1440p`, `2160p`.
The current price in credits (with the options) is `price` of this model in `GET https://api.6io.io/native/sixio/models`; the price charged is the one of the site for your exact input. Check `price` before sending if the cost matters.


# sixio/minimax-h3/text-to-video

> Generated from the live model catalog. Index of Sixio models: https://api.6io.io/md/en/sixio-models.md. All pages: https://api.6io.io/llms.txt

Video model of the 6io platform (group `sixio`). Text to video: generates a video from a text prompt. Accepts: a text prompt, images (links), videos (links), audio (links).

## How to call it

Submit a task, poll it, download the files. The same three steps work for every `sixio/` model; the full flow, errors and money are in https://api.6io.io/md/en/sixio.md.

```bash
curl -X POST https://api.6io.io/native/sixio/tasks \
  -H "Authorization: Bearer sixio_sk_..." \
  -H "Content-Type: application/json" \
  -d '{"model":"sixio/minimax-h3/text-to-video","input":{"prompt":"A paper boat floats down a rainy street"}}'
```

Then `GET https://api.6io.io/native/sixio/tasks/<id>` until `status` is `succeeded` (the files are in `result.urls`) or `failed` (the reason is in `error.message`). To be notified instead of polling, add `webhook_url` to the body: https://api.6io.io/md/en/webhooks.md. Result links are valid for 14 days by default.

## Input fields

The `input` object takes these fields (camelCase names). Values the model does not accept are refused with `422 invalid_input` before any money is reserved.

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `prompt` | string | yes | Text prompt describing what to generate. |
| `aspectRatio` | string | no | Aspect ratio of the result, for example "16:9" or "1:1". |
| `resolution` | string | no | Output resolution, for example "720p" or "1K". |
| `duration` | integer | no | Length of the video, in seconds. |
| `firstFrameUrl` | string | no |  |
| `lastFrameUrl` | string | no |  |
| `referenceImageUrls` | array<string> | no | Public http(s) links to reference images. |
| `referenceVideoUrls` | array<string> | no | Public http(s) links to reference videos. The server downloads and measures them: the price depends on their length. |
| `referenceAudioUrls` | array<string> | no |  |

Not accepted through the API (the request is refused with `400 unsupported_parameter`): `inputVideoSeconds`. The server measures what the price depends on by itself.

## Files

The server downloads these files from your public links, checks them and works with a copy (kept for at most 15 minutes, deleted when the task ends):

- `referenceVideoUrls`: video, up to 3 links, each file up to 100 MB (MP4, MOV, WebM).

Details and errors: https://api.6io.io/md/en/sixio.md (section "Files by link").

## Example input

```json
{
  "model": "sixio/minimax-h3/text-to-video",
  "input": {
    "prompt": "A paper boat floats down a rainy street"
  }
}
```

This example contains the required fields only.

## What the price depends on

The price depends on the variant of the request. Priced variants: `text to video, 2K`, `text to video, 768p`.
The current price in credits (with the options) is `price` of this model in `GET https://api.6io.io/native/sixio/models`; the price charged is the one of the site for your exact input. Check `price` before sending if the cost matters.


# sixio/minimax-h3/image-to-video

> Generated from the live model catalog. Index of Sixio models: https://api.6io.io/md/en/sixio-models.md. All pages: https://api.6io.io/llms.txt

Video model of the 6io platform (group `sixio`). Image to video: animates an input image (or images) following a prompt. Accepts: a text prompt, images (links), videos (links), audio (links).

## How to call it

Submit a task, poll it, download the files. The same three steps work for every `sixio/` model; the full flow, errors and money are in https://api.6io.io/md/en/sixio.md.

```bash
curl -X POST https://api.6io.io/native/sixio/tasks \
  -H "Authorization: Bearer sixio_sk_..." \
  -H "Content-Type: application/json" \
  -d '{"model":"sixio/minimax-h3/image-to-video","input":{"prompt":"A paper boat floats down a rainy street"}}'
```

Then `GET https://api.6io.io/native/sixio/tasks/<id>` until `status` is `succeeded` (the files are in `result.urls`) or `failed` (the reason is in `error.message`). To be notified instead of polling, add `webhook_url` to the body: https://api.6io.io/md/en/webhooks.md. Result links are valid for 14 days by default.

## Input fields

The `input` object takes these fields (camelCase names). Values the model does not accept are refused with `422 invalid_input` before any money is reserved.

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `prompt` | string | yes | Text prompt describing what to generate. |
| `aspectRatio` | string | no | Aspect ratio of the result, for example "16:9" or "1:1". |
| `resolution` | string | no | Output resolution, for example "720p" or "1K". |
| `duration` | integer | no | Length of the video, in seconds. |
| `firstFrameUrl` | string | no |  |
| `lastFrameUrl` | string | no |  |
| `referenceImageUrls` | array<string> | no | Public http(s) links to reference images. |
| `referenceVideoUrls` | array<string> | no | Public http(s) links to reference videos. The server downloads and measures them: the price depends on their length. |
| `referenceAudioUrls` | array<string> | no |  |

Not accepted through the API (the request is refused with `400 unsupported_parameter`): `inputVideoSeconds`. The server measures what the price depends on by itself.

## Files

The server downloads these files from your public links, checks them and works with a copy (kept for at most 15 minutes, deleted when the task ends):

- `referenceVideoUrls`: video, up to 3 links, each file up to 100 MB (MP4, MOV, WebM).

Details and errors: https://api.6io.io/md/en/sixio.md (section "Files by link").

## Example input

```json
{
  "model": "sixio/minimax-h3/image-to-video",
  "input": {
    "prompt": "A paper boat floats down a rainy street"
  }
}
```

This example contains the required fields only.

## What the price depends on

The price depends on the variant of the request. Priced variants: `image to video, 2K`, `image to video, 768p`.
The current price in credits (with the options) is `price` of this model in `GET https://api.6io.io/native/sixio/models`; the price charged is the one of the site for your exact input. Check `price` before sending if the cost matters.


# sixio/minimax-h3/reference-to-video

> Generated from the live model catalog. Index of Sixio models: https://api.6io.io/md/en/sixio-models.md. All pages: https://api.6io.io/llms.txt

Video model of the 6io platform (group `sixio`). Reference to video: generates a video guided by reference images, videos or audio. Accepts: a text prompt, images (links), videos (links), audio (links).

## How to call it

Submit a task, poll it, download the files. The same three steps work for every `sixio/` model; the full flow, errors and money are in https://api.6io.io/md/en/sixio.md.

```bash
curl -X POST https://api.6io.io/native/sixio/tasks \
  -H "Authorization: Bearer sixio_sk_..." \
  -H "Content-Type: application/json" \
  -d '{"model":"sixio/minimax-h3/reference-to-video","input":{"prompt":"A paper boat floats down a rainy street"}}'
```

Then `GET https://api.6io.io/native/sixio/tasks/<id>` until `status` is `succeeded` (the files are in `result.urls`) or `failed` (the reason is in `error.message`). To be notified instead of polling, add `webhook_url` to the body: https://api.6io.io/md/en/webhooks.md. Result links are valid for 14 days by default.

## Input fields

The `input` object takes these fields (camelCase names). Values the model does not accept are refused with `422 invalid_input` before any money is reserved.

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `prompt` | string | yes | Text prompt describing what to generate. |
| `aspectRatio` | string | no | Aspect ratio of the result, for example "16:9" or "1:1". |
| `resolution` | string | no | Output resolution, for example "720p" or "1K". |
| `duration` | integer | no | Length of the video, in seconds. |
| `firstFrameUrl` | string | no |  |
| `lastFrameUrl` | string | no |  |
| `referenceImageUrls` | array<string> | no | Public http(s) links to reference images. |
| `referenceVideoUrls` | array<string> | no | Public http(s) links to reference videos. The server downloads and measures them: the price depends on their length. |
| `referenceAudioUrls` | array<string> | no |  |

Not accepted through the API (the request is refused with `400 unsupported_parameter`): `inputVideoSeconds`. The server measures what the price depends on by itself.

## Files

The server downloads these files from your public links, checks them and works with a copy (kept for at most 15 minutes, deleted when the task ends):

- `referenceVideoUrls`: video, up to 3 links, each file up to 100 MB (MP4, MOV, WebM).

Details and errors: https://api.6io.io/md/en/sixio.md (section "Files by link").

## Example input

```json
{
  "model": "sixio/minimax-h3/reference-to-video",
  "input": {
    "prompt": "A paper boat floats down a rainy street"
  }
}
```

This example contains the required fields only.

## What the price depends on

The price depends on the variant of the request. Priced variants: `reference to video, 2K`, `reference to video, 768p`.
The current price in credits (with the options) is `price` of this model in `GET https://api.6io.io/native/sixio/models`; the price charged is the one of the site for your exact input. Check `price` before sending if the cost matters.


# sixio/pixverse-v6/text-to-video

> Generated from the live model catalog. Index of Sixio models: https://api.6io.io/md/en/sixio-models.md. All pages: https://api.6io.io/llms.txt

Video model of the 6io platform (group `sixio`). Text to video: generates a video from a text prompt. Accepts: a text prompt, images (links). Has a switch for generated sound.

## How to call it

Submit a task, poll it, download the files. The same three steps work for every `sixio/` model; the full flow, errors and money are in https://api.6io.io/md/en/sixio.md.

```bash
curl -X POST https://api.6io.io/native/sixio/tasks \
  -H "Authorization: Bearer sixio_sk_..." \
  -H "Content-Type: application/json" \
  -d '{"model":"sixio/pixverse-v6/text-to-video","input":{"prompt":"A paper boat floats down a rainy street"}}'
```

Then `GET https://api.6io.io/native/sixio/tasks/<id>` until `status` is `succeeded` (the files are in `result.urls`) or `failed` (the reason is in `error.message`). To be notified instead of polling, add `webhook_url` to the body: https://api.6io.io/md/en/webhooks.md. Result links are valid for 14 days by default.

## Input fields

The `input` object takes these fields (camelCase names). Values the model does not accept are refused with `422 invalid_input` before any money is reserved.

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `prompt` | string | yes | Text prompt describing what to generate. |
| `aspectRatio` | string | no | Aspect ratio of the result, for example "16:9" or "1:1". |
| `quality` | string | no |  |
| `duration` | integer | no | Length of the video, in seconds. |
| `generateAudio` | boolean | no |  |
| `generateMultiClip` | boolean | no |  |
| `seed` | integer | no | Seed for reproducible results. |
| `imageUrls` | array<string> | no | Public http(s) links to the input images. |
| `firstFrameImageUrl` | string | no |  |
| `lastFrameImageUrl` | string | no |  |
| `imageReferences` | array<object> | no |  |

Set by the model itself (do not send, they cannot be overridden): `mode` = `"text"`.

Not accepted through the API (the request is refused with `400 unsupported_parameter`): `originalVideoId`. The server measures what the price depends on by itself.

## Example input

```json
{
  "model": "sixio/pixverse-v6/text-to-video",
  "input": {
    "prompt": "A paper boat floats down a rainy street"
  }
}
```

This example contains the required fields only.

## What the price depends on

The price depends on the variant of the request. Priced variants: `Text /Image to Video, 1080p(no audio)`, `Text /Image to Video, 1080p(with audio)`, `Text /Image to Video, 360p(no audio)`, `Text /Image to Video, 360p(with audio)`, `Text /Image to Video, 540p(no audio)`, `Text /Image to Video, 540p(with audio)`, `Text /Image to Video, 720p(no audio)`, `Text /Image to Video, 720p(with audio)`.
The current price in credits (with the options) is `price` of this model in `GET https://api.6io.io/native/sixio/models`; the price charged is the one of the site for your exact input. Check `price` before sending if the cost matters.


# sixio/pixverse-v6/image-to-video

> Generated from the live model catalog. Index of Sixio models: https://api.6io.io/md/en/sixio-models.md. All pages: https://api.6io.io/llms.txt

Video model of the 6io platform (group `sixio`). Image to video: animates an input image (or images) following a prompt. Accepts: a text prompt, images (links). Has a switch for generated sound.

## How to call it

Submit a task, poll it, download the files. The same three steps work for every `sixio/` model; the full flow, errors and money are in https://api.6io.io/md/en/sixio.md.

```bash
curl -X POST https://api.6io.io/native/sixio/tasks \
  -H "Authorization: Bearer sixio_sk_..." \
  -H "Content-Type: application/json" \
  -d '{"model":"sixio/pixverse-v6/image-to-video","input":{"prompt":"A paper boat floats down a rainy street"}}'
```

Then `GET https://api.6io.io/native/sixio/tasks/<id>` until `status` is `succeeded` (the files are in `result.urls`) or `failed` (the reason is in `error.message`). To be notified instead of polling, add `webhook_url` to the body: https://api.6io.io/md/en/webhooks.md. Result links are valid for 14 days by default.

## Input fields

The `input` object takes these fields (camelCase names). Values the model does not accept are refused with `422 invalid_input` before any money is reserved.

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `prompt` | string | yes | Text prompt describing what to generate. |
| `aspectRatio` | string | no | Aspect ratio of the result, for example "16:9" or "1:1". |
| `quality` | string | no |  |
| `duration` | integer | no | Length of the video, in seconds. |
| `generateAudio` | boolean | no |  |
| `generateMultiClip` | boolean | no |  |
| `seed` | integer | no | Seed for reproducible results. |
| `imageUrls` | array<string> | no | Public http(s) links to the input images. |
| `firstFrameImageUrl` | string | no |  |
| `lastFrameImageUrl` | string | no |  |
| `imageReferences` | array<object> | no |  |

Set by the model itself (do not send, they cannot be overridden): `mode` = `"image"`.

Not accepted through the API (the request is refused with `400 unsupported_parameter`): `originalVideoId`. The server measures what the price depends on by itself.

## Example input

```json
{
  "model": "sixio/pixverse-v6/image-to-video",
  "input": {
    "prompt": "A paper boat floats down a rainy street"
  }
}
```

This example contains the required fields only.

## What the price depends on

The price depends on the variant of the request. Priced variants: `Text /Image to Video, 1080p(no audio)`, `Text /Image to Video, 1080p(with audio)`, `Text /Image to Video, 360p(no audio)`, `Text /Image to Video, 360p(with audio)`, `Text /Image to Video, 540p(no audio)`, `Text /Image to Video, 540p(with audio)`, `Text /Image to Video, 720p(no audio)`, `Text /Image to Video, 720p(with audio)`.
The current price in credits (with the options) is `price` of this model in `GET https://api.6io.io/native/sixio/models`; the price charged is the one of the site for your exact input. Check `price` before sending if the cost matters.


# sixio/pixverse-v6/reference-to-video

> Generated from the live model catalog. Index of Sixio models: https://api.6io.io/md/en/sixio-models.md. All pages: https://api.6io.io/llms.txt

Video model of the 6io platform (group `sixio`). Reference to video: generates a video guided by reference images, videos or audio. Accepts: a text prompt, images (links). Has a switch for generated sound.

## How to call it

Submit a task, poll it, download the files. The same three steps work for every `sixio/` model; the full flow, errors and money are in https://api.6io.io/md/en/sixio.md.

```bash
curl -X POST https://api.6io.io/native/sixio/tasks \
  -H "Authorization: Bearer sixio_sk_..." \
  -H "Content-Type: application/json" \
  -d '{"model":"sixio/pixverse-v6/reference-to-video","input":{"prompt":"A paper boat floats down a rainy street"}}'
```

Then `GET https://api.6io.io/native/sixio/tasks/<id>` until `status` is `succeeded` (the files are in `result.urls`) or `failed` (the reason is in `error.message`). To be notified instead of polling, add `webhook_url` to the body: https://api.6io.io/md/en/webhooks.md. Result links are valid for 14 days by default.

## Input fields

The `input` object takes these fields (camelCase names). Values the model does not accept are refused with `422 invalid_input` before any money is reserved.

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `prompt` | string | yes | Text prompt describing what to generate. |
| `aspectRatio` | string | no | Aspect ratio of the result, for example "16:9" or "1:1". |
| `quality` | string | no |  |
| `duration` | integer | no | Length of the video, in seconds. |
| `generateAudio` | boolean | no |  |
| `generateMultiClip` | boolean | no |  |
| `seed` | integer | no | Seed for reproducible results. |
| `imageUrls` | array<string> | no | Public http(s) links to the input images. |
| `firstFrameImageUrl` | string | no |  |
| `lastFrameImageUrl` | string | no |  |
| `imageReferences` | array<object> | no |  |

Set by the model itself (do not send, they cannot be overridden): `mode` = `"reference"`.

Not accepted through the API (the request is refused with `400 unsupported_parameter`): `originalVideoId`. The server measures what the price depends on by itself.

## Example input

```json
{
  "model": "sixio/pixverse-v6/reference-to-video",
  "input": {
    "prompt": "A paper boat floats down a rainy street"
  }
}
```

This example contains the required fields only.

## What the price depends on

The price depends on the variant of the request. Priced variants: `Reference To Video, 1080p(no audio)`, `Reference To Video, 1080p(with audio)`, `Reference To Video, 360p(no audio)`, `Reference To Video, 360p(with audio)`, `Reference To Video, 540p(no audio)`, `Reference To Video, 540p(with audio)`, `Reference To Video, 720p(no audio)`, `Reference To Video, 720p(with audio)`.
The current price in credits (with the options) is `price` of this model in `GET https://api.6io.io/native/sixio/models`; the price charged is the one of the site for your exact input. Check `price` before sending if the cost matters.


# sixio/pixverse-v6/transition

> Generated from the live model catalog. Index of Sixio models: https://api.6io.io/md/en/sixio-models.md. All pages: https://api.6io.io/llms.txt

Video model of the 6io platform (group `sixio`). Transition mode of PixVerse V6. Accepts: a text prompt, images (links). Has a switch for generated sound.

## How to call it

Submit a task, poll it, download the files. The same three steps work for every `sixio/` model; the full flow, errors and money are in https://api.6io.io/md/en/sixio.md.

```bash
curl -X POST https://api.6io.io/native/sixio/tasks \
  -H "Authorization: Bearer sixio_sk_..." \
  -H "Content-Type: application/json" \
  -d '{"model":"sixio/pixverse-v6/transition","input":{"prompt":"A paper boat floats down a rainy street"}}'
```

Then `GET https://api.6io.io/native/sixio/tasks/<id>` until `status` is `succeeded` (the files are in `result.urls`) or `failed` (the reason is in `error.message`). To be notified instead of polling, add `webhook_url` to the body: https://api.6io.io/md/en/webhooks.md. Result links are valid for 14 days by default.

## Input fields

The `input` object takes these fields (camelCase names). Values the model does not accept are refused with `422 invalid_input` before any money is reserved.

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `prompt` | string | yes | Text prompt describing what to generate. |
| `aspectRatio` | string | no | Aspect ratio of the result, for example "16:9" or "1:1". |
| `quality` | string | no |  |
| `duration` | integer | no | Length of the video, in seconds. |
| `generateAudio` | boolean | no |  |
| `generateMultiClip` | boolean | no |  |
| `seed` | integer | no | Seed for reproducible results. |
| `imageUrls` | array<string> | no | Public http(s) links to the input images. |
| `firstFrameImageUrl` | string | no |  |
| `lastFrameImageUrl` | string | no |  |
| `imageReferences` | array<object> | no |  |

Set by the model itself (do not send, they cannot be overridden): `mode` = `"transition"`.

Not accepted through the API (the request is refused with `400 unsupported_parameter`): `originalVideoId`. The server measures what the price depends on by itself.

## Example input

```json
{
  "model": "sixio/pixverse-v6/transition",
  "input": {
    "prompt": "A paper boat floats down a rainy street"
  }
}
```

This example contains the required fields only.

## What the price depends on

The price depends on the variant of the request. Priced variants: `transition, 1080p(no audio)`, `transition, 1080p(with audio)`, `transition, 360p(no audio)`, `transition, 360p(with audio)`, `transition, 540p(no audio)`, `transition, 540p(with audio)`, `transition, 720p(no audio)`, `transition, 720p(with audio)`.
The current price in credits (with the options) is `price` of this model in `GET https://api.6io.io/native/sixio/models`; the price charged is the one of the site for your exact input. Check `price` before sending if the cost matters.


# sixio/pixverse-v6/extend

> Generated from the live model catalog. Index of Sixio models: https://api.6io.io/md/en/sixio-models.md. All pages: https://api.6io.io/llms.txt

Video model of the 6io platform (group `sixio`). Extends an earlier finished video task of yours. Accepts: a text prompt, images (links). Has a switch for generated sound.

## How to call it

Submit a task, poll it, download the files. The same three steps work for every `sixio/` model; the full flow, errors and money are in https://api.6io.io/md/en/sixio.md.

```bash
curl -X POST https://api.6io.io/native/sixio/tasks \
  -H "Authorization: Bearer sixio_sk_..." \
  -H "Content-Type: application/json" \
  -d '{"model":"sixio/pixverse-v6/extend","input":{"prompt":"A paper boat floats down a rainy street"}}'
```

Then `GET https://api.6io.io/native/sixio/tasks/<id>` until `status` is `succeeded` (the files are in `result.urls`) or `failed` (the reason is in `error.message`). To be notified instead of polling, add `webhook_url` to the body: https://api.6io.io/md/en/webhooks.md. Result links are valid for 14 days by default.

## Input fields

The `input` object takes these fields (camelCase names). Values the model does not accept are refused with `422 invalid_input` before any money is reserved.

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `prompt` | string | yes | Text prompt describing what to generate. |
| `aspectRatio` | string | no | Aspect ratio of the result, for example "16:9" or "1:1". |
| `quality` | string | no |  |
| `duration` | integer | no | Length of the video, in seconds. |
| `generateAudio` | boolean | no |  |
| `generateMultiClip` | boolean | no |  |
| `seed` | integer | no | Seed for reproducible results. |
| `imageUrls` | array<string> | no | Public http(s) links to the input images. |
| `firstFrameImageUrl` | string | no |  |
| `lastFrameImageUrl` | string | no |  |
| `originalVideoId` | string | no | The id of your earlier finished sixio task, a string like req_… (not a number) |
| `imageReferences` | array<object> | no |  |

Set by the model itself (do not send, they cannot be overridden): `mode` = `"extend"`.

`originalVideoId` is the `id` of your earlier finished `sixio/` video task, a string like `req_…`. A number, a foreign or an unknown id is refused with `422 invalid_input`.

## Example input

```json
{
  "model": "sixio/pixverse-v6/extend",
  "input": {
    "prompt": "A paper boat floats down a rainy street"
  }
}
```

This example contains the required fields only.

## What the price depends on

The price depends on the variant of the request. Priced variants: `Extend, 1080p(no audio)`, `Extend, 1080p(with audio)`, `Extend, 360p(no audio)`, `Extend, 360p(with audio)`, `Extend, 540p(no audio)`, `Extend, 540p(with audio)`, `Extend, 720p(no audio)`, `Extend, 720p(with audio)`.
The current price in credits (with the options) is `price` of this model in `GET https://api.6io.io/native/sixio/models`; the price charged is the one of the site for your exact input. Check `price` before sending if the cost matters.


# sixio/wan/2-5-text-to-video

> Generated from the live model catalog. Index of Sixio models: https://api.6io.io/md/en/sixio-models.md. All pages: https://api.6io.io/llms.txt

Video model of the 6io platform (group `sixio`). Text to video: generates a video from a text prompt. Accepts: a text prompt, images (links).

## How to call it

Submit a task, poll it, download the files. The same three steps work for every `sixio/` model; the full flow, errors and money are in https://api.6io.io/md/en/sixio.md.

```bash
curl -X POST https://api.6io.io/native/sixio/tasks \
  -H "Authorization: Bearer sixio_sk_..." \
  -H "Content-Type: application/json" \
  -d '{"model":"sixio/wan/2-5-text-to-video","input":{"prompt":"A paper boat floats down a rainy street"}}'
```

Then `GET https://api.6io.io/native/sixio/tasks/<id>` until `status` is `succeeded` (the files are in `result.urls`) or `failed` (the reason is in `error.message`). To be notified instead of polling, add `webhook_url` to the body: https://api.6io.io/md/en/webhooks.md. Result links are valid for 14 days by default.

## Input fields

The `input` object takes these fields (camelCase names). Values the model does not accept are refused with `422 invalid_input` before any money is reserved.

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `prompt` | string | yes | Text prompt describing what to generate. |
| `duration` | string | no | Length of the video, in seconds. |
| `aspectRatio` | string | no | Aspect ratio of the result, for example "16:9" or "1:1". |
| `resolution` | string | no | Output resolution, for example "720p" or "1K". |
| `imageUrl` | string | no | Public http(s) link to the input image. |
| `negativePrompt` | string | no | What the result should avoid. |
| `enablePromptExpansion` | boolean | no |  |
| `seed` | integer | no | Seed for reproducible results. |

## Example input

```json
{
  "model": "sixio/wan/2-5-text-to-video",
  "input": {
    "prompt": "A paper boat floats down a rainy street"
  }
}
```

This example contains the required fields only.

## What the price depends on

The price depends on the variant of the request. Priced variants: `text-to-video, default-10.0s-1080p`, `text-to-video, default-10.0s-720p`, `text-to-video, default-5.0s-1080p`, `text-to-video, default-5.0s-720p`.
The current price in credits (with the options) is `price` of this model in `GET https://api.6io.io/native/sixio/models`; the price charged is the one of the site for your exact input. Check `price` before sending if the cost matters.


# sixio/wan/2-5-image-to-video

> Generated from the live model catalog. Index of Sixio models: https://api.6io.io/md/en/sixio-models.md. All pages: https://api.6io.io/llms.txt

Video model of the 6io platform (group `sixio`). Image to video: animates an input image (or images) following a prompt. Accepts: a text prompt, images (links).

## How to call it

Submit a task, poll it, download the files. The same three steps work for every `sixio/` model; the full flow, errors and money are in https://api.6io.io/md/en/sixio.md.

```bash
curl -X POST https://api.6io.io/native/sixio/tasks \
  -H "Authorization: Bearer sixio_sk_..." \
  -H "Content-Type: application/json" \
  -d '{"model":"sixio/wan/2-5-image-to-video","input":{"prompt":"A paper boat floats down a rainy street"}}'
```

Then `GET https://api.6io.io/native/sixio/tasks/<id>` until `status` is `succeeded` (the files are in `result.urls`) or `failed` (the reason is in `error.message`). To be notified instead of polling, add `webhook_url` to the body: https://api.6io.io/md/en/webhooks.md. Result links are valid for 14 days by default.

## Input fields

The `input` object takes these fields (camelCase names). Values the model does not accept are refused with `422 invalid_input` before any money is reserved.

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `prompt` | string | yes | Text prompt describing what to generate. |
| `duration` | string | no | Length of the video, in seconds. |
| `aspectRatio` | string | no | Aspect ratio of the result, for example "16:9" or "1:1". |
| `resolution` | string | no | Output resolution, for example "720p" or "1K". |
| `imageUrl` | string | no | Public http(s) link to the input image. |
| `negativePrompt` | string | no | What the result should avoid. |
| `enablePromptExpansion` | boolean | no |  |
| `seed` | integer | no | Seed for reproducible results. |

## Example input

```json
{
  "model": "sixio/wan/2-5-image-to-video",
  "input": {
    "prompt": "A paper boat floats down a rainy street"
  }
}
```

This example contains the required fields only.

## What the price depends on

The price depends on the variant of the request. Priced variants: `image-to-video, default-10.0s-1080p`, `image-to-video, default-10.0s-720p`, `image-to-video, default-5.0s-1080p`, `image-to-video, default-5.0s-720p`.
The current price in credits (with the options) is `price` of this model in `GET https://api.6io.io/native/sixio/models`; the price charged is the one of the site for your exact input. Check `price` before sending if the cost matters.


# sixio/wan/2-6-text-to-video

> Generated from the live model catalog. Index of Sixio models: https://api.6io.io/md/en/sixio-models.md. All pages: https://api.6io.io/llms.txt

Video model of the 6io platform (group `sixio`). Text to video: generates a video from a text prompt. Accepts: a text prompt, images (links), videos (links).

## How to call it

Submit a task, poll it, download the files. The same three steps work for every `sixio/` model; the full flow, errors and money are in https://api.6io.io/md/en/sixio.md.

```bash
curl -X POST https://api.6io.io/native/sixio/tasks \
  -H "Authorization: Bearer sixio_sk_..." \
  -H "Content-Type: application/json" \
  -d '{"model":"sixio/wan/2-6-text-to-video","input":{"prompt":"A paper boat floats down a rainy street","duration":"5","resolution":"1080p"}}'
```

Then `GET https://api.6io.io/native/sixio/tasks/<id>` until `status` is `succeeded` (the files are in `result.urls`) or `failed` (the reason is in `error.message`). To be notified instead of polling, add `webhook_url` to the body: https://api.6io.io/md/en/webhooks.md. Result links are valid for 14 days by default.

## Input fields

The `input` object takes these fields (camelCase names). Values the model does not accept are refused with `422 invalid_input` before any money is reserved.

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `prompt` | string | yes | Text prompt describing what to generate. |
| `duration` | string | no | Length of the video, in seconds. |
| `resolution` | string | no | Output resolution, for example "720p" or "1K". |
| `imageUrls` | array<string> | no | Public http(s) links to the input images. |
| `videoUrls` | array<string> | no |  |
| `multiShots` | boolean | no |  |

## Example input

```json
{
  "model": "sixio/wan/2-6-text-to-video",
  "input": {
    "prompt": "A paper boat floats down a rainy street",
    "duration": "5",
    "resolution": "1080p"
  }
}
```

## What the price depends on

The price depends on the variant of the request. Priced variants: `text to video, 10.0s-1080p`, `text to video, 10.0s-720p`, `text to video, 15.0s-1080p`, `text to video, 15.0s-720p`, `text to video, 5.0s-1080p`, `text to video, 5.0s-720p`.
The current price in credits (with the options) is `price` of this model in `GET https://api.6io.io/native/sixio/models`; the price charged is the one of the site for your exact input. Check `price` before sending if the cost matters.


# sixio/wan/2-6-image-to-video

> Generated from the live model catalog. Index of Sixio models: https://api.6io.io/md/en/sixio-models.md. All pages: https://api.6io.io/llms.txt

Video model of the 6io platform (group `sixio`). Image to video: animates an input image (or images) following a prompt. Accepts: a text prompt, images (links), videos (links).

## How to call it

Submit a task, poll it, download the files. The same three steps work for every `sixio/` model; the full flow, errors and money are in https://api.6io.io/md/en/sixio.md.

```bash
curl -X POST https://api.6io.io/native/sixio/tasks \
  -H "Authorization: Bearer sixio_sk_..." \
  -H "Content-Type: application/json" \
  -d '{"model":"sixio/wan/2-6-image-to-video","input":{"prompt":"The boat starts to drift","imageUrls":["https://example.com/boat.png"],"duration":"5","resolution":"1080p"}}'
```

Then `GET https://api.6io.io/native/sixio/tasks/<id>` until `status` is `succeeded` (the files are in `result.urls`) or `failed` (the reason is in `error.message`). To be notified instead of polling, add `webhook_url` to the body: https://api.6io.io/md/en/webhooks.md. Result links are valid for 14 days by default.

## Input fields

The `input` object takes these fields (camelCase names). Values the model does not accept are refused with `422 invalid_input` before any money is reserved.

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `prompt` | string | yes | Text prompt describing what to generate. |
| `duration` | string | no | Length of the video, in seconds. |
| `resolution` | string | no | Output resolution, for example "720p" or "1K". |
| `imageUrls` | array<string> | no | Public http(s) links to the input images. |
| `videoUrls` | array<string> | no |  |
| `multiShots` | boolean | no |  |

## Example input

```json
{
  "model": "sixio/wan/2-6-image-to-video",
  "input": {
    "prompt": "The boat starts to drift",
    "imageUrls": [
      "https://example.com/boat.png"
    ],
    "duration": "5",
    "resolution": "1080p"
  }
}
```

## What the price depends on

The price depends on the variant of the request. Priced variants: `image-to-video, 10.0s-1080p`, `image-to-video, 10.0s-720p`, `image-to-video, 15.0s-1080p`, `image-to-video, 15.0s-720p`, `image-to-video, 5.0s-1080p`, `image-to-video, 5.0s-720p`.
The current price in credits (with the options) is `price` of this model in `GET https://api.6io.io/native/sixio/models`; the price charged is the one of the site for your exact input. Check `price` before sending if the cost matters.


# sixio/wan/2-6-video-to-video

> Generated from the live model catalog. Index of Sixio models: https://api.6io.io/md/en/sixio-models.md. All pages: https://api.6io.io/llms.txt

Video model of the 6io platform (group `sixio`). Video to video: transforms an input video following a prompt. Accepts: a text prompt, images (links), videos (links).

## How to call it

Submit a task, poll it, download the files. The same three steps work for every `sixio/` model; the full flow, errors and money are in https://api.6io.io/md/en/sixio.md.

```bash
curl -X POST https://api.6io.io/native/sixio/tasks \
  -H "Authorization: Bearer sixio_sk_..." \
  -H "Content-Type: application/json" \
  -d '{"model":"sixio/wan/2-6-video-to-video","input":{"prompt":"A paper boat floats down a rainy street"}}'
```

Then `GET https://api.6io.io/native/sixio/tasks/<id>` until `status` is `succeeded` (the files are in `result.urls`) or `failed` (the reason is in `error.message`). To be notified instead of polling, add `webhook_url` to the body: https://api.6io.io/md/en/webhooks.md. Result links are valid for 14 days by default.

## Input fields

The `input` object takes these fields (camelCase names). Values the model does not accept are refused with `422 invalid_input` before any money is reserved.

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `prompt` | string | yes | Text prompt describing what to generate. |
| `duration` | string | no | Length of the video, in seconds. |
| `resolution` | string | no | Output resolution, for example "720p" or "1K". |
| `imageUrls` | array<string> | no | Public http(s) links to the input images. |
| `videoUrls` | array<string> | no |  |
| `multiShots` | boolean | no |  |

## Example input

```json
{
  "model": "sixio/wan/2-6-video-to-video",
  "input": {
    "prompt": "A paper boat floats down a rainy street"
  }
}
```

This example contains the required fields only.

## What the price depends on

The price depends on the variant of the request. Priced variants: `video-to-video, 10.0s-1080p`, `video-to-video, 10.0s-720p`, `video-to-video, 5.0s-1080p`, `video-to-video, 5.0s-720p`.
The current price in credits (with the options) is `price` of this model in `GET https://api.6io.io/native/sixio/models`; the price charged is the one of the site for your exact input. Check `price` before sending if the cost matters.


# sixio/wan-ai/wan-2-6/flash/image-to-video

> Generated from the live model catalog. Index of Sixio models: https://api.6io.io/md/en/sixio-models.md. All pages: https://api.6io.io/llms.txt

Video model of the 6io platform (group `sixio`). Image to video: animates an input image (or images) following a prompt. Accepts: a text prompt, images (links). Has a switch for generated sound.

## How to call it

Submit a task, poll it, download the files. The same three steps work for every `sixio/` model; the full flow, errors and money are in https://api.6io.io/md/en/sixio.md.

```bash
curl -X POST https://api.6io.io/native/sixio/tasks \
  -H "Authorization: Bearer sixio_sk_..." \
  -H "Content-Type: application/json" \
  -d '{"model":"sixio/wan-ai/wan-2-6/flash/image-to-video","input":{"prompt":"The boat starts to drift","imageUrl":"https://example.com/boat.png","duration":5,"resolution":"720p"}}'
```

Then `GET https://api.6io.io/native/sixio/tasks/<id>` until `status` is `succeeded` (the files are in `result.urls`) or `failed` (the reason is in `error.message`). To be notified instead of polling, add `webhook_url` to the body: https://api.6io.io/md/en/webhooks.md. Result links are valid for 14 days by default.

## Input fields

The `input` object takes these fields (camelCase names). Values the model does not accept are refused with `422 invalid_input` before any money is reserved.

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `prompt` | string | yes | Text prompt describing what to generate. |
| `imageUrl` | string | yes | Public http(s) link to the input image. |
| `duration` | integer | no | Length of the video, in seconds. |
| `resolution` | string | no | Output resolution, for example "720p" or "1K". |
| `shotType` | string | no |  |
| `negativePrompt` | string | no | What the result should avoid. |
| `seed` | integer | no | Seed for reproducible results. |
| `promptExtend` | boolean | no |  |
| `audio` | boolean | no |  |

## Example input

```json
{
  "model": "sixio/wan-ai/wan-2-6/flash/image-to-video",
  "input": {
    "prompt": "The boat starts to drift",
    "imageUrl": "https://example.com/boat.png",
    "duration": 5,
    "resolution": "720p"
  }
}
```

## What the price depends on

The price depends on the variant of the request. Priced variants: `5 s, 720p, no audio`, `5 s, 720p, with audio`, `5 s, 1080p, no audio`, `5 s, 1080p, with audio`, `10 s, 720p, no audio`, `10 s, 720p, with audio`, `10 s, 1080p, no audio`, `10 s, 1080p, with audio`, `15 s, 720p, no audio`, `15 s, 720p, with audio`, `15 s, 1080p, no audio`, `15 s, 1080p, with audio`.
The current price in credits (with the options) is `price` of this model in `GET https://api.6io.io/native/sixio/models`; the price charged is the one of the site for your exact input. Check `price` before sending if the cost matters.


# sixio/wan/2-7-text-to-video

> Generated from the live model catalog. Index of Sixio models: https://api.6io.io/md/en/sixio-models.md. All pages: https://api.6io.io/llms.txt

Video model of the 6io platform (group `sixio`). Text to video: generates a video from a text prompt. Accepts: a text prompt, images (links), videos (links), audio (links).

## How to call it

Submit a task, poll it, download the files. The same three steps work for every `sixio/` model; the full flow, errors and money are in https://api.6io.io/md/en/sixio.md.

```bash
curl -X POST https://api.6io.io/native/sixio/tasks \
  -H "Authorization: Bearer sixio_sk_..." \
  -H "Content-Type: application/json" \
  -d '{"model":"sixio/wan/2-7-text-to-video","input":{}}'
```

Then `GET https://api.6io.io/native/sixio/tasks/<id>` until `status` is `succeeded` (the files are in `result.urls`) or `failed` (the reason is in `error.message`). To be notified instead of polling, add `webhook_url` to the body: https://api.6io.io/md/en/webhooks.md. Result links are valid for 14 days by default.

## Input fields

The `input` object takes these fields (camelCase names). Values the model does not accept are refused with `422 invalid_input` before any money is reserved.

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `prompt` | string | no | Text prompt describing what to generate. |
| `negativePrompt` | string | no | What the result should avoid. |
| `duration` | integer | no | Length of the video, in seconds. |
| `videoDurationSec` | number | no | Optional hint; the server measures the real length of the video. |
| `resolution` | string | no | Output resolution, for example "720p" or "1K". |
| `ratio` | string | no |  |
| `audioUrl` | string | no | Public http(s) link to the input audio. |
| `firstFrameUrl` | string | no |  |
| `lastFrameUrl` | string | no |  |
| `firstClipUrl` | string | no |  |
| `drivingAudioUrl` | string | no |  |
| `referenceImages` | array<string> | no |  |
| `referenceVideos` | array<string> | no |  |
| `firstFrame` | string | no |  |
| `referenceVoice` | string | no |  |
| `videoUrl` | string | no | Public http(s) link to the input video. |
| `imageUrls` | array<string> | no | Public http(s) links to the input images. |
| `audioSetting` | string | no |  |
| `trimStart` | number | no |  |
| `trimDuration` | integer | no |  |
| `referenceVideoTrims` | array<object> | no |  |
| `seed` | integer | no | Seed for reproducible results. |

## Example input

```json
{
  "model": "sixio/wan/2-7-text-to-video",
  "input": {}
}
```

This example contains the required fields only.

## What the price depends on

The price depends on the variant of the request. Priced variants: `text-to-video, 1080p`, `text-to-video, 720p`.
The current price in credits (with the options) is `price` of this model in `GET https://api.6io.io/native/sixio/models`; the price charged is the one of the site for your exact input. Check `price` before sending if the cost matters.


# sixio/wan/2-7-image-to-video

> Generated from the live model catalog. Index of Sixio models: https://api.6io.io/md/en/sixio-models.md. All pages: https://api.6io.io/llms.txt

Video model of the 6io platform (group `sixio`). Image to video: animates an input image (or images) following a prompt. Accepts: a text prompt, images (links), videos (links), audio (links).

## How to call it

Submit a task, poll it, download the files. The same three steps work for every `sixio/` model; the full flow, errors and money are in https://api.6io.io/md/en/sixio.md.

```bash
curl -X POST https://api.6io.io/native/sixio/tasks \
  -H "Authorization: Bearer sixio_sk_..." \
  -H "Content-Type: application/json" \
  -d '{"model":"sixio/wan/2-7-image-to-video","input":{}}'
```

Then `GET https://api.6io.io/native/sixio/tasks/<id>` until `status` is `succeeded` (the files are in `result.urls`) or `failed` (the reason is in `error.message`). To be notified instead of polling, add `webhook_url` to the body: https://api.6io.io/md/en/webhooks.md. Result links are valid for 14 days by default.

## Input fields

The `input` object takes these fields (camelCase names). Values the model does not accept are refused with `422 invalid_input` before any money is reserved.

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `prompt` | string | no | Text prompt describing what to generate. |
| `negativePrompt` | string | no | What the result should avoid. |
| `duration` | integer | no | Length of the video, in seconds. |
| `videoDurationSec` | number | no | Optional hint; the server measures the real length of the video. |
| `resolution` | string | no | Output resolution, for example "720p" or "1K". |
| `ratio` | string | no |  |
| `audioUrl` | string | no | Public http(s) link to the input audio. |
| `firstFrameUrl` | string | no |  |
| `lastFrameUrl` | string | no |  |
| `firstClipUrl` | string | no |  |
| `drivingAudioUrl` | string | no |  |
| `referenceImages` | array<string> | no |  |
| `referenceVideos` | array<string> | no |  |
| `firstFrame` | string | no |  |
| `referenceVoice` | string | no |  |
| `videoUrl` | string | no | Public http(s) link to the input video. |
| `imageUrls` | array<string> | no | Public http(s) links to the input images. |
| `audioSetting` | string | no |  |
| `trimStart` | number | no |  |
| `trimDuration` | integer | no |  |
| `referenceVideoTrims` | array<object> | no |  |
| `seed` | integer | no | Seed for reproducible results. |

## Example input

```json
{
  "model": "sixio/wan/2-7-image-to-video",
  "input": {}
}
```

This example contains the required fields only.

## What the price depends on

The price depends on the variant of the request. Priced variants: `image-to-video, 1080p`, `image-to-video, 720p`.
The current price in credits (with the options) is `price` of this model in `GET https://api.6io.io/native/sixio/models`; the price charged is the one of the site for your exact input. Check `price` before sending if the cost matters.


# sixio/wan/2-7-r2v

> Generated from the live model catalog. Index of Sixio models: https://api.6io.io/md/en/sixio-models.md. All pages: https://api.6io.io/llms.txt

Video model of the 6io platform (group `sixio`). Reference to video: generates a video guided by reference images, videos or audio. Accepts: a text prompt, images (links), videos (links), audio (links).

## How to call it

Submit a task, poll it, download the files. The same three steps work for every `sixio/` model; the full flow, errors and money are in https://api.6io.io/md/en/sixio.md.

```bash
curl -X POST https://api.6io.io/native/sixio/tasks \
  -H "Authorization: Bearer sixio_sk_..." \
  -H "Content-Type: application/json" \
  -d '{"model":"sixio/wan/2-7-r2v","input":{}}'
```

Then `GET https://api.6io.io/native/sixio/tasks/<id>` until `status` is `succeeded` (the files are in `result.urls`) or `failed` (the reason is in `error.message`). To be notified instead of polling, add `webhook_url` to the body: https://api.6io.io/md/en/webhooks.md. Result links are valid for 14 days by default.

## Input fields

The `input` object takes these fields (camelCase names). Values the model does not accept are refused with `422 invalid_input` before any money is reserved.

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `prompt` | string | no | Text prompt describing what to generate. |
| `negativePrompt` | string | no | What the result should avoid. |
| `duration` | integer | no | Length of the video, in seconds. |
| `videoDurationSec` | number | no | Optional hint; the server measures the real length of the video. |
| `resolution` | string | no | Output resolution, for example "720p" or "1K". |
| `ratio` | string | no |  |
| `audioUrl` | string | no | Public http(s) link to the input audio. |
| `firstFrameUrl` | string | no |  |
| `lastFrameUrl` | string | no |  |
| `firstClipUrl` | string | no |  |
| `drivingAudioUrl` | string | no |  |
| `referenceImages` | array<string> | no |  |
| `referenceVideos` | array<string> | no |  |
| `firstFrame` | string | no |  |
| `referenceVoice` | string | no |  |
| `videoUrl` | string | no | Public http(s) link to the input video. |
| `imageUrls` | array<string> | no | Public http(s) links to the input images. |
| `audioSetting` | string | no |  |
| `trimStart` | number | no |  |
| `trimDuration` | integer | no |  |
| `referenceVideoTrims` | array<object> | no |  |
| `seed` | integer | no | Seed for reproducible results. |

## Example input

```json
{
  "model": "sixio/wan/2-7-r2v",
  "input": {}
}
```

This example contains the required fields only.

## What the price depends on

The price depends on the variant of the request. Priced variants: `r2v, 1080p`, `r2v, 720p`.
The current price in credits (with the options) is `price` of this model in `GET https://api.6io.io/native/sixio/models`; the price charged is the one of the site for your exact input. Check `price` before sending if the cost matters.


# sixio/wan/2-7-videoedit

> Generated from the live model catalog. Index of Sixio models: https://api.6io.io/md/en/sixio-models.md. All pages: https://api.6io.io/llms.txt

Video model of the 6io platform (group `sixio`). Video editing: edits an input video following a prompt. Accepts: a text prompt, images (links), videos (links), audio (links).

## How to call it

Submit a task, poll it, download the files. The same three steps work for every `sixio/` model; the full flow, errors and money are in https://api.6io.io/md/en/sixio.md.

```bash
curl -X POST https://api.6io.io/native/sixio/tasks \
  -H "Authorization: Bearer sixio_sk_..." \
  -H "Content-Type: application/json" \
  -d '{"model":"sixio/wan/2-7-videoedit","input":{}}'
```

Then `GET https://api.6io.io/native/sixio/tasks/<id>` until `status` is `succeeded` (the files are in `result.urls`) or `failed` (the reason is in `error.message`). To be notified instead of polling, add `webhook_url` to the body: https://api.6io.io/md/en/webhooks.md. Result links are valid for 14 days by default.

## Input fields

The `input` object takes these fields (camelCase names). Values the model does not accept are refused with `422 invalid_input` before any money is reserved.

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `prompt` | string | no | Text prompt describing what to generate. |
| `negativePrompt` | string | no | What the result should avoid. |
| `duration` | integer | no | Length of the video, in seconds. |
| `videoDurationSec` | number | no | Optional hint; the server measures the real length of the video. |
| `resolution` | string | no | Output resolution, for example "720p" or "1K". |
| `ratio` | string | no |  |
| `audioUrl` | string | no | Public http(s) link to the input audio. |
| `firstFrameUrl` | string | no |  |
| `lastFrameUrl` | string | no |  |
| `firstClipUrl` | string | no |  |
| `drivingAudioUrl` | string | no |  |
| `referenceImages` | array<string> | no |  |
| `referenceVideos` | array<string> | no |  |
| `firstFrame` | string | no |  |
| `referenceVoice` | string | no |  |
| `videoUrl` | string | no | Public http(s) link to the input video. |
| `imageUrls` | array<string> | no | Public http(s) links to the input images. |
| `audioSetting` | string | no |  |
| `trimStart` | number | no |  |
| `trimDuration` | integer | no |  |
| `referenceVideoTrims` | array<object> | no |  |
| `seed` | integer | no | Seed for reproducible results. |

## Example input

```json
{
  "model": "sixio/wan/2-7-videoedit",
  "input": {}
}
```

This example contains the required fields only.

## What the price depends on

The price depends on the variant of the request. Priced variants: `videoedit, 1080p`, `videoedit, 720p`.
The current price in credits (with the options) is `price` of this model in `GET https://api.6io.io/native/sixio/models`; the price charged is the one of the site for your exact input. Check `price` before sending if the cost matters.


# sixio/wan/3-0-video

> Generated from the live model catalog. Index of Sixio models: https://api.6io.io/md/en/sixio-models.md. All pages: https://api.6io.io/llms.txt

Video model of the 6io platform (group `sixio`). Video generation model. Accepts: a text prompt, images (links), videos (links), audio (links). Has a switch for generated sound.

## How to call it

Submit a task, poll it, download the files. The same three steps work for every `sixio/` model; the full flow, errors and money are in https://api.6io.io/md/en/sixio.md.

```bash
curl -X POST https://api.6io.io/native/sixio/tasks \
  -H "Authorization: Bearer sixio_sk_..." \
  -H "Content-Type: application/json" \
  -d '{"model":"sixio/wan/3-0-video","input":{}}'
```

Then `GET https://api.6io.io/native/sixio/tasks/<id>` until `status` is `succeeded` (the files are in `result.urls`) or `failed` (the reason is in `error.message`). To be notified instead of polling, add `webhook_url` to the body: https://api.6io.io/md/en/webhooks.md. Result links are valid for 14 days by default.

## Input fields

The `input` object takes these fields (camelCase names). Values the model does not accept are refused with `422 invalid_input` before any money is reserved.

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `prompt` | string | no | Text prompt describing what to generate. |
| `mode` | string | no |  |
| `duration` | integer | no | Length of the video, in seconds. |
| `resolution` | string | no | Output resolution, for example "720p" or "1K". |
| `aspectRatio` | string | no | Aspect ratio of the result, for example "16:9" or "1:1". |
| `audio` | boolean | no |  |
| `seed` | integer | no | Seed for reproducible results. |
| `firstFrameUrl` | string | no |  |
| `lastFrameUrl` | string | no |  |
| `referenceImageUrls` | array<string> | no | Public http(s) links to reference images. |
| `referenceVideoUrls` | array<string> | no | Public http(s) links to reference videos. The server downloads and measures them: the price depends on their length. |
| `referenceAudioUrls` | array<string> | no |  |
| `referenceFileUrls` | array<string> | no |  |
| `referenceLinkUrls` | array<string> | no |  |
| `referenceVideoTrims` | array<object> | no |  |
| `referenceAudioTrims` | array<object> | no |  |
| `inputVideoSeconds` | integer | no | Optional hint; the server measures the real length of the videos. |

Set by the model itself (do not send, they cannot be overridden): `tier` = `"standard"`.

## Example input

```json
{
  "model": "sixio/wan/3-0-video",
  "input": {}
}
```

This example contains the required fields only.

## What the price depends on

The price depends on the variant of the request. Priced variants: `1080p, video`, `480p, video`, `720p, video`.
The current price in credits (with the options) is `price` of this model in `GET https://api.6io.io/native/sixio/models`; the price charged is the one of the site for your exact input. Check `price` before sending if the cost matters.


# sixio/wan/3-0-video-prime

> Generated from the live model catalog. Index of Sixio models: https://api.6io.io/md/en/sixio-models.md. All pages: https://api.6io.io/llms.txt

Video model of the 6io platform (group `sixio`). Video generation model. Accepts: a text prompt, images (links), videos (links), audio (links). Has a switch for generated sound.

## How to call it

Submit a task, poll it, download the files. The same three steps work for every `sixio/` model; the full flow, errors and money are in https://api.6io.io/md/en/sixio.md.

```bash
curl -X POST https://api.6io.io/native/sixio/tasks \
  -H "Authorization: Bearer sixio_sk_..." \
  -H "Content-Type: application/json" \
  -d '{"model":"sixio/wan/3-0-video-prime","input":{}}'
```

Then `GET https://api.6io.io/native/sixio/tasks/<id>` until `status` is `succeeded` (the files are in `result.urls`) or `failed` (the reason is in `error.message`). To be notified instead of polling, add `webhook_url` to the body: https://api.6io.io/md/en/webhooks.md. Result links are valid for 14 days by default.

## Input fields

The `input` object takes these fields (camelCase names). Values the model does not accept are refused with `422 invalid_input` before any money is reserved.

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `prompt` | string | no | Text prompt describing what to generate. |
| `mode` | string | no |  |
| `duration` | integer | no | Length of the video, in seconds. |
| `resolution` | string | no | Output resolution, for example "720p" or "1K". |
| `aspectRatio` | string | no | Aspect ratio of the result, for example "16:9" or "1:1". |
| `audio` | boolean | no |  |
| `seed` | integer | no | Seed for reproducible results. |
| `firstFrameUrl` | string | no |  |
| `lastFrameUrl` | string | no |  |
| `referenceImageUrls` | array<string> | no | Public http(s) links to reference images. |
| `referenceVideoUrls` | array<string> | no | Public http(s) links to reference videos. The server downloads and measures them: the price depends on their length. |
| `referenceAudioUrls` | array<string> | no |  |
| `referenceFileUrls` | array<string> | no |  |
| `referenceLinkUrls` | array<string> | no |  |
| `referenceVideoTrims` | array<object> | no |  |
| `referenceAudioTrims` | array<object> | no |  |
| `inputVideoSeconds` | integer | no | Optional hint; the server measures the real length of the videos. |

Set by the model itself (do not send, they cannot be overridden): `tier` = `"prime"`.

## Example input

```json
{
  "model": "sixio/wan/3-0-video-prime",
  "input": {}
}
```

This example contains the required fields only.

## What the price depends on

The price depends on the variant of the request. Priced variants: `1080p, video`, `480p, video`, `720p, video`.
The current price in credits (with the options) is `price` of this model in `GET https://api.6io.io/native/sixio/models`; the price charged is the one of the site for your exact input. Check `price` before sending if the cost matters.


# sixio/flux-3/klein-text-to-image

> Generated from the live model catalog. Index of Sixio models: https://api.6io.io/md/en/sixio-models.md. All pages: https://api.6io.io/llms.txt

Image model of the 6io platform (group `sixio`). Text to image: generates an image from a text prompt. Accepts: a text prompt, images (links).

## How to call it

Submit a task, poll it, download the files. The same three steps work for every `sixio/` model; the full flow, errors and money are in https://api.6io.io/md/en/sixio.md.

```bash
curl -X POST https://api.6io.io/native/sixio/tasks \
  -H "Authorization: Bearer sixio_sk_..." \
  -H "Content-Type: application/json" \
  -d '{"model":"sixio/flux-3/klein-text-to-image","input":{"prompt":"a red circle on white background","aspectRatio":"1:1","resolution":"1K"}}'
```

Then `GET https://api.6io.io/native/sixio/tasks/<id>` until `status` is `succeeded` (the files are in `result.urls`) or `failed` (the reason is in `error.message`). To be notified instead of polling, add `webhook_url` to the body: https://api.6io.io/md/en/webhooks.md. Result links are valid for 14 days by default.

## Input fields

The `input` object takes these fields (camelCase names). Values the model does not accept are refused with `422 invalid_input` before any money is reserved.

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `prompt` | string | no | Text prompt describing what to generate. |
| `aspectRatio` | string | no | Aspect ratio of the result, for example "16:9" or "1:1". |
| `resolution` | string | no | Output resolution, for example "720p" or "1K". |
| `outputFormat` | string | no |  |
| `sourceImageUrls` | array<string> | no | Public http(s) links to the images to edit. |
| `extraParams` | object | no | Extra options of this model, passed as on the 6io site (an object). |

Not accepted through the API (the request is refused with `400 unsupported_parameter`): `parentImageId`, `expectedCredits`. The server measures what the price depends on by itself.

## Example input

```json
{
  "model": "sixio/flux-3/klein-text-to-image",
  "input": {
    "prompt": "a red circle on white background",
    "aspectRatio": "1:1",
    "resolution": "1K"
  }
}
```

## What the price depends on

The price depends on the variant of the request. Priced variants: `text to image, 1K`, `text to image, 2K`, `text to image, 4K`.
The current price in credits (with the options) is `price` of this model in `GET https://api.6io.io/native/sixio/models`; the price charged is the one of the site for your exact input. Check `price` before sending if the cost matters.


# sixio/gpt-image/1.5-text-to-image

> Generated from the live model catalog. Index of Sixio models: https://api.6io.io/md/en/sixio-models.md. All pages: https://api.6io.io/llms.txt

Image model of the 6io platform (group `sixio`). Text to image: generates an image from a text prompt. Accepts: a text prompt, images (links).

## How to call it

Submit a task, poll it, download the files. The same three steps work for every `sixio/` model; the full flow, errors and money are in https://api.6io.io/md/en/sixio.md.

```bash
curl -X POST https://api.6io.io/native/sixio/tasks \
  -H "Authorization: Bearer sixio_sk_..." \
  -H "Content-Type: application/json" \
  -d '{"model":"sixio/gpt-image/1.5-text-to-image","input":{}}'
```

Then `GET https://api.6io.io/native/sixio/tasks/<id>` until `status` is `succeeded` (the files are in `result.urls`) or `failed` (the reason is in `error.message`). To be notified instead of polling, add `webhook_url` to the body: https://api.6io.io/md/en/webhooks.md. Result links are valid for 14 days by default.

## Input fields

The `input` object takes these fields (camelCase names). Values the model does not accept are refused with `422 invalid_input` before any money is reserved.

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `prompt` | string | no | Text prompt describing what to generate. |
| `aspectRatio` | string | no | Aspect ratio of the result, for example "16:9" or "1:1". |
| `resolution` | string | no | Output resolution, for example "720p" or "1K". |
| `outputFormat` | string | no |  |
| `sourceImageUrls` | array<string> | no | Public http(s) links to the images to edit. |
| `extraParams` | object | no | Extra options of this model, passed as on the 6io site (an object). |

Not accepted through the API (the request is refused with `400 unsupported_parameter`): `parentImageId`, `expectedCredits`. The server measures what the price depends on by itself.

## Example input

```json
{
  "model": "sixio/gpt-image/1.5-text-to-image",
  "input": {}
}
```

This example contains the required fields only.

## What the price depends on

The price depends on the variant of the request. Priced variants: `text-to-image, high`, `text-to-image, medium`.
The current price in credits (with the options) is `price` of this model in `GET https://api.6io.io/native/sixio/models`; the price charged is the one of the site for your exact input. Check `price` before sending if the cost matters.


# sixio/gpt-image/1.5-image-to-image

> Generated from the live model catalog. Index of Sixio models: https://api.6io.io/md/en/sixio-models.md. All pages: https://api.6io.io/llms.txt

Image model of the 6io platform (group `sixio`). Image editing: edits or restyles input images following a prompt. Accepts: a text prompt, images (links).

## How to call it

Submit a task, poll it, download the files. The same three steps work for every `sixio/` model; the full flow, errors and money are in https://api.6io.io/md/en/sixio.md.

```bash
curl -X POST https://api.6io.io/native/sixio/tasks \
  -H "Authorization: Bearer sixio_sk_..." \
  -H "Content-Type: application/json" \
  -d '{"model":"sixio/gpt-image/1.5-image-to-image","input":{}}'
```

Then `GET https://api.6io.io/native/sixio/tasks/<id>` until `status` is `succeeded` (the files are in `result.urls`) or `failed` (the reason is in `error.message`). To be notified instead of polling, add `webhook_url` to the body: https://api.6io.io/md/en/webhooks.md. Result links are valid for 14 days by default.

## Input fields

The `input` object takes these fields (camelCase names). Values the model does not accept are refused with `422 invalid_input` before any money is reserved.

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `prompt` | string | no | Text prompt describing what to generate. |
| `aspectRatio` | string | no | Aspect ratio of the result, for example "16:9" or "1:1". |
| `resolution` | string | no | Output resolution, for example "720p" or "1K". |
| `outputFormat` | string | no |  |
| `sourceImageUrls` | array<string> | no | Public http(s) links to the images to edit. |
| `extraParams` | object | no | Extra options of this model, passed as on the 6io site (an object). |

Not accepted through the API (the request is refused with `400 unsupported_parameter`): `parentImageId`, `expectedCredits`. The server measures what the price depends on by itself.

## Example input

```json
{
  "model": "sixio/gpt-image/1.5-image-to-image",
  "input": {}
}
```

This example contains the required fields only.

## What the price depends on

The price depends on the variant of the request. Priced variants: `image-to-image, high`, `image-to-image, medium`.
The current price in credits (with the options) is `price` of this model in `GET https://api.6io.io/native/sixio/models`; the price charged is the one of the site for your exact input. Check `price` before sending if the cost matters.


# sixio/grok-imagine-image-2-0/text-to-image

> Generated from the live model catalog. Index of Sixio models: https://api.6io.io/md/en/sixio-models.md. All pages: https://api.6io.io/llms.txt

Image model of the 6io platform (group `sixio`). Text to image: generates an image from a text prompt. Accepts: a text prompt, images (links).

## How to call it

Submit a task, poll it, download the files. The same three steps work for every `sixio/` model; the full flow, errors and money are in https://api.6io.io/md/en/sixio.md.

```bash
curl -X POST https://api.6io.io/native/sixio/tasks \
  -H "Authorization: Bearer sixio_sk_..." \
  -H "Content-Type: application/json" \
  -d '{"model":"sixio/grok-imagine-image-2-0/text-to-image","input":{}}'
```

Then `GET https://api.6io.io/native/sixio/tasks/<id>` until `status` is `succeeded` (the files are in `result.urls`) or `failed` (the reason is in `error.message`). To be notified instead of polling, add `webhook_url` to the body: https://api.6io.io/md/en/webhooks.md. Result links are valid for 14 days by default.

## Input fields

The `input` object takes these fields (camelCase names). Values the model does not accept are refused with `422 invalid_input` before any money is reserved.

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `prompt` | string | no | Text prompt describing what to generate. |
| `aspectRatio` | string | no | Aspect ratio of the result, for example "16:9" or "1:1". |
| `resolution` | string | no | Output resolution, for example "720p" or "1K". |
| `outputFormat` | string | no |  |
| `sourceImageUrls` | array<string> | no | Public http(s) links to the images to edit. |
| `extraParams` | object | no | Extra options of this model, passed as on the 6io site (an object). |

Not accepted through the API (the request is refused with `400 unsupported_parameter`): `parentImageId`, `expectedCredits`. The server measures what the price depends on by itself.

## Example input

```json
{
  "model": "sixio/grok-imagine-image-2-0/text-to-image",
  "input": {}
}
```

This example contains the required fields only.

## What the price depends on

The price depends on the variant of the request. Priced variants: `Text to Image`.
The current price in credits (with the options) is `price` of this model in `GET https://api.6io.io/native/sixio/models`; the price charged is the one of the site for your exact input. Check `price` before sending if the cost matters.


# sixio/grok-imagine-image-2-0/image-edit

> Generated from the live model catalog. Index of Sixio models: https://api.6io.io/md/en/sixio-models.md. All pages: https://api.6io.io/llms.txt

Image model of the 6io platform (group `sixio`). Image editing: edits or restyles input images following a prompt. Accepts: a text prompt, images (links).

## How to call it

Submit a task, poll it, download the files. The same three steps work for every `sixio/` model; the full flow, errors and money are in https://api.6io.io/md/en/sixio.md.

```bash
curl -X POST https://api.6io.io/native/sixio/tasks \
  -H "Authorization: Bearer sixio_sk_..." \
  -H "Content-Type: application/json" \
  -d '{"model":"sixio/grok-imagine-image-2-0/image-edit","input":{}}'
```

Then `GET https://api.6io.io/native/sixio/tasks/<id>` until `status` is `succeeded` (the files are in `result.urls`) or `failed` (the reason is in `error.message`). To be notified instead of polling, add `webhook_url` to the body: https://api.6io.io/md/en/webhooks.md. Result links are valid for 14 days by default.

## Input fields

The `input` object takes these fields (camelCase names). Values the model does not accept are refused with `422 invalid_input` before any money is reserved.

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `prompt` | string | no | Text prompt describing what to generate. |
| `aspectRatio` | string | no | Aspect ratio of the result, for example "16:9" or "1:1". |
| `resolution` | string | no | Output resolution, for example "720p" or "1K". |
| `outputFormat` | string | no |  |
| `sourceImageUrls` | array<string> | no | Public http(s) links to the images to edit. |
| `extraParams` | object | no | Extra options of this model, passed as on the 6io site (an object). |

Not accepted through the API (the request is refused with `400 unsupported_parameter`): `parentImageId`, `expectedCredits`. The server measures what the price depends on by itself.

## Example input

```json
{
  "model": "sixio/grok-imagine-image-2-0/image-edit",
  "input": {}
}
```

This example contains the required fields only.

## What the price depends on

The price depends on the variant of the request. Priced variants: `Image Edit`.
The current price in credits (with the options) is `price` of this model in `GET https://api.6io.io/native/sixio/models`; the price charged is the one of the site for your exact input. Check `price` before sending if the cost matters.


# sixio/nano-banana-2

> Generated from the live model catalog. Index of Sixio models: https://api.6io.io/md/en/sixio-models.md. All pages: https://api.6io.io/llms.txt

Image model of the 6io platform (group `sixio`). Image generation model. Accepts: a text prompt, images (links).

## How to call it

Submit a task, poll it, download the files. The same three steps work for every `sixio/` model; the full flow, errors and money are in https://api.6io.io/md/en/sixio.md.

```bash
curl -X POST https://api.6io.io/native/sixio/tasks \
  -H "Authorization: Bearer sixio_sk_..." \
  -H "Content-Type: application/json" \
  -d '{"model":"sixio/nano-banana-2","input":{}}'
```

Then `GET https://api.6io.io/native/sixio/tasks/<id>` until `status` is `succeeded` (the files are in `result.urls`) or `failed` (the reason is in `error.message`). To be notified instead of polling, add `webhook_url` to the body: https://api.6io.io/md/en/webhooks.md. Result links are valid for 14 days by default.

## Input fields

The `input` object takes these fields (camelCase names). Values the model does not accept are refused with `422 invalid_input` before any money is reserved.

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `prompt` | string | no | Text prompt describing what to generate. |
| `aspectRatio` | string | no | Aspect ratio of the result, for example "16:9" or "1:1". |
| `resolution` | string | no | Output resolution, for example "720p" or "1K". |
| `outputFormat` | string | no |  |
| `sourceImageUrls` | array<string> | no | Public http(s) links to the images to edit. |
| `extraParams` | object | no | Extra options of this model, passed as on the 6io site (an object). |

Not accepted through the API (the request is refused with `400 unsupported_parameter`): `parentImageId`, `expectedCredits`. The server measures what the price depends on by itself.

## Example input

```json
{
  "model": "sixio/nano-banana-2",
  "input": {}
}
```

This example contains the required fields only.

## What the price depends on

The price depends on the variant of the request. Priced variants: `1K`, `2K`, `4K`.
The current price in credits (with the options) is `price` of this model in `GET https://api.6io.io/native/sixio/models`; the price charged is the one of the site for your exact input. Check `price` before sending if the cost matters.


# sixio/nano-banana-2-1

> Generated from the live model catalog. Index of Sixio models: https://api.6io.io/md/en/sixio-models.md. All pages: https://api.6io.io/llms.txt

Image model of the 6io platform (group `sixio`). Image generation model. Accepts: a text prompt, images (links).

## How to call it

Submit a task, poll it, download the files. The same three steps work for every `sixio/` model; the full flow, errors and money are in https://api.6io.io/md/en/sixio.md.

```bash
curl -X POST https://api.6io.io/native/sixio/tasks \
  -H "Authorization: Bearer sixio_sk_..." \
  -H "Content-Type: application/json" \
  -d '{"model":"sixio/nano-banana-2-1","input":{}}'
```

Then `GET https://api.6io.io/native/sixio/tasks/<id>` until `status` is `succeeded` (the files are in `result.urls`) or `failed` (the reason is in `error.message`). To be notified instead of polling, add `webhook_url` to the body: https://api.6io.io/md/en/webhooks.md. Result links are valid for 14 days by default.

## Input fields

The `input` object takes these fields (camelCase names). Values the model does not accept are refused with `422 invalid_input` before any money is reserved.

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `prompt` | string | no | Text prompt describing what to generate. |
| `aspectRatio` | string | no | Aspect ratio of the result, for example "16:9" or "1:1". |
| `resolution` | string | no | Output resolution, for example "720p" or "1K". |
| `outputFormat` | string | no |  |
| `sourceImageUrls` | array<string> | no | Public http(s) links to the images to edit. |
| `extraParams` | object | no | Extra options of this model, passed as on the 6io site (an object). |

Not accepted through the API (the request is refused with `400 unsupported_parameter`): `parentImageId`, `expectedCredits`. The server measures what the price depends on by itself.

## Example input

```json
{
  "model": "sixio/nano-banana-2-1",
  "input": {}
}
```

This example contains the required fields only.

## What the price depends on

The price depends on the variant of the request. Priced variants: `1K`, `2K`, `4K`.
The current price in credits (with the options) is `price` of this model in `GET https://api.6io.io/native/sixio/models`; the price charged is the one of the site for your exact input. Check `price` before sending if the cost matters.


# sixio/nano-banana-2-lite

> Generated from the live model catalog. Index of Sixio models: https://api.6io.io/md/en/sixio-models.md. All pages: https://api.6io.io/llms.txt

Image model of the 6io platform (group `sixio`). Image generation model. Accepts: a text prompt, images (links).

## How to call it

Submit a task, poll it, download the files. The same three steps work for every `sixio/` model; the full flow, errors and money are in https://api.6io.io/md/en/sixio.md.

```bash
curl -X POST https://api.6io.io/native/sixio/tasks \
  -H "Authorization: Bearer sixio_sk_..." \
  -H "Content-Type: application/json" \
  -d '{"model":"sixio/nano-banana-2-lite","input":{}}'
```

Then `GET https://api.6io.io/native/sixio/tasks/<id>` until `status` is `succeeded` (the files are in `result.urls`) or `failed` (the reason is in `error.message`). To be notified instead of polling, add `webhook_url` to the body: https://api.6io.io/md/en/webhooks.md. Result links are valid for 14 days by default.

## Input fields

The `input` object takes these fields (camelCase names). Values the model does not accept are refused with `422 invalid_input` before any money is reserved.

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `prompt` | string | no | Text prompt describing what to generate. |
| `aspectRatio` | string | no | Aspect ratio of the result, for example "16:9" or "1:1". |
| `resolution` | string | no | Output resolution, for example "720p" or "1K". |
| `outputFormat` | string | no |  |
| `sourceImageUrls` | array<string> | no | Public http(s) links to the images to edit. |
| `extraParams` | object | no | Extra options of this model, passed as on the 6io site (an object). |

Not accepted through the API (the request is refused with `400 unsupported_parameter`): `parentImageId`, `expectedCredits`. The server measures what the price depends on by itself.

## Example input

```json
{
  "model": "sixio/nano-banana-2-lite",
  "input": {}
}
```

This example contains the required fields only.

## What the price depends on

The price depends on the variant of the request. Priced variants: `1k`.
The current price in credits (with the options) is `price` of this model in `GET https://api.6io.io/native/sixio/models`; the price charged is the one of the site for your exact input. Check `price` before sending if the cost matters.


# sixio/nano-banana-pro

> Generated from the live model catalog. Index of Sixio models: https://api.6io.io/md/en/sixio-models.md. All pages: https://api.6io.io/llms.txt

Image model of the 6io platform (group `sixio`). Image generation model. Accepts: a text prompt, images (links).

## How to call it

Submit a task, poll it, download the files. The same three steps work for every `sixio/` model; the full flow, errors and money are in https://api.6io.io/md/en/sixio.md.

```bash
curl -X POST https://api.6io.io/native/sixio/tasks \
  -H "Authorization: Bearer sixio_sk_..." \
  -H "Content-Type: application/json" \
  -d '{"model":"sixio/nano-banana-pro","input":{}}'
```

Then `GET https://api.6io.io/native/sixio/tasks/<id>` until `status` is `succeeded` (the files are in `result.urls`) or `failed` (the reason is in `error.message`). To be notified instead of polling, add `webhook_url` to the body: https://api.6io.io/md/en/webhooks.md. Result links are valid for 14 days by default.

## Input fields

The `input` object takes these fields (camelCase names). Values the model does not accept are refused with `422 invalid_input` before any money is reserved.

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `prompt` | string | no | Text prompt describing what to generate. |
| `aspectRatio` | string | no | Aspect ratio of the result, for example "16:9" or "1:1". |
| `resolution` | string | no | Output resolution, for example "720p" or "1K". |
| `outputFormat` | string | no |  |
| `sourceImageUrls` | array<string> | no | Public http(s) links to the images to edit. |
| `extraParams` | object | no | Extra options of this model, passed as on the 6io site (an object). |

Not accepted through the API (the request is refused with `400 unsupported_parameter`): `parentImageId`, `expectedCredits`. The server measures what the price depends on by itself.

## Example input

```json
{
  "model": "sixio/nano-banana-pro",
  "input": {}
}
```

This example contains the required fields only.

## What the price depends on

The price depends on the variant of the request. Priced variants: `1/2K`, `4K`.
The current price in credits (with the options) is `price` of this model in `GET https://api.6io.io/native/sixio/models`; the price charged is the one of the site for your exact input. Check `price` before sending if the cost matters.


# sixio/qwen2-1/text-to-image

> Generated from the live model catalog. Index of Sixio models: https://api.6io.io/md/en/sixio-models.md. All pages: https://api.6io.io/llms.txt

Image model of the 6io platform (group `sixio`). Text to image: generates an image from a text prompt. Accepts: a text prompt, images (links).

## How to call it

Submit a task, poll it, download the files. The same three steps work for every `sixio/` model; the full flow, errors and money are in https://api.6io.io/md/en/sixio.md.

```bash
curl -X POST https://api.6io.io/native/sixio/tasks \
  -H "Authorization: Bearer sixio_sk_..." \
  -H "Content-Type: application/json" \
  -d '{"model":"sixio/qwen2-1/text-to-image","input":{}}'
```

Then `GET https://api.6io.io/native/sixio/tasks/<id>` until `status` is `succeeded` (the files are in `result.urls`) or `failed` (the reason is in `error.message`). To be notified instead of polling, add `webhook_url` to the body: https://api.6io.io/md/en/webhooks.md. Result links are valid for 14 days by default.

## Input fields

The `input` object takes these fields (camelCase names). Values the model does not accept are refused with `422 invalid_input` before any money is reserved.

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `prompt` | string | no | Text prompt describing what to generate. |
| `aspectRatio` | string | no | Aspect ratio of the result, for example "16:9" or "1:1". |
| `resolution` | string | no | Output resolution, for example "720p" or "1K". |
| `outputFormat` | string | no |  |
| `sourceImageUrls` | array<string> | no | Public http(s) links to the images to edit. |
| `extraParams` | object | no | Extra options of this model, passed as on the 6io site (an object). |

Not accepted through the API (the request is refused with `400 unsupported_parameter`): `parentImageId`, `expectedCredits`. The server measures what the price depends on by itself.

## Example input

```json
{
  "model": "sixio/qwen2-1/text-to-image",
  "input": {}
}
```

This example contains the required fields only.

## What the price depends on

The price depends on the variant of the request. Priced variants: `text to image, 1K`, `text to image, 2K`.
The current price in credits (with the options) is `price` of this model in `GET https://api.6io.io/native/sixio/models`; the price charged is the one of the site for your exact input. Check `price` before sending if the cost matters.


# sixio/seedream/4.5-text-to-image

> Generated from the live model catalog. Index of Sixio models: https://api.6io.io/md/en/sixio-models.md. All pages: https://api.6io.io/llms.txt

Image model of the 6io platform (group `sixio`). Text to image: generates an image from a text prompt. Accepts: a text prompt, images (links).

## How to call it

Submit a task, poll it, download the files. The same three steps work for every `sixio/` model; the full flow, errors and money are in https://api.6io.io/md/en/sixio.md.

```bash
curl -X POST https://api.6io.io/native/sixio/tasks \
  -H "Authorization: Bearer sixio_sk_..." \
  -H "Content-Type: application/json" \
  -d '{"model":"sixio/seedream/4.5-text-to-image","input":{}}'
```

Then `GET https://api.6io.io/native/sixio/tasks/<id>` until `status` is `succeeded` (the files are in `result.urls`) or `failed` (the reason is in `error.message`). To be notified instead of polling, add `webhook_url` to the body: https://api.6io.io/md/en/webhooks.md. Result links are valid for 14 days by default.

## Input fields

The `input` object takes these fields (camelCase names). Values the model does not accept are refused with `422 invalid_input` before any money is reserved.

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `prompt` | string | no | Text prompt describing what to generate. |
| `aspectRatio` | string | no | Aspect ratio of the result, for example "16:9" or "1:1". |
| `resolution` | string | no | Output resolution, for example "720p" or "1K". |
| `outputFormat` | string | no |  |
| `sourceImageUrls` | array<string> | no | Public http(s) links to the images to edit. |
| `extraParams` | object | no | Extra options of this model, passed as on the 6io site (an object). |

Not accepted through the API (the request is refused with `400 unsupported_parameter`): `parentImageId`, `expectedCredits`. The server measures what the price depends on by itself.

## Example input

```json
{
  "model": "sixio/seedream/4.5-text-to-image",
  "input": {}
}
```

This example contains the required fields only.

## What the price depends on

The price depends on the variant of the request. Priced variants: `text-to-image`.
The current price in credits (with the options) is `price` of this model in `GET https://api.6io.io/native/sixio/models`; the price charged is the one of the site for your exact input. Check `price` before sending if the cost matters.


# sixio/seedream/4.5-edit

> Generated from the live model catalog. Index of Sixio models: https://api.6io.io/md/en/sixio-models.md. All pages: https://api.6io.io/llms.txt

Image model of the 6io platform (group `sixio`). Image editing: edits or restyles input images following a prompt. Accepts: a text prompt, images (links).

## How to call it

Submit a task, poll it, download the files. The same three steps work for every `sixio/` model; the full flow, errors and money are in https://api.6io.io/md/en/sixio.md.

```bash
curl -X POST https://api.6io.io/native/sixio/tasks \
  -H "Authorization: Bearer sixio_sk_..." \
  -H "Content-Type: application/json" \
  -d '{"model":"sixio/seedream/4.5-edit","input":{}}'
```

Then `GET https://api.6io.io/native/sixio/tasks/<id>` until `status` is `succeeded` (the files are in `result.urls`) or `failed` (the reason is in `error.message`). To be notified instead of polling, add `webhook_url` to the body: https://api.6io.io/md/en/webhooks.md. Result links are valid for 14 days by default.

## Input fields

The `input` object takes these fields (camelCase names). Values the model does not accept are refused with `422 invalid_input` before any money is reserved.

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `prompt` | string | no | Text prompt describing what to generate. |
| `aspectRatio` | string | no | Aspect ratio of the result, for example "16:9" or "1:1". |
| `resolution` | string | no | Output resolution, for example "720p" or "1K". |
| `outputFormat` | string | no |  |
| `sourceImageUrls` | array<string> | no | Public http(s) links to the images to edit. |
| `extraParams` | object | no | Extra options of this model, passed as on the 6io site (an object). |

Not accepted through the API (the request is refused with `400 unsupported_parameter`): `parentImageId`, `expectedCredits`. The server measures what the price depends on by itself.

## Example input

```json
{
  "model": "sixio/seedream/4.5-edit",
  "input": {}
}
```

This example contains the required fields only.

## What the price depends on

The price depends on the variant of the request. Priced variants: `image-to-image`.
The current price in credits (with the options) is `price` of this model in `GET https://api.6io.io/native/sixio/models`; the price charged is the one of the site for your exact input. Check `price` before sending if the cost matters.


# sixio/seedream/5-lite-text-to-image

> Generated from the live model catalog. Index of Sixio models: https://api.6io.io/md/en/sixio-models.md. All pages: https://api.6io.io/llms.txt

Image model of the 6io platform (group `sixio`). Text to image: generates an image from a text prompt. Accepts: a text prompt, images (links).

## How to call it

Submit a task, poll it, download the files. The same three steps work for every `sixio/` model; the full flow, errors and money are in https://api.6io.io/md/en/sixio.md.

```bash
curl -X POST https://api.6io.io/native/sixio/tasks \
  -H "Authorization: Bearer sixio_sk_..." \
  -H "Content-Type: application/json" \
  -d '{"model":"sixio/seedream/5-lite-text-to-image","input":{}}'
```

Then `GET https://api.6io.io/native/sixio/tasks/<id>` until `status` is `succeeded` (the files are in `result.urls`) or `failed` (the reason is in `error.message`). To be notified instead of polling, add `webhook_url` to the body: https://api.6io.io/md/en/webhooks.md. Result links are valid for 14 days by default.

## Input fields

The `input` object takes these fields (camelCase names). Values the model does not accept are refused with `422 invalid_input` before any money is reserved.

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `prompt` | string | no | Text prompt describing what to generate. |
| `aspectRatio` | string | no | Aspect ratio of the result, for example "16:9" or "1:1". |
| `resolution` | string | no | Output resolution, for example "720p" or "1K". |
| `outputFormat` | string | no |  |
| `sourceImageUrls` | array<string> | no | Public http(s) links to the images to edit. |
| `extraParams` | object | no | Extra options of this model, passed as on the 6io site (an object). |

Not accepted through the API (the request is refused with `400 unsupported_parameter`): `parentImageId`, `expectedCredits`. The server measures what the price depends on by itself.

## Example input

```json
{
  "model": "sixio/seedream/5-lite-text-to-image",
  "input": {}
}
```

This example contains the required fields only.

## What the price depends on

The price depends on the variant of the request. Priced variants: `text-to-image`.
The current price in credits (with the options) is `price` of this model in `GET https://api.6io.io/native/sixio/models`; the price charged is the one of the site for your exact input. Check `price` before sending if the cost matters.


# sixio/seedream/5-lite-image-to-image

> Generated from the live model catalog. Index of Sixio models: https://api.6io.io/md/en/sixio-models.md. All pages: https://api.6io.io/llms.txt

Image model of the 6io platform (group `sixio`). Image editing: edits or restyles input images following a prompt. Accepts: a text prompt, images (links).

## How to call it

Submit a task, poll it, download the files. The same three steps work for every `sixio/` model; the full flow, errors and money are in https://api.6io.io/md/en/sixio.md.

```bash
curl -X POST https://api.6io.io/native/sixio/tasks \
  -H "Authorization: Bearer sixio_sk_..." \
  -H "Content-Type: application/json" \
  -d '{"model":"sixio/seedream/5-lite-image-to-image","input":{}}'
```

Then `GET https://api.6io.io/native/sixio/tasks/<id>` until `status` is `succeeded` (the files are in `result.urls`) or `failed` (the reason is in `error.message`). To be notified instead of polling, add `webhook_url` to the body: https://api.6io.io/md/en/webhooks.md. Result links are valid for 14 days by default.

## Input fields

The `input` object takes these fields (camelCase names). Values the model does not accept are refused with `422 invalid_input` before any money is reserved.

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `prompt` | string | no | Text prompt describing what to generate. |
| `aspectRatio` | string | no | Aspect ratio of the result, for example "16:9" or "1:1". |
| `resolution` | string | no | Output resolution, for example "720p" or "1K". |
| `outputFormat` | string | no |  |
| `sourceImageUrls` | array<string> | no | Public http(s) links to the images to edit. |
| `extraParams` | object | no | Extra options of this model, passed as on the 6io site (an object). |

Not accepted through the API (the request is refused with `400 unsupported_parameter`): `parentImageId`, `expectedCredits`. The server measures what the price depends on by itself.

## Example input

```json
{
  "model": "sixio/seedream/5-lite-image-to-image",
  "input": {}
}
```

This example contains the required fields only.

## What the price depends on

The price depends on the variant of the request. Priced variants: `image-to-image`.
The current price in credits (with the options) is `price` of this model in `GET https://api.6io.io/native/sixio/models`; the price charged is the one of the site for your exact input. Check `price` before sending if the cost matters.


# sixio/seedream/5-pro-text-to-image

> Generated from the live model catalog. Index of Sixio models: https://api.6io.io/md/en/sixio-models.md. All pages: https://api.6io.io/llms.txt

Image model of the 6io platform (group `sixio`). Text to image: generates an image from a text prompt. Accepts: a text prompt, images (links).

## How to call it

Submit a task, poll it, download the files. The same three steps work for every `sixio/` model; the full flow, errors and money are in https://api.6io.io/md/en/sixio.md.

```bash
curl -X POST https://api.6io.io/native/sixio/tasks \
  -H "Authorization: Bearer sixio_sk_..." \
  -H "Content-Type: application/json" \
  -d '{"model":"sixio/seedream/5-pro-text-to-image","input":{}}'
```

Then `GET https://api.6io.io/native/sixio/tasks/<id>` until `status` is `succeeded` (the files are in `result.urls`) or `failed` (the reason is in `error.message`). To be notified instead of polling, add `webhook_url` to the body: https://api.6io.io/md/en/webhooks.md. Result links are valid for 14 days by default.

## Input fields

The `input` object takes these fields (camelCase names). Values the model does not accept are refused with `422 invalid_input` before any money is reserved.

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `prompt` | string | no | Text prompt describing what to generate. |
| `aspectRatio` | string | no | Aspect ratio of the result, for example "16:9" or "1:1". |
| `resolution` | string | no | Output resolution, for example "720p" or "1K". |
| `outputFormat` | string | no |  |
| `sourceImageUrls` | array<string> | no | Public http(s) links to the images to edit. |
| `extraParams` | object | no | Extra options of this model, passed as on the 6io site (an object). |

Not accepted through the API (the request is refused with `400 unsupported_parameter`): `parentImageId`, `expectedCredits`. The server measures what the price depends on by itself.

## Example input

```json
{
  "model": "sixio/seedream/5-pro-text-to-image",
  "input": {}
}
```

This example contains the required fields only.

## What the price depends on

The price depends on the variant of the request. Priced variants: `text-to-image, 1K`, `text-to-image, 2K`.
The current price in credits (with the options) is `price` of this model in `GET https://api.6io.io/native/sixio/models`; the price charged is the one of the site for your exact input. Check `price` before sending if the cost matters.


# sixio/seedream/5-pro-image-to-image

> Generated from the live model catalog. Index of Sixio models: https://api.6io.io/md/en/sixio-models.md. All pages: https://api.6io.io/llms.txt

Image model of the 6io platform (group `sixio`). Image editing: edits or restyles input images following a prompt. Accepts: a text prompt, images (links).

## How to call it

Submit a task, poll it, download the files. The same three steps work for every `sixio/` model; the full flow, errors and money are in https://api.6io.io/md/en/sixio.md.

```bash
curl -X POST https://api.6io.io/native/sixio/tasks \
  -H "Authorization: Bearer sixio_sk_..." \
  -H "Content-Type: application/json" \
  -d '{"model":"sixio/seedream/5-pro-image-to-image","input":{}}'
```

Then `GET https://api.6io.io/native/sixio/tasks/<id>` until `status` is `succeeded` (the files are in `result.urls`) or `failed` (the reason is in `error.message`). To be notified instead of polling, add `webhook_url` to the body: https://api.6io.io/md/en/webhooks.md. Result links are valid for 14 days by default.

## Input fields

The `input` object takes these fields (camelCase names). Values the model does not accept are refused with `422 invalid_input` before any money is reserved.

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `prompt` | string | no | Text prompt describing what to generate. |
| `aspectRatio` | string | no | Aspect ratio of the result, for example "16:9" or "1:1". |
| `resolution` | string | no | Output resolution, for example "720p" or "1K". |
| `outputFormat` | string | no |  |
| `sourceImageUrls` | array<string> | no | Public http(s) links to the images to edit. |
| `extraParams` | object | no | Extra options of this model, passed as on the 6io site (an object). |

Not accepted through the API (the request is refused with `400 unsupported_parameter`): `parentImageId`, `expectedCredits`. The server measures what the price depends on by itself.

## Example input

```json
{
  "model": "sixio/seedream/5-pro-image-to-image",
  "input": {}
}
```

This example contains the required fields only.

## What the price depends on

The price depends on the variant of the request. Priced variants: `input image, First image free`.
The current price in credits (with the options) is `price` of this model in `GET https://api.6io.io/native/sixio/models`; the price charged is the one of the site for your exact input. Check `price` before sending if the cost matters.