Source: https://ailoot.ai/models/es-mx/deepseek-ai-deepseek-v4-1-flash/
Canonical: https://ailoot.ai/models/es-mx/deepseek-ai-deepseek-v4-1-flash/
Language: es-mx

# DeepSeek v4.1 Flash

[Markdown](https://ailoot.ai/models/es-mx/deepseek-ai-deepseek-v4-1-flash/index.md) · [JSON](https://ailoot.ai/models/es-mx/deepseek-ai-deepseek-v4-1-flash/facts.json)

## [DeepSeek v4.1 Flash](https://ailoot.ai/models/es-mx/deepseek-ai-deepseek-v4-1-flash/)

DeepSeek V4.1 Flash es un modelo multimodal para analizar texto e imágenes, programar y trabajar con agentes y contexto amplio.

- [**Ailoot · Anthropic Messages** `POST /v1/messages` `deepseek-ai/deepseek-v4.1-flash`](https://ailoot.ai/models/es-mx/deepseek-ai-deepseek-v4-1-flash/#method-0)
- [**Ailoot · OpenAI Chat** `POST /v1/chat/completions` `deepseek-ai/deepseek-v4.1-flash`](https://ailoot.ai/models/es-mx/deepseek-ai-deepseek-v4-1-flash/#method-1)

Sobre el modelo

Esta descripción cubre las capacidades del modelo. Las entradas, salidas y opciones disponibles en Ailoot se indican a continuación para el método seleccionado.

#### Procesamiento conjunto de texto e imágenes

DeepSeek V4.1 Flash es un modelo multimodal desde su diseño: un codificador visual convierte la imagen en una representación que se procesa junto con el texto. El resultado es de texto. Se contemplan comprensión visual, programación y tareas de agentes; el contexto alcanza un millón de tokens.

#### Arquitectura para entradas amplias

La red principal contiene 552 mil millones de parámetros. El codificador causal y el decodificador tienen 20 capas cada uno. Al procesar la entrada se activan 8 mil millones de parámetros por token y, al generar, 16 mil millones. Esta separación está diseñada para tareas en las que el material de entrada es mucho más amplio que la respuesta.

La atención dispersa comprimida reutiliza datos entre capas y limita la búsqueda repetida de las partes relevantes del contexto. Los estados de atención local que faltan se reconstruyen a partir de un fragmento reciente. La memoria condicional Engram contiene 196 mil millones de parámetros y accede a registros mediante búsqueda dispersa por tokens. Es un bloque de memoria independiente, no otra denominación del tamaño de la red principal. Cada capa de expertos tiene un experto compartido y 384 expertos enrutados; se eligen seis expertos enrutados por token. También se utilizan conexiones modificadas entre capas y DSpark para decodificación especulativa.

#### Entrenamiento y entornos de agentes

El modelo se entrenó desde cero con un corpus multimodal de 45 billones de tokens. La preparación posterior sigue esta secuencia: entrenamiento con ejemplos, aprendizaje por refuerzo y después destilación sobre secuencias del propio modelo.

DeepSeek amplía los datos de tareas sintéticas, los entornos de trabajo y las trayectorias de agentes. La preparación relaciona la tarea, el entorno disponible y la forma de comprobar el resultado; los datos se filtran, se eliminan duplicados y se seleccionan según la dificultad. Esto describe el entrenamiento, no la disponibilidad automática de herramientas externas al utilizar el modelo.

#### Profundidad de análisis controlable

El razonamiento se regula con un número entero entre 1 y 100. Esta escala continua define el esfuerzo de análisis; un razonamiento profundo puede requerir más tiempo y tokens.

#### Continuación del diálogo y acciones

El formato del modelo contempla diálogo de varios turnos, llamadas a herramientas, razonamiento guardado y alternancia de texto e imágenes. Las herramientas las ejecuta la aplicación; sus resultados aportan material para el siguiente paso.

La respuesta sigue siendo de texto. La capacidad visual requiere un método de entrada compatible. El tamaño del contexto y la longitud de generación recomendada no establecen un tamaño máximo universal de respuesta.

Tarea práctica

### Tarea práctica

Ejemplo técnico en inglés

```
Trace a data-loss bug from a text log

Use this log and code sketch to identify the likely lost-update mechanism: A reads stock=5; B reads stock=5; A writes 4; B writes 4. Both requests call read(), subtract one, then write(). Explain the failure, propose one atomic update strategy and a concurrent test. Do not assume a specific database or execute anything.
```

#### Resultado esperado

```
A causal diagnosis, database-neutral pseudocode for an atomic decrement and a concurrent-test scenario with the expected final count.
```

#### Comprobar el resultado

```
The test expects stock 3 after two successful decrements from 5, with a stated insufficient-stock rule.
```

**Ailoot · Anthropic Messages** `POST /v1/messages` `deepseek-ai/deepseek-v4.1-flash`

[`deepseek-ai/deepseek-v4.1-flash`](https://ailoot.ai/models/es-mx/#m=deepseek-ai%2Fdeepseek-v4.1-flash&route=Core&caller=deepseek-ai%2Fdeepseek-v4.1-flash&fmt=messages)

DeepSeek /`deepseek-ai/deepseek-v4.1-flash`

### Inicio

DeepSeek V4.1 Flash es un modelo multimodal para analizar texto e imágenes, programar y trabajar con agentes y contexto amplio.

Entradas aceptadas

Texto

Resultados

Texto

### Disponible en Ailoot · entradas y métodos

**Ailoot · Anthropic Messages** `POST /v1/messages`

Entrada

`text`

Salida

`text`

Contexto

1,048,576 tokens

Salida máxima

32,768 tokens

Formato de salida

json o SSE

| Campo | Tipo | Requisito | Valores y límites | Predeterminado |
| --- | --- | --- | --- | --- |
| Campo`model` | Tipo`string` | RequisitoObligatorio | Valores y límites deepseek-ai/deepseek-v4.1-flash | Predeterminado— |
| Campo`messages` | Tipo`message[]` | RequisitoObligatorio | Valores y límites Número mínimo de elementos: 1 | Predeterminado— |
| Campo`messages[].role` | Tipo`string` | RequisitoObligatorio | Valores y límites user, assistant | Predeterminado— |
| Campo`messages[].content` | Tipo`string\|content_block[]` | RequisitoObligatorio | Valores y límites | Predeterminado— |
| Campo`system` | Tipo`string\|content_block[]` | RequisitoOpcional | Valores y límites | Predeterminado— |
| Campo`max_tokens` | Tipo`integer` | RequisitoObligatorio | Valores y límites Mínimo: 1 El límite se aplica a: límite máximo exacto de la ficha del modelo seleccionado | Predeterminado— |
| Campo`stream` | Tipo`boolean` | RequisitoOpcional | Valores y límites | Predeterminadofalse |
| Campo`temperature` | Tipo`number` | RequisitoOpcional | Valores y límites Depende del modelo | Predeterminado— |
| Campo`top_p` | Tipo`number` | RequisitoOpcional | Valores y límites Depende del modelo | Predeterminado— |
| Campo`stop_sequences` | Tipo`string[]` | RequisitoOpcional | Valores y límites Depende del modelo | Predeterminado— |
| Campo`tools` | Tipo`tool[]` | RequisitoOpcional | Valores y límites Depende del modelo | Predeterminado— |
| Campo`tools[].name` | Tipo`string` | RequisitoOpcional | Valores y límites Se aplica cuando: herramienta proporcionada | Predeterminado— |
| Campo`tools[].description` | Tipo`string` | RequisitoOpcional | Valores y límites | Predeterminado— |
| Campo`tools[].input_schema` | Tipo`JSON_schema` | RequisitoOpcional | Valores y límites | Predeterminado— |
| Campo`tool_choice` | Tipo`object` | RequisitoOpcional | Valores y límites Depende del modelo | Predeterminado— |
| Campo`thinking.type` | Tipo`string` | RequisitoOpcional | Valores y límites Depende del modelo | Predeterminado— |
| Campo`thinking.budget_tokens` | Tipo`integer` | RequisitoOpcional | Valores y límites Depende del modelo | Predeterminado— |
| Campo`output_config.effort` | Tipo`string` | RequisitoOpcional | Valores y límites Depende del modelo | Predeterminado— |
| Campo`metadata` | Tipo`object` | RequisitoOpcional | Valores y límites | Predeterminado— |
| Campo`cache_control` | Tipo`object` | RequisitoOpcional | Valores y límites Depende del modelo | Predeterminado— |

Combinaciones de materiales de entrada

**Texto** · Texto UTF8

`messages[].content o bloque type=text`

Parámetros del método y ciclo de vida

| Parámetro | Contrato |
| --- | --- |
| Parámetro`material_types` | Contratotext |
| Parámetro`required` | Contratomodel, messages, max\_tokens |
| Parámetro`optional_controls` | Contratonull |
| Parámetro`content_type` | Contratoapplication/json |
| Parámetro`text_file_material` | Contratocontenido real en UTF-8 insertado como texto; los ID de archivo y las URLs requieren compatibilidad específica e independiente |

Ciclo de vida: `exact retained published method`

Las estructuras e ID de los métodos son exactos; la capacidad del proveedor y la admisión son conceptos distintos.

### Tarifas

#### Tarifas de métodos Ailoot

Entrada

USD 0.0003 */ 1K*

Salida

USD 0.0012 */ 1K*

Lectura de caché

USD 0.000006 */ 1K*

Escritura en caché

USD 0.0003 */ 1K*

Escritura en caché, 5 min

USD 0.0003 */ 1K tokens*

Ailoot reserva un monto estimado antes de la solicitud. Tras obtener el resultado, liquida el cargo definitivo según el uso medido. En las respuestas en flujo, la liquidación usa el registro de uso final. [Cómo funcionan la reserva y la liquidación →](https://ailoot.ai/docs/es-mx/billing/reserve/)

### Solicitudes de ejemplo

#### Ailoot · Anthropic Messages

Ejemplo de textoPython SDKNode.js SDKFlujo en Python

```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_TEXT_FILE:?Set your actual UTF-8 source-material file}"
export AILOOT_TEXT_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "deepseek-ai/deepseek-v4.1-flash", "max_tokens": 1024, "messages": []}')
f=Path(os.environ["AILOOT_TEXT_FILE"])
if not f.is_file():raise SystemExit("Choose your actual UTF-8 source material")
text=f.read_text(encoding="utf-8")
if not text.strip():raise SystemExit("Source material must contain text")
p["messages"]=[{"role":"user","content":"Summarize this material and quote supporting source passages.\n\n"+text}]
Path("request.json").write_text(json.dumps(p,ensure_ascii=False))
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/messages \
  -H "x-api-key: $AILOOT_API_KEY" -H 'anthropic-version: 2023-06-01' -H 'Content-Type: application/json' \
  --data-binary @request.json -D response-headers.txt -o result.json
python3 - <<'PY_RESULT'
import json
from pathlib import Path
print(json.dumps(json.loads(Path("result.json").read_text()),ensure_ascii=False,indent=2))
PY_RESULT
```

```python
import anthropic
import os

if not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")
client = anthropic.Anthropic(base_url="https://api.ailoot.ai", api_key=os.environ["AILOOT_API_KEY"], max_retries=0)
msg = client.messages.create(
    model="deepseek-ai/deepseek-v4.1-flash",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Explain the difference between an observation and a hypothesis in three sentences."}],
)
import base64, json
from pathlib import Path

def save_result(data, stem="result"):
    # Keep every field, including usage, IDs, reasoning and tool requests.
    Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
    print(json.dumps(data, ensure_ascii=False, indent=2))
    def save_blob(encoded, suffix, label):
        raw = base64.b64decode(encoded, altchars=b"-_", validate=True)
        ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix
        file = Path(stem + "-" + label + "." + ext)
        file.write_bytes(raw)
        print("Saved", file)
    for index, block in enumerate(data.get("content") or []):
        print("Content", index, json.dumps(block, ensure_ascii=False))
    for choice in data.get("choices") or []:
        print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))
    for index, item in enumerate(data.get("output") or []):
        print("Output", index, json.dumps(item, ensure_ascii=False))
        if item.get("type") == "image_generation_call" and item.get("result"):
            save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))
    for ci, candidate in enumerate(data.get("candidates") or []):
        for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):
            print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))
            blob = part.get("inlineData") or part.get("inline_data")
            if blob and blob.get("data"):
                mime = blob.get("mimeType") or blob.get("mime_type")
                suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")
                save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))

save_result(msg.to_dict(mode="json"))
```

```js
import Anthropic from "@anthropic-ai/sdk";

if (!process.env.AILOOT_API_KEY?.trim()) throw new Error("Set AILOOT_API_KEY before making a request");
const client = new Anthropic({ baseURL: "https://api.ailoot.ai", apiKey: process.env.AILOOT_API_KEY, maxRetries: 0 });
const msg = await client.messages.create({
  model: "deepseek-ai/deepseek-v4.1-flash",
  max_tokens: 1024,
  messages: [{ role: "user", content: "Explain the difference between an observation and a hypothesis in three sentences." }],
});
import { writeFileSync } from "node:fs";

function saveResult(data, stem = "result") {
  writeFileSync(stem + ".json", JSON.stringify(data, null, 2));
  console.log(JSON.stringify(data, null, 2));
  const saveBlob = (encoded, suffix, label) => {
    const raw = Buffer.from(encoded, "base64");
    const ext = raw.subarray(0,8).equals(Buffer.from([137,80,78,71,13,10,26,10])) ? "png" : raw[0]===255 && raw[1]===216 ? "jpg" : raw.subarray(0,4).toString()==="RIFF" && raw.subarray(8,12).toString()==="WEBP" ? "webp" : suffix;
    const file = `${stem}-${label}.${ext}`;
    writeFileSync(file, raw); console.log("Saved", file);
  };
  for (const [i, block] of (data.content || []).entries()) console.log("Content", i, JSON.stringify(block));
  for (const choice of data.choices || []) console.log("Choice", choice.index, JSON.stringify(choice.message || choice.delta || {}));
  for (const [i, item] of (data.output || []).entries()) {
    console.log("Output", i, JSON.stringify(item));
    if (item.type === "image_generation_call" && item.result) saveBlob(item.result, item.output_format || "bin", `output-${i}`);
  }
  for (const [ci, candidate] of (data.candidates || []).entries()) {
    for (const [pi, part] of (candidate.content?.parts || []).entries()) {
      console.log("Candidate/part", ci, pi, JSON.stringify(part));
      const blob = part.inlineData || part.inline_data;
      if (blob?.data) {
        const mime = blob.mimeType || blob.mime_type;
        const suffix = ({"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"})[mime] || "bin";
        saveBlob(blob.data, suffix, `candidate-${ci}-part-${pi}`);
      }
    }
  }
}

saveResult(msg);
```

```python
import anthropic,os
from pathlib import Path

if not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")
client=anthropic.Anthropic(base_url="https://api.ailoot.ai",api_key=os.environ["AILOOT_API_KEY"],max_retries=0)
import base64, json
from pathlib import Path

def save_result(data, stem="result"):
    # Keep every field, including usage, IDs, reasoning and tool requests.
    Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
    print(json.dumps(data, ensure_ascii=False, indent=2))
    def save_blob(encoded, suffix, label):
        raw = base64.b64decode(encoded, altchars=b"-_", validate=True)
        ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix
        file = Path(stem + "-" + label + "." + ext)
        file.write_bytes(raw)
        print("Saved", file)
    for index, block in enumerate(data.get("content") or []):
        print("Content", index, json.dumps(block, ensure_ascii=False))
    for choice in data.get("choices") or []:
        print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))
    for index, item in enumerate(data.get("output") or []):
        print("Output", index, json.dumps(item, ensure_ascii=False))
        if item.get("type") == "image_generation_call" and item.get("result"):
            save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))
    for ci, candidate in enumerate(data.get("candidates") or []):
        for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):
            print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))
            blob = part.get("inlineData") or part.get("inline_data")
            if blob and blob.get("data"):
                mime = blob.get("mimeType") or blob.get("mime_type")
                suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")
                save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))

with client.messages.stream(model='deepseek-ai/deepseek-v4.1-flash',max_tokens=1024,messages=[{"role":"user","content":"Explain observations and hypotheses in three sentences."}]) as stream:
    with Path("stream-events.jsonl").open("w",encoding="utf-8") as log:
        for event in stream:
            payload=event.to_dict(mode="json")
            log.write(json.dumps(payload,ensure_ascii=False)+"\n"); log.flush()
            print(json.dumps(payload,ensure_ascii=False))
    final=stream.get_final_message()
    save_result(final.to_dict(mode="json"),"stream-result")
```

### Recibir y guardar resultados

#### Ailoot · Anthropic Messages

json o SSE

##### Conserva todos los resultados completados

Conserva todas las respuestas, archivos y partes de contenido completos recibidos.

Conserva todos los bloques de contenido, las firmas de razonamiento y los ID reales de uso de herramientas. Ensambla todos los fragmentos incrementales de los bloques SSE; el primer bloque de texto no constituye la salida completa.

##### Si es necesario revisar la respuesta original

Conserva los ID de solicitud y respuesta y los encabezados. No se proporciona una URL genérica para recuperar tareas de texto.

Campos de respuesta

| Campo | Tipo |
| --- | --- |
| Campo`id` | Tipostring |
| Campo`model` | Tipostring |
| Campo`content[]` | Tipotext\|thinking\|tool\_use\|other content block |
| Campo`stop_reason` | Tipostring\|null |
| Campo`usage` | Tipoobject |

Errores y siguientes pasos

| Respuesta | Condición | Siguiente paso |
| --- | --- | --- |
| Respuesta400 · `invalid_request_error` | CondiciónCampos obligatorios, representación del material o valor del parámetro no válidos | Siguiente pasoCorrige los campos indicados antes de una nueva solicitud de creación. |

### Alias

#### Alias del modelo

**Ailoot** [`deepseek-ai/deepseek-v4.1-flash`](https://ailoot.ai/models/es-mx/#m=deepseek-ai%2Fdeepseek-v4.1-flash&route=Core&caller=deepseek-ai%2Fdeepseek-v4.1-flash&fmt=messages)

#### Alias de rutas de métodos

Usa las rutas de método indicadas arriba.

#### ID de modelo relacionados

[`deepseek-ai/deepseek-v4.1-flash`](https://ailoot.ai/models/es-mx/#m=deepseek-ai%2Fdeepseek-v4.1-flash&route=Core&caller=deepseek-ai%2Fdeepseek-v4.1-flash&fmt=messages)

**Ailoot · OpenAI Chat** `POST /v1/chat/completions` `deepseek-ai/deepseek-v4.1-flash`

[`deepseek-ai/deepseek-v4.1-flash`](https://ailoot.ai/models/es-mx/#m=deepseek-ai%2Fdeepseek-v4.1-flash&route=Core&caller=deepseek-ai%2Fdeepseek-v4.1-flash&fmt=chat)

DeepSeek /`deepseek-ai/deepseek-v4.1-flash`

### Inicio

DeepSeek V4.1 Flash es un modelo multimodal para analizar texto e imágenes, programar y trabajar con agentes y contexto amplio.

Entradas aceptadas

Texto

Resultados

Texto

### Disponible en Ailoot · entradas y métodos

**Ailoot · OpenAI Chat** `POST /v1/chat/completions`

Entrada

`text`

Salida

`text`

Contexto

4,096 tokens

Salida máxima

1,024 tokens

Formato de salida

json o SSE

| Campo | Tipo | Requisito | Valores y límites | Predeterminado |
| --- | --- | --- | --- | --- |
| Campo`model` | Tipo`string` | RequisitoObligatorio | Valores y límites deepseek-ai/deepseek-v4.1-flash | Predeterminado— |
| Campo`messages` | Tipo`message[]` | RequisitoObligatorio | Valores y límites Número mínimo de elementos: 1 | Predeterminado— |
| Campo`messages[].role` | Tipo`string` | RequisitoObligatorio | Valores y límites Ejemplos: system, user, assistant, tool, function Condiciones: Estos roles están representados explícitamente por los tipos de compatibilidad del código fuente; el conjunto exacto de roles depende del modelo. Depende del modelo | Predeterminado— |
| Campo`messages[].content` | Tipo`string\|content_part[]\|null` | RequisitoOpcional | Valores y límites | Predeterminado— |
| Campo`messages[].tool_calls` | Tipo`tool_call[]` | RequisitoOpcional | Valores y límites | Predeterminado— |
| Campo`messages[].tool_call_id` | Tipo`string` | RequisitoOpcional | Valores y límites Se aplica cuando: role=tool; utiliza el ID real devuelto | Predeterminado— |
| Campo`messages[].name` | Tipo`string` | RequisitoOpcional | Valores y límites | Predeterminado— |
| Campo`messages[].reasoning_content` | Tipo`string` | RequisitoOpcional | Valores y límites Se aplica cuando: Devuelve en los turnos siguientes el razonamiento realmente recibido cuando este modelo lo utilice | Predeterminado— |
| Campo`messages[].reasoning_details` | Tipo`object\|array` | RequisitoOpcional | Valores y límites Depende del modelo | Predeterminado— |
| Campo`max_tokens` | Tipo`integer` | RequisitoOpcional | Valores y límites Mínimo: 1 Depende del modelo | Predeterminado— |
| Campo`max_completion_tokens` | Tipo`integer` | RequisitoOpcional | Valores y límites Mínimo: 1 Depende del modelo | Predeterminado— |
| Campo`stream` | Tipo`boolean` | RequisitoOpcional | Valores y límites | Predeterminadofalse |
| Campo`stream_options.include_usage` | Tipo`boolean` | RequisitoOpcional | Valores y límites Depende del modelo | Predeterminado— |
| Campo`temperature` | Tipo`number` | RequisitoOpcional | Valores y límites Depende del modelo | Predeterminado— |
| Campo`top_p` | Tipo`number` | RequisitoOpcional | Valores y límites Depende del modelo | Predeterminado— |
| Campo`stop` | Tipo`string\|string[]` | RequisitoOpcional | Valores y límites Depende del modelo | Predeterminado— |
| Campo`tools` | Tipo`function_tool[]` | RequisitoOpcional | Valores y límites Depende del modelo | Predeterminado— |
| Campo`tools[].type` | Tipo`string` | RequisitoOpcional | Valores y límites Depende del modelo | Predeterminado— |
| Campo`tools[].function.name` | Tipo`string` | RequisitoObligatorio | Valores y límites Se aplica cuando: herramienta de función proporcionada | Predeterminado— |
| Campo`tools[].function.description` | Tipo`string` | RequisitoOpcional | Valores y límites | Predeterminado— |
| Campo`tools[].function.parameters` | Tipo`JSON_schema` | RequisitoOpcional | Valores y límites | Predeterminado— |
| Campo`tool_choice` | Tipo`string\|object` | RequisitoOpcional | Valores y límites Depende del modelo | Predeterminado— |
| Campo`parallel_tool_calls` | Tipo`boolean` | RequisitoOpcional | Valores y límites Depende del modelo | Predeterminado— |
| Campo`response_format` | Tipo`object` | RequisitoOpcional | Valores y límites Depende del modelo | Predeterminado— |
| Campo`reasoning_effort` | Tipo`string` | RequisitoOpcional | Valores y límites Depende del modelo | Predeterminado— |
| Campo`reasoning` | Tipo`object` | RequisitoOpcional | Valores y límites Depende del modelo | Predeterminado— |
| Campo`service_tier` | Tipo`string` | RequisitoOpcional | Valores y límites Depende del modelo | Predeterminado— |
| Campo`instructions` | Tipo`string` | RequisitoOpcional | Valores y límites Campo de compatibilidad | Predeterminado— |
| Campo`functions` | Tipo`function[]` | RequisitoOpcional | Valores y límites Depende del modelo | Predeterminado— |
| Campo`function_call` | Tipo`string\|object` | RequisitoOpcional | Valores y límites Depende del modelo | Predeterminado— |
| Campo`prompt_cache_options` | Tipo`object` | RequisitoOpcional | Valores y límites Depende del modelo | Predeterminado— |

Combinaciones de materiales de entrada

**Texto** · Texto UTF8

`messages[].content`

Parámetros del método y ciclo de vida

| Parámetro | Contrato |
| --- | --- |
| Parámetro`material_types` | Contratotext |
| Parámetro`required` | Contratomodel, messages |
| Parámetro`optional_controls` | Contratonull |
| Parámetro`content_type` | Contratoapplication/json |
| Parámetro`text_file_material` | Contratocontenido real en UTF-8 insertado como texto; los ID de archivo y las URLs requieren compatibilidad específica e independiente |

Ciclo de vida: `exact retained published method`

Las estructuras e ID de los métodos son exactos; la capacidad del proveedor y la admisión son conceptos distintos.

### Tarifas

#### Tarifas de métodos Ailoot

Entrada

USD 0.0003 */ 1K*

Salida

USD 0.0012 */ 1K*

Lectura de caché

USD 0.000006 */ 1K*

Escritura en caché

USD 0.0003 */ 1K*

Escritura en caché, 5 min

USD 0.0003 */ 1K tokens*

Ailoot reserva un monto estimado antes de la solicitud. Tras obtener el resultado, liquida el cargo definitivo según el uso medido. En las respuestas en flujo, la liquidación usa el registro de uso final. [Cómo funcionan la reserva y la liquidación →](https://ailoot.ai/docs/es-mx/billing/reserve/)

### Solicitudes de ejemplo

#### Ailoot · OpenAI Chat

Ejemplo de textoPython SDKNode.js SDKFlujo en Python

```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_TEXT_FILE:?Set your actual UTF-8 source-material file}"
export AILOOT_TEXT_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "deepseek-ai/deepseek-v4.1-flash", "messages": []}')
f=Path(os.environ["AILOOT_TEXT_FILE"])
if not f.is_file():raise SystemExit("Choose your actual UTF-8 source material")
text=f.read_text(encoding="utf-8")
if not text.strip():raise SystemExit("Source material must contain text")
p["messages"]=[{"role":"user","content":"Summarize this material and quote supporting source passages.\n\n"+text}]
Path("request.json").write_text(json.dumps(p,ensure_ascii=False))
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/chat/completions \
  -H "Authorization: Bearer $AILOOT_API_KEY" -H 'Content-Type: application/json' \
  --data-binary @request.json -D response-headers.txt -o result.json
python3 - <<'PY_RESULT'
import json
from pathlib import Path
print(json.dumps(json.loads(Path("result.json").read_text()),ensure_ascii=False,indent=2))
PY_RESULT
```

```python
from openai import OpenAI
import os

if not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")
client = OpenAI(base_url="https://api.ailoot.ai/v1", api_key=os.environ["AILOOT_API_KEY"], max_retries=0)
resp = client.chat.completions.create(
    model="deepseek-ai/deepseek-v4.1-flash",
    messages=[{"role": "user", "content": "Explain the difference between an observation and a hypothesis in three sentences."}],
)
import base64, json
from pathlib import Path

def save_result(data, stem="result"):
    # Keep every field, including usage, IDs, reasoning and tool requests.
    Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
    print(json.dumps(data, ensure_ascii=False, indent=2))
    def save_blob(encoded, suffix, label):
        raw = base64.b64decode(encoded, altchars=b"-_", validate=True)
        ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix
        file = Path(stem + "-" + label + "." + ext)
        file.write_bytes(raw)
        print("Saved", file)
    for index, block in enumerate(data.get("content") or []):
        print("Content", index, json.dumps(block, ensure_ascii=False))
    for choice in data.get("choices") or []:
        print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))
    for index, item in enumerate(data.get("output") or []):
        print("Output", index, json.dumps(item, ensure_ascii=False))
        if item.get("type") == "image_generation_call" and item.get("result"):
            save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))
    for ci, candidate in enumerate(data.get("candidates") or []):
        for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):
            print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))
            blob = part.get("inlineData") or part.get("inline_data")
            if blob and blob.get("data"):
                mime = blob.get("mimeType") or blob.get("mime_type")
                suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")
                save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))

save_result(resp.to_dict(mode="json"))
```

```js
import OpenAI from "openai";

if (!process.env.AILOOT_API_KEY?.trim()) throw new Error("Set AILOOT_API_KEY before making a request");
const client = new OpenAI({ baseURL: "https://api.ailoot.ai/v1", apiKey: process.env.AILOOT_API_KEY, maxRetries: 0 });
const resp = await client.chat.completions.create({
  model: "deepseek-ai/deepseek-v4.1-flash",
  messages: [{ role: "user", content: "Explain the difference between an observation and a hypothesis in three sentences." }],
});
import { writeFileSync } from "node:fs";

function saveResult(data, stem = "result") {
  writeFileSync(stem + ".json", JSON.stringify(data, null, 2));
  console.log(JSON.stringify(data, null, 2));
  const saveBlob = (encoded, suffix, label) => {
    const raw = Buffer.from(encoded, "base64");
    const ext = raw.subarray(0,8).equals(Buffer.from([137,80,78,71,13,10,26,10])) ? "png" : raw[0]===255 && raw[1]===216 ? "jpg" : raw.subarray(0,4).toString()==="RIFF" && raw.subarray(8,12).toString()==="WEBP" ? "webp" : suffix;
    const file = `${stem}-${label}.${ext}`;
    writeFileSync(file, raw); console.log("Saved", file);
  };
  for (const [i, block] of (data.content || []).entries()) console.log("Content", i, JSON.stringify(block));
  for (const choice of data.choices || []) console.log("Choice", choice.index, JSON.stringify(choice.message || choice.delta || {}));
  for (const [i, item] of (data.output || []).entries()) {
    console.log("Output", i, JSON.stringify(item));
    if (item.type === "image_generation_call" && item.result) saveBlob(item.result, item.output_format || "bin", `output-${i}`);
  }
  for (const [ci, candidate] of (data.candidates || []).entries()) {
    for (const [pi, part] of (candidate.content?.parts || []).entries()) {
      console.log("Candidate/part", ci, pi, JSON.stringify(part));
      const blob = part.inlineData || part.inline_data;
      if (blob?.data) {
        const mime = blob.mimeType || blob.mime_type;
        const suffix = ({"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"})[mime] || "bin";
        saveBlob(blob.data, suffix, `candidate-${ci}-part-${pi}`);
      }
    }
  }
}

saveResult(resp);
```

```python
from openai import OpenAI
import os
from pathlib import Path

if not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")
client=OpenAI(base_url="https://api.ailoot.ai/v1",api_key=os.environ["AILOOT_API_KEY"],max_retries=0)
import base64, json
from pathlib import Path

def save_result(data, stem="result"):
    # Keep every field, including usage, IDs, reasoning and tool requests.
    Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
    print(json.dumps(data, ensure_ascii=False, indent=2))
    def save_blob(encoded, suffix, label):
        raw = base64.b64decode(encoded, altchars=b"-_", validate=True)
        ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix
        file = Path(stem + "-" + label + "." + ext)
        file.write_bytes(raw)
        print("Saved", file)
    for index, block in enumerate(data.get("content") or []):
        print("Content", index, json.dumps(block, ensure_ascii=False))
    for choice in data.get("choices") or []:
        print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))
    for index, item in enumerate(data.get("output") or []):
        print("Output", index, json.dumps(item, ensure_ascii=False))
        if item.get("type") == "image_generation_call" and item.get("result"):
            save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))
    for ci, candidate in enumerate(data.get("candidates") or []):
        for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):
            print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))
            blob = part.get("inlineData") or part.get("inline_data")
            if blob and blob.get("data"):
                mime = blob.get("mimeType") or blob.get("mime_type")
                suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")
                save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))

with client.chat.completions.stream(model='deepseek-ai/deepseek-v4.1-flash',messages=[{"role":"user","content":"Explain observations and hypotheses in three sentences."}]) as stream:
    with Path("stream-events.jsonl").open("w",encoding="utf-8") as log:
        for event in stream:
            payload=event.to_dict(mode="json")
            log.write(json.dumps(payload,ensure_ascii=False)+"\n"); log.flush()
            print(json.dumps(payload,ensure_ascii=False))
    final=stream.get_final_completion()
    save_result(final.to_dict(mode="json"),"stream-result")
```

### Recibir y guardar resultados

#### Ailoot · OpenAI Chat

json o SSE

##### Conserva todos los resultados completados

Conserva todas las respuestas, archivos y partes de contenido completos recibidos.

Conserva cada alternativa y su contenido, llamadas de herramientas y razonamiento. En SSE, ensambla los fragmentos incrementales por índice de alternativa/herramienta y conserva el motivo final de terminación y el uso.

##### Si es necesario revisar la respuesta original

Conserva los ID de solicitud y respuesta y los encabezados. No se proporciona una URL genérica para recuperar tareas de texto.

Campos de respuesta

| Campo | Tipo |
| --- | --- |
| Campo`choices[].index` | Tipointeger |
| Campo`choices[].message.content` | Tipostring\|null |
| Campo`choices[].message.tool_calls` | Tipotool\_call\[\] |
| Campo`choices[].message.reasoning_content` | Tipostring |
| Campo`choices[].message.reasoning_details` | Tipoobject\|array |
| Campo`choices[].finish_reason` | Tipostring\|null |
| Campo`usage` | Tipoobject |

Errores y siguientes pasos

| Respuesta | Condición | Siguiente paso |
| --- | --- | --- |
| Respuesta400 · `invalid_request_error` | CondiciónCampos obligatorios, representación del material o valor del parámetro no válidos | Siguiente pasoCorrige los campos indicados antes de una nueva solicitud de creación. |

### Alias

#### Alias del modelo

**Ailoot** [`deepseek-ai/deepseek-v4.1-flash`](https://ailoot.ai/models/es-mx/#m=deepseek-ai%2Fdeepseek-v4.1-flash&route=Core&caller=deepseek-ai%2Fdeepseek-v4.1-flash&fmt=chat)

#### Alias de rutas de métodos

Usa las rutas de método indicadas arriba.

#### ID de modelo relacionados

[`deepseek-ai/deepseek-v4.1-flash`](https://ailoot.ai/models/es-mx/#m=deepseek-ai%2Fdeepseek-v4.1-flash&route=Core&caller=deepseek-ai%2Fdeepseek-v4.1-flash&fmt=chat)

FAQ · deepseek-ai/deepseek-v4.1-flash

¿Qué entradas y resultados están disponibles?

`POST /v1/messages` · `deepseek-ai/deepseek-v4.1-flash`: `text` → `text` `POST /v1/chat/completions` · `deepseek-ai/deepseek-v4.1-flash`: `text` → `text`

¿Qué campos utiliza la solicitud?

`POST /v1/messages` · `deepseek-ai/deepseek-v4.1-flash`: `model`, `messages`, `system`, `max_tokens`, `stream`, `metadata` `POST /v1/chat/completions` · `deepseek-ai/deepseek-v4.1-flash`: `model`, `messages`, `stream`

¿Qué límites se aplican?

`POST /v1/messages` · `deepseek-ai/deepseek-v4.1-flash`: `ctx`: `1048576`; `max_out`: `32768`; `messages.min_items`: `1`; `max_tokens.minimum`: `1` `POST /v1/chat/completions` · `deepseek-ai/deepseek-v4.1-flash`: `ctx`: `4096`; `max_out`: `1024`; `messages.min_items`: `1`

Conecta Ailoot a Claude Code, OpenCode, Hermes o tu aplicación.

## La empresa y su cartera de proyectos

La empresa y su cartera de proyectos: millones de clientes; ventas por miles de millones al mes.

## Compra tokens con descuento.

Ahorro por suscripción para trabajo habitual. Códigos promocionales: hasta el 50% al comprar tokens.

Suscripción

Elige un plan con descuento para tus peticiones habituales.

Código de hasta el 50%

Introduce el código al comprar. El precio se recalcula según la promoción vigente.

Gasto en el historial

Modelo, tokens e importe quedan guardados por cada petición.

[Elegir suscripción](https://ailoot.ai/docs/es-mx/billing/subscriptions/) · [Consultar precios de modelos](https://ailoot.ai/models/es-mx/)

## Conecta la API al producto que vendes.

SaaS, aplicaciones y bots bajo la oferta y el acuerdo de licencia Ailoot. Solicita una licencia de reventa para redistribuir el acceso.

Aplicación comercial

Integra generación de texto, imágenes, vídeo y sonido en funciones de pago de tu servicio.

Licencia para revendedores

Envía descripción del proyecto y esquema de acceso. Solicita condiciones escritas de uso y reventa.

Documentos en la web

La oferta, el acuerdo de licencia y la política de datos están disponibles antes de conectar.

[Solicitar licencia de reventa](mailto:support@ailoot.ai) · [Oferta y acuerdo de licencia](https://ailoot.ai/legal/offer?lang=es-mx)

## Ailoot · La empresa y su cartera de proyectos





Ailoot se apoya en la experiencia operativa acumulada, una amplia base de clientes, un servicio estable y el seguimiento continuo de KPI.





La empresa y su cartera de proyectos: millones de clientes; ventas por miles de millones al mes.





Ailoot aplica esa experiencia operativa al acceso por API a funciones de IA en productos de clientes, agentes, aplicaciones y automatizaciones.