Z.ai: GLM 5.3

Z.ai GLM 5.3 es un modelo de razonamiento textual para ingeniería de software compleja, trabajo en terminal y agentes de largo recorrido. Admite un contexto de 1M tokens documentado por el fabricante, hasta 128K tokens de salida, llamadas a funciones y niveles de esfuerzo de razonamiento low/high/max, con el razonamiento activado en todo momento.

Ailoot · Anthropic Messages POST /v1/messages glm-5.3
Ailoot · OpenAI Responses POST /v1/responses glm-5.3
Ailoot · OpenAI Chat POST /v1/chat/completions glm-5.3
Ailoot Ultra · OpenAI Chat POST /v1/chat/completions glm-5.3
Ailoot Ultra · Anthropic Messages POST /v1/messages glm-5.3
Ailoot · Anthropic Messages POST /v1/messages glm
Ailoot · OpenAI Responses POST /v1/responses glm
Ailoot · OpenAI Chat POST /v1/chat/completions glm
Ailoot · Anthropic Messages POST /v1/messages glm-5
Ailoot · OpenAI Responses POST /v1/responses glm-5
Ailoot · OpenAI Chat POST /v1/chat/completions glm-5
Ailoot · Anthropic Messages POST /v1/messages glm-5.1
Ailoot · OpenAI Responses POST /v1/responses glm-5.1
Ailoot · OpenAI Chat POST /v1/chat/completions glm-5.1
Ailoot · Anthropic Messages POST /v1/messages glm-5.2
Ailoot · OpenAI Responses POST /v1/responses glm-5.2
Ailoot · OpenAI Chat POST /v1/chat/completions glm-5.2
Ailoot · Anthropic Messages POST /v1/messages glm-latest
Ailoot · OpenAI Responses POST /v1/responses glm-latest
Ailoot · OpenAI Chat POST /v1/chat/completions glm-latest
Ailoot Ultra · OpenAI Chat POST /v1/chat/completions z-ai/glm-5.3
Ailoot Ultra · Anthropic Messages POST /v1/messages z-ai/glm-5.3
Ailoot Ultra · OpenAI Chat POST /v1/chat/completions ~z-ai/glm-latest
Ailoot Ultra · Anthropic Messages POST /v1/messages ~z-ai/glm-latest

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.

Z.ai GLM 5.3 es un modelo de razonamiento textual a gran escala diseñado para ingeniería de software compleja y trabajo con agentes de largo recorrido. El fabricante afirma que utiliza el mismo modelo base que GLM 5.2 y que las nuevas mejoras proceden del entrenamiento posterior. La versión se centra en reforzar la programación, las operaciones de terminal y las tareas más amplias que implican varios pasos dependientes. Acepta texto y produce texto, incluido código, explicaciones, planes y solicitudes de llamadas a herramientas en una aplicación conectada a herramientas.

El modo de razonamiento documentado permanece siempre activado. GLM 5.3 ofrece tres niveles de esfuerzo: low, high y max, con max como valor predeterminado. El fabricante recomienda max para programación compleja; low ofrece una opción de razonamiento más ligera para pasos más sencillos. Utiliza el nivel seleccionado junto con un entregable final claro y criterios de finalización. Por ejemplo: «Inspecciona estos archivos y resultados fallidos, rastrea la causa en los módulos afectados, propón una corrección que conserve la interfaz pública y explica qué comprobaciones demuestran que la regresión está resuelta».

El fabricante especifica una ventana de contexto de 1M tokens y una longitud máxima de salida de 128K tokens. Organiza el material extenso en torno a la relación que deba investigar el modelo. Conserva los nombres de archivos, las definiciones pertinentes, las etiquetas de las fuentes y el orden de las observaciones, y deja espacio para el razonamiento y la respuesta final dentro del contexto de trabajo aplicable. Una ventana amplia resulta útil para las dependencias entre módulos o una secuencia larga de observaciones del agente; no convierte un archivo desorganizado de material sin relación en una tarea bien definida.

Para trabajar con repositorios, proporciona el comportamiento esperado, el texto de origen pertinente, las versiones de las dependencias y la salida real del error. Pide al modelo que identifique el comportamiento afectado antes de proponer un parche. Para una refactorización, indica la interfaz y los invariantes que deben conservarse intactos. Una respuesta útil contiene el código revisado, por qué el cambio aborda el problema observado y los casos necesarios para comprobar el resultado. Devuelve los resultados reales a un flujo conectado a herramientas para que el siguiente paso se base en el estado modificado, en lugar de en la propuesta anterior.

Para trabajar sobre el rendimiento, proporciona una carga de trabajo, una referencia inicial y mediciones como tiempos, perfiles o registros de asignación de memoria. Z.ai describe tareas de entrenamiento que implican diagnóstico de cuellos de botella, optimización, experimentos y resultados que preservan la corrección. Una solicitud práctica es: «Utiliza este perfil para identificar el cuello de botella de mayor impacto, propón un cambio medible y explica qué resultado justificaría conservarlo». Distingue una hipótesis de rendimiento de una mejora registrada. Conserva la misma carga de trabajo y las condiciones pertinentes al inspeccionar un resultado.

La versión también desarrolla la capacidad de análisis de vulnerabilidades. Para una revisión defensiva del código fuente, proporciona el código pertinente, sus límites de confianza previstos y las condiciones en las que se ejecuta. Solicita un hallazgo que conecte un posible problema con la entrada y el comportamiento afectados y con una corrección concreta. Separa una posible debilidad de un fallo reproducido y conserva la observación utilizada para validarlo. Un informe resulta más útil cuando prioriza las evidencias concretas y las correcciones propuestas, en lugar de tratar cada patrón sospechoso como una vulnerabilidad confirmada.

Las llamadas a funciones permiten que una aplicación que rodea al modelo le exponga operaciones externas. Define la finalidad, los argumentos y el resultado esperado de cada herramienta; después, devuelve la observación real de la herramienta para el siguiente paso. El modelo puede razonar sobre ese resultado y decidir cómo modifica la tarea. Mantén diferenciadas las acciones propuestas, las operaciones ejecutadas y las comprobaciones sin resolver. El fabricante también documenta respuestas transmitidas en continuo, que devuelven por separado los fragmentos de razonamiento y respuesta; ensambla la respuesta completa antes de tratarla como informe final o explicación del código.

La ficha local del modelo proporciona un detalle específico sobre el ajuste del historial: su plantilla de chat conserva el pensamiento de forma predeterminada, mientras que el fabricante recomienda borrar explícitamente el pensamiento anterior para los escenarios de chat habituales. Aplica la estructura de conversación adecuada al caso de uso, conservando las respuestas realmente completadas y los resultados de herramientas necesarios para continuar. Evita tratar los ajustes de control del razonamiento de GLM 5.2 o de las ediciones independientes GLM 5.3 Flash como intercambiables con los controles low/high/max de este modelo.

Para resultados estructurados, especifica los campos, los tipos y las reglas de origen esperados. Un artefacto útil puede ser una tabla de defectos, un plan de cambios o un objeto JSON que resuma observaciones. Valida tanto la estructura como los valores antes de que los utilice una aplicación. El resultado final debe identificar la respuesta o el artefacto revisado, las evidencias que lo respaldan y las suposiciones pendientes. Un mayor esfuerzo de razonamiento no demuestra que se haya ejecutado una herramienta, que un parche propuesto haya superado sus comprobaciones ni que una afirmación factual tenga respaldo más allá del material proporcionado.

Tarea práctica

Ejemplo técnico en inglés

Target a measured bottleneck

Profile P1 for one import: parsing 0.4 s, per-row database lookups 8.1 s, writing 0.8 s. The import handles 10,000 rows, including repeated customer IDs. Propose one correctness-preserving optimization, describe what lookup behavior must remain identical and define a same-workload check before claiming an improvement.

Resultado esperado

A bottleneck hypothesis, one proposed change and a correctness plus timing comparison plan.

Comprobar el resultado

The proposal must use P1 without inventing an observed speedup or losing missing-customer behavior.

Ailoot · Anthropic Messages POST /v1/messages glm-5.3

glm-5.3

Z.ai /glm-5.3

ID del modelo

glm-5.3
glm
glm-5
glm-5.1
glm-5.2
glm-latest

Primeros pasos

Entradas aceptadas: Texto
Resultados: Texto

Disponible en Ailoot · entradas y métodos

Ailoot · Anthropic Messages POST /v1/messages

Tipos de entrada: text
Tipos de salida: text
Contexto: 1.000.000 tokens
Salida máxima: 131.072 tokens
Formato de salida: json o SSE

Campo	Tipo	Requisito	Valores y límites	Predeterminado
Campo`model`	Tipo`string`	RequisitoObligatorio	Valores y límites glm-5.3	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.

Planes

Tarifas de métodos Ailoot

Ailoot Anthropic MessagesPOST /v1/messages

Entrada: 0,0014 US$ / 1K
Salida: 0,0044 US$ / 1K
Lectura de caché: ≈0,00026 US$ / 1K

Ailoot reserva un importe 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 →

Detalles de la tarifa de referencia

Las tablas de referencia del modelo no cambian la selección del método, las estimaciones de coste ni los cargos. Los cargos aplicados usan las tarifas del método Ailoot seleccionado.

Tablas de referencia del modelo

Precios por configuración

Relaciona cada cargo con las condiciones mostradas. Usa una tarifa para cada conjunto de configuraciones alternativas.

Configuración	Tabla de tarifas	Tokens de contexto, más de	Tokens de contexto, hasta inclusive	Cargo
ConfiguraciónOpenAI Chat · Tarifas base por token	Tabla de tarifasTarifa base	Tokens de contexto, más de—	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens
ConfiguraciónOpenAI Chat · Nivel 1 según la longitud de la solicitud	Tabla de tarifas—	Tokens de contexto, más de0	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens
ConfiguraciónAnthropic Messages · Tarifas base por token	Tabla de tarifasTarifa base	Tokens de contexto, más de—	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens
ConfiguraciónAnthropic Messages · Nivel 1 según la longitud de la solicitud	Tabla de tarifas—	Tokens de contexto, más de0	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens

Solicitudes de ejemplo

Ailoot · Anthropic Messages

Ejemplo de textoPython SDKNode.js SDKFlujo en Python

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": "glm-5.3", "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

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="glm-5.3",
    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"))

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: "glm-5.3",
  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);

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='glm-5.3',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 las cabeceras. 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 glm-5.3, glm, glm-5, glm-5.1, glm-5.2, glm-latest
Ailoot Ultra glm-5.3, z-ai/glm-5.3, ~z-ai/glm-latest

Alias de rutas de métodos

/chat/completions

ID de modelo relacionados

z-ai/glm-5.3, glm, glm-5, glm-5.1, glm-5.2, glm-latest, ~z-ai/glm-latest, glm-5.3, glm-5.3

Ailoot · OpenAI Responses POST /v1/responses glm-5.3

glm-5.3

Z.ai /glm-5.3

ID del modelo

glm-5.3
glm
glm-5
glm-5.1
glm-5.2
glm-latest

Primeros pasos

Entradas aceptadas: Texto
Resultados: Texto

Disponible en Ailoot · entradas y métodos

Ailoot · OpenAI Responses POST /v1/responses

Tipos de entrada: text
Tipos de salida: text
Contexto: 1.000.000 tokens
Salida máxima: 131.072 tokens
Formato de salida: json o SSE

Campo	Tipo	Requisito	Valores y límites	Predeterminado
Campo`model`	Tipo`string`	RequisitoObligatorio	Valores y límites glm-5.3	Predeterminado—
Campo`input`	Tipo`string\|input_item[]`	RequisitoObligatorio	Valores y límites	Predeterminado—
Campo`instructions`	Tipo`string`	RequisitoOpcional	Valores y límites	Predeterminado—
Campo`input[].type`	Tipo`string`	RequisitoOpcional	Valores y límites message, reasoning, function_call, function_call_output	Predeterminado—
Campo`input[].content`	Tipo`string\|content_part[]`	RequisitoOpcional	Valores y límites	Predeterminado—
Campo`input[].call_id`	Tipo`string`	RequisitoOpcional	Valores y límites Se aplica cuando: function_call_output; conserva el call_id real devuelto	Predeterminado—
Campo`input[].output`	Tipo`string\|content_part[]`	RequisitoOpcional	Valores y límites Se aplica cuando: function_call_output	Predeterminado—
Campo`max_output_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`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`tools`	Tipo`tool[]`	RequisitoOpcional	Valores y límites Depende del modelo	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`reasoning.effort`	Tipo`string`	RequisitoOpcional	Valores y límites Depende del modelo	Predeterminado—
Campo`reasoning.summary`	Tipo`string`	RequisitoOpcional	Valores y límites Depende del modelo	Predeterminado—
Campo`text.format`	Tipo`object`	RequisitoOpcional	Valores y límites Depende del modelo	Predeterminado—
Campo`text.verbosity`	Tipo`string`	RequisitoOpcional	Valores y límites Depende del modelo	Predeterminado—
Campo`include`	Tipo`string[]`	RequisitoOpcional	Valores y límites Depende del modelo	Predeterminado—
Campo`store`	Tipo`boolean`	RequisitoOpcional	Valores y límites Depende del modelo	Predeterminado—
Campo`previous_response_id`	Tipo`string`	RequisitoOpcional	Valores y límites Requisito de ID: Solo un ID real de respuesta de una continuación compatible Depende del modelo	Predeterminado—
Campo`service_tier`	Tipo`string`	RequisitoOpcional	Valores y límites Depende del modelo	Predeterminado—
Campo`prompt_cache_key`	Tipo`string`	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

texto en input o parte input_text

Parámetros del método y ciclo de vida

Parámetro	Contrato
Parámetro`material_types`	Contratotext
Parámetro`required`	Contratomodel, input
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.

Planes

Tarifas de métodos Ailoot

Ailoot OpenAI ResponsesPOST /v1/responses

Entrada: 0,0014 US$ / 1K
Salida: 0,0044 US$ / 1K
Lectura de caché: ≈0,00026 US$ / 1K

Detalles de la tarifa de referencia

Las tablas de referencia del modelo no cambian la selección del método, las estimaciones de coste ni los cargos. Los cargos aplicados usan las tarifas del método Ailoot seleccionado.

Tablas de referencia del modelo

Precios por configuración

Relaciona cada cargo con las condiciones mostradas. Usa una tarifa para cada conjunto de configuraciones alternativas.

Configuración	Tabla de tarifas	Tokens de contexto, más de	Tokens de contexto, hasta inclusive	Cargo
ConfiguraciónOpenAI Chat · Tarifas base por token	Tabla de tarifasTarifa base	Tokens de contexto, más de—	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens
ConfiguraciónOpenAI Chat · Nivel 1 según la longitud de la solicitud	Tabla de tarifas—	Tokens de contexto, más de0	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens
ConfiguraciónAnthropic Messages · Tarifas base por token	Tabla de tarifasTarifa base	Tokens de contexto, más de—	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens
ConfiguraciónAnthropic Messages · Nivel 1 según la longitud de la solicitud	Tabla de tarifas—	Tokens de contexto, más de0	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens

Solicitudes de ejemplo

Ailoot · OpenAI Responses

Ejemplo de textoPython SDKNode.js SDKFlujo en Python

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": "glm-5.3", "input": ""}')
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["input"]="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/responses \
  -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 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(json.loads(Path("result.json").read_text(encoding="utf-8")))
PY_RESULT

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.responses.create(model="glm-5.3", input="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"))

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.responses.create({ model: "glm-5.3", input: "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);

from openai import OpenAI
import os
from pathlib import Path
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))

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)
with client.responses.stream(model="glm-5.3", input="Explain the difference between an observation and a hypothesis 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_response()
    save_result(final.to_dict(mode="json"),"stream-result")

Recibir y guardar resultados

Ailoot · OpenAI Responses

json o SSE

Conserva todos los resultados completados

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

Conserva todos los elementos de salida y partes de contenido, el call_id real de la función, el razonamiento cifrado y el uso. Durante la transmisión en flujo, conserva la identidad completa de cada evento y elemento.

Si es necesario revisar la respuesta original

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

Campos de respuesta

Campo	Tipo
Campo`id`	Tipostring
Campo`status`	Tipostring
Campo`output[]`	Tipomessage\|reasoning\|function_call\|other item
Campo`output[].content[]`	Tipocontent part
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 glm-5.3, glm, glm-5, glm-5.1, glm-5.2, glm-latest
Ailoot Ultra glm-5.3, z-ai/glm-5.3, ~z-ai/glm-latest

Alias de rutas de métodos

/chat/completions

ID de modelo relacionados

z-ai/glm-5.3, glm, glm-5, glm-5.1, glm-5.2, glm-latest, ~z-ai/glm-latest, glm-5.3, glm-5.3

Ailoot · OpenAI Chat POST /v1/chat/completions glm-5.3

glm-5.3

Z.ai /glm-5.3

ID del modelo

glm-5.3
glm
glm-5
glm-5.1
glm-5.2
glm-latest

Primeros pasos

Entradas aceptadas: Texto
Resultados: Texto

Disponible en Ailoot · entradas y métodos

Ailoot · OpenAI Chat POST /v1/chat/completions

Tipos de entrada: text
Tipos de salida: text
Contexto: 1.000.000 tokens
Salida máxima: 131.072 tokens
Formato de salida: json o SSE

Campo	Tipo	Requisito	Valores y límites	Predeterminado
Campo`model`	Tipo`string`	RequisitoObligatorio	Valores y límites glm-5.3	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.

Planes

Tarifas de métodos Ailoot

Ailoot OpenAI ChatPOST /v1/chat/completions

Entrada: 0,0014 US$ / 1K
Salida: 0,0044 US$ / 1K
Lectura de caché: ≈0,00026 US$ / 1K

Detalles de la tarifa de referencia

Las tablas de referencia del modelo no cambian la selección del método, las estimaciones de coste ni los cargos. Los cargos aplicados usan las tarifas del método Ailoot seleccionado.

Tablas de referencia del modelo

Precios por configuración

Relaciona cada cargo con las condiciones mostradas. Usa una tarifa para cada conjunto de configuraciones alternativas.

Configuración	Tabla de tarifas	Tokens de contexto, más de	Tokens de contexto, hasta inclusive	Cargo
ConfiguraciónOpenAI Chat · Tarifas base por token	Tabla de tarifasTarifa base	Tokens de contexto, más de—	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens
ConfiguraciónOpenAI Chat · Nivel 1 según la longitud de la solicitud	Tabla de tarifas—	Tokens de contexto, más de0	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens
ConfiguraciónAnthropic Messages · Tarifas base por token	Tabla de tarifasTarifa base	Tokens de contexto, más de—	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens
ConfiguraciónAnthropic Messages · Nivel 1 según la longitud de la solicitud	Tabla de tarifas—	Tokens de contexto, más de0	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens

Solicitudes de ejemplo

Ailoot · OpenAI Chat

Ejemplo de textoPython SDKNode.js SDKFlujo en Python

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": "glm-5.3", "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

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="glm-5.3",
    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"))

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: "glm-5.3",
  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);

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='glm-5.3',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 las cabeceras. 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 glm-5.3, glm, glm-5, glm-5.1, glm-5.2, glm-latest
Ailoot Ultra glm-5.3, z-ai/glm-5.3, ~z-ai/glm-latest

Alias de rutas de métodos

/chat/completions

ID de modelo relacionados

z-ai/glm-5.3, glm, glm-5, glm-5.1, glm-5.2, glm-latest, ~z-ai/glm-latest, glm-5.3, glm-5.3

Ailoot Ultra · OpenAI Chat POST /v1/chat/completions glm-5.3

glm-5.3

Z.ai /glm-5.3

ID del modelo

glm-5.3
z-ai/glm-5.3
~z-ai/glm-latest

Primeros pasos

Entradas aceptadas: Texto
Resultados: Texto

Disponible en Ailoot · entradas y métodos

Ailoot Ultra · OpenAI Chat POST /v1/chat/completions

Tipos de entrada: text
Tipos de salida: text
Formato de salida: json o SSE

Campo	Tipo	Requisito	Valores y límites	Predeterminado
Campo`model`	Tipo`string`	RequisitoObligatorio	Valores y límites glm-5.3	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 Depende del modelo	Predeterminado—
Campo`messages[].content`	Tipo`string`	RequisitoOpcional	Valores y límites Se aplica cuando: Conversación textual	Predeterminado—
Campo`stream`	Tipo`boolean`	RequisitoOpcional	Valores y límites	Predeterminadofalse

Combinaciones de materiales de entrada

Texto · Texto UTF8

messages[].content

Parámetros del método y ciclo de vida

Parámetro	Contrato
Parámetro`content_type`	Contratoapplication/json
Parámetro`required`	Contratomodel, messages
Parámetro`material_types`	Contratotext
Parámetro`messages`	Contratomatriz de mensajes con estructura role/content
Parámetro`file_material`	Contratodocumento real en UTF-8 insertado como texto literal; no se deduce ningún ID de archivo
Parámetro`optional_controls`	Contratostream
Parámetro`control_scope`	ContratoConversación textual; stream es un booleano y su valor predeterminado es false.
Parámetro`output_modalities`	Contratotext
Parámetro`hosted_operations`	Contratofalse
Parámetro`multimodal_input_binding`	Contratonull

Alias de método: /chat/completions

Ciclo de vida: synchronous_or_streamed

Envía el ID exacto del modelo junto con messages.

La longitud del contexto no es un límite máximo de salida.

Un archivo de texto puede aportar texto literal; las entradas de imagen, audio u objetos de archivo requieren una vinculación exacta.

Planes

Las referencias tarifarias no añaden opciones a la solicitud. Los parámetros admitidos se indican en el método seleccionado.

Modo rápido: Tarifa estándar Cuando se selecciona el modo rápido
Modo flex: Tarifa estándar Cuando se selecciona el modo flex
Esfuerzo máximo de razonamiento: Tarifa estándar Cuando el esfuerzo máximo de razonamiento utiliza el ajuste predeterminado (default)
Esfuerzo de razonamiento · alto: Tarifa estándar Cuando el esfuerzo de razonamiento es alto
Esfuerzo de razonamiento · bajo: Tarifa estándar Cuando el esfuerzo de razonamiento es bajo
Esfuerzo de razonamiento · máximo: Tarifa estándar Cuando el esfuerzo de razonamiento es máximo

Tarifas de Ailoot

Precios por configuración

Relaciona cada cargo con las condiciones mostradas. Usa una tarifa para cada conjunto de configuraciones alternativas.

Configuración	Tabla de tarifas	Tokens de contexto, más de	Tokens de contexto, hasta inclusive	Cargo
ConfiguraciónTarifas base por token	Tabla de tarifasTarifa base	Tokens de contexto, más de—	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens
ConfiguraciónTramo 1 por longitud de la solicitud	Tabla de tarifas—	Tokens de contexto, más de0	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens

Solicitudes de ejemplo

Ailoot Ultra · OpenAI Chat

curlPython SDK

set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model":"glm-5.3","messages":[{"role":"user","content":"hello"}],"stream":false}')

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
r=json.loads(Path("result.json").read_text())
for x in r.get("choices",[]):
    if x.get("message",{}).get("content"): print(x["message"]["content"])
PY_RESULT

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)
result=client.chat.completions.create(model="glm-5.3", messages=[{"role":"user","content":"hello"}], stream=False)
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(result.to_dict(mode="json"))

Recibir y guardar resultados

Ailoot Ultra · OpenAI Chat

json o SSE

Conserva todos los resultados completados

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

Si es necesario revisar la respuesta original

Conserva los ID de solicitud y respuesta y las cabeceras. 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 glm-5.3, glm, glm-5, glm-5.1, glm-5.2, glm-latest
Ailoot Ultra glm-5.3, z-ai/glm-5.3, ~z-ai/glm-latest

Alias de rutas de métodos

/chat/completions

ID de modelo relacionados

z-ai/glm-5.3, glm, glm-5, glm-5.1, glm-5.2, glm-latest, ~z-ai/glm-latest, glm-5.3, glm-5.3

Ailoot Ultra · Anthropic Messages POST /v1/messages glm-5.3

glm-5.3

Z.ai /glm-5.3

ID del modelo

glm-5.3
z-ai/glm-5.3
~z-ai/glm-latest

Primeros pasos

Entradas aceptadas: Texto
Resultados: json · sse

Disponible en Ailoot · entradas y métodos

Ailoot Ultra · Anthropic Messages POST /v1/messages

Tipos de entrada: text
Tipos de salida: json, sse
Formato de salida: JSON o SSE

Campo	Tipo	Requisito	Valores y límites	Predeterminado
Campo`model`	Tipo`string`	RequisitoObligatorio	Valores y límites glm-5.3	Predeterminado—
Campo`messages`	Tipo`message[]`	RequisitoObligatorio	Valores y límites	Predeterminado—
Campo`messages[].role`	Tipo`string`	RequisitoObligatorio	Valores y límites user, assistant	Predeterminado—
Campo`messages[].content`	Tipo`string`	RequisitoObligatorio	Valores y límites	Predeterminado—
Campo`max_tokens`	Tipo`integer`	RequisitoObligatorio	Valores y límites	Predeterminado—
Campo`stream`	Tipo`boolean`	RequisitoOpcional	Valores y límites	Predeterminadofalse

Combinaciones de materiales de entrada

Texto · Texto UTF-8

cadena messages[].content

Parámetros del método y ciclo de vida

Parámetro	Contrato
Parámetro`content_type`	Contratoapplication/json
Parámetro`required`	Contratomodel, messages, max_tokens
Parámetro`optional_controls`	Contratostream
Parámetro`material_types`	Contratotext
Parámetro`text_file_material`	ContratoLee el documento real en UTF-8 y coloca su texto en el campo input indicado o en la cadena de contenido del mensaje.

Ciclo de vida: synchronous_or_streamed

Planes

Las referencias tarifarias no añaden opciones a la solicitud. Los parámetros admitidos se indican en el método seleccionado.

Modo rápido: Tarifa estándar Cuando se selecciona el modo rápido
Modo flex: Tarifa estándar Cuando se selecciona el modo flex
Esfuerzo máximo de razonamiento: Tarifa estándar Cuando el esfuerzo máximo de razonamiento utiliza el ajuste predeterminado (default)
Esfuerzo de razonamiento · alto: Tarifa estándar Cuando el esfuerzo de razonamiento es alto
Esfuerzo de razonamiento · bajo: Tarifa estándar Cuando el esfuerzo de razonamiento es bajo
Esfuerzo de razonamiento · máximo: Tarifa estándar Cuando el esfuerzo de razonamiento es máximo

Tarifas de Ailoot

Precios por configuración

Relaciona cada cargo con las condiciones mostradas. Usa una tarifa para cada conjunto de configuraciones alternativas.

Configuración	Tabla de tarifas	Tokens de contexto, más de	Tokens de contexto, hasta inclusive	Cargo
ConfiguraciónTarifas base por token	Tabla de tarifasTarifa base	Tokens de contexto, más de—	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens
ConfiguraciónTramo 1 por longitud de la solicitud	Tabla de tarifas—	Tokens de contexto, más de0	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens

Solicitudes de ejemplo

Ailoot Ultra · Anthropic Messages

Cuerpo JSON mínimo completocurl · usa tu documento en UTF-8Python · guarda el resultado completo

{
  "model": "glm-5.3",
  "max_tokens": 128,
  "messages": [
    {
      "role": "user",
      "content": "Summarize the incident report."
    }
  ],
  "stream": false
}

set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_TEXT_FILE:?Set your actual UTF-8 document}"
export AILOOT_TEXT_FILE
python3 - <<'PY_REQUEST'
import json, os
from pathlib import Path

source_file = Path(os.environ['AILOOT_TEXT_FILE'])
if not source_file.is_file():
    raise SystemExit('Set AILOOT_TEXT_FILE to your actual UTF-8 document')
text = source_file.read_text(encoding='utf-8')
if not text.strip():
    raise SystemExit('Choose a document containing text')
payload = {'model': 'glm-5.3', 'max_tokens': 128, 'messages': [{'role': 'user', 'content': 'Summarize the incident report.'}]}
payload['messages'][0]['content'] = 'Summarize this material and quote supporting source passages.\n\n' + text
Path('request.json').write_text(json.dumps(payload, ensure_ascii=False), encoding='utf-8')
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

result = json.loads(Path('result.json').read_text(encoding='utf-8'))
print(json.dumps(result, ensure_ascii=False, indent=2))
PY_RESULT

import json, os
from pathlib import Path

source_file = Path(os.environ['AILOOT_TEXT_FILE'])
if not source_file.is_file():
    raise SystemExit('Set AILOOT_TEXT_FILE to your actual UTF-8 document')
text = source_file.read_text(encoding='utf-8')
if not text.strip():
    raise SystemExit('Choose a document containing text')
payload = {'model': 'glm-5.3', 'max_tokens': 128, 'messages': [{'role': 'user', 'content': 'Summarize the incident report.'}]}
payload['messages'][0]['content'] = 'Summarize this material and quote supporting source passages.\n\n' + text
from urllib.request import Request, urlopen
from urllib.error import HTTPError

api_key = os.environ['AILOOT_API_KEY']
if not api_key.strip():
    raise SystemExit('Set AILOOT_API_KEY before making a request')
headers = {'x-api-key': 'PLACEHOLDER_KEY', 'anthropic-version': '2023-06-01', 'Content-Type': 'application/json'}
headers['x-api-key'] = api_key
request = Request('https://api.ailoot.ai/v1/messages', data=json.dumps(payload, ensure_ascii=False).encode('utf-8'), headers=headers, method='POST')
try:
    with urlopen(request, timeout=120) as response:
        raw = response.read()
        Path('response-headers.txt').write_text(str(response.headers), encoding='utf-8')
except HTTPError as error:
    Path('result.json').write_bytes(error.read())
    Path('response-headers.txt').write_text(str(error.headers), encoding='utf-8')
    raise
Path('result.json').write_bytes(raw)
import json
from pathlib import Path

result = json.loads(Path('result.json').read_text(encoding='utf-8'))
print(json.dumps(result, ensure_ascii=False, indent=2))

Recibir y guardar resultados

Ailoot Ultra · Anthropic Messages

JSON o SSE

Conserva todos los resultados completados

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

Si es necesario revisar la respuesta original

Conserva los ID de solicitud y respuesta y las cabeceras. 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 glm-5.3, glm, glm-5, glm-5.1, glm-5.2, glm-latest
Ailoot Ultra glm-5.3, z-ai/glm-5.3, ~z-ai/glm-latest

Alias de rutas de métodos

/chat/completions

ID de modelo relacionados

z-ai/glm-5.3, glm, glm-5, glm-5.1, glm-5.2, glm-latest, ~z-ai/glm-latest, glm-5.3, glm-5.3

Ailoot · Anthropic Messages POST /v1/messages glm

glm

Z.ai /glm

ID del modelo

glm-5.3
glm
glm-5
glm-5.1
glm-5.2
glm-latest

Primeros pasos

Entradas aceptadas: Texto
Resultados: Texto

Disponible en Ailoot · entradas y métodos

Ailoot · Anthropic Messages POST /v1/messages

Tipos de entrada: text
Tipos de salida: text
Contexto: 1.000.000 tokens
Salida máxima: 131.072 tokens
Formato de salida: json o SSE

Campo	Tipo	Requisito	Valores y límites	Predeterminado
Campo`model`	Tipo`string`	RequisitoObligatorio	Valores y límites glm	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.

Planes

Tarifas de métodos Ailoot

Ailoot Anthropic MessagesPOST /v1/messages

Entrada: 0,0014 US$ / 1K
Salida: 0,0044 US$ / 1K
Lectura de caché: ≈0,00026 US$ / 1K

Detalles de la tarifa de referencia

Las tablas de referencia del modelo no cambian la selección del método, las estimaciones de coste ni los cargos. Los cargos aplicados usan las tarifas del método Ailoot seleccionado.

Tablas de referencia del modelo

Precios por configuración

Relaciona cada cargo con las condiciones mostradas. Usa una tarifa para cada conjunto de configuraciones alternativas.

Configuración	Tabla de tarifas	Tokens de contexto, más de	Tokens de contexto, hasta inclusive	Cargo
ConfiguraciónOpenAI Chat · Tarifas base por token	Tabla de tarifasTarifa base	Tokens de contexto, más de—	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens
ConfiguraciónOpenAI Chat · Nivel 1 según la longitud de la solicitud	Tabla de tarifas—	Tokens de contexto, más de0	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens
ConfiguraciónAnthropic Messages · Tarifas base por token	Tabla de tarifasTarifa base	Tokens de contexto, más de—	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens
ConfiguraciónAnthropic Messages · Nivel 1 según la longitud de la solicitud	Tabla de tarifas—	Tokens de contexto, más de0	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens

Solicitudes de ejemplo

Ailoot · Anthropic Messages

Ejemplo de textoPython SDKNode.js SDKFlujo en Python

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": "glm", "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

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="glm",
    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"))

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: "glm",
  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);

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='glm',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.

Si es necesario revisar la respuesta original

Conserva los ID de solicitud y respuesta y las cabeceras. 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 glm-5.3, glm, glm-5, glm-5.1, glm-5.2, glm-latest
Ailoot Ultra glm-5.3, z-ai/glm-5.3, ~z-ai/glm-latest

Alias de rutas de métodos

/chat/completions

ID de modelo relacionados

z-ai/glm-5.3, glm, glm-5, glm-5.1, glm-5.2, glm-latest, ~z-ai/glm-latest, glm-5.3, glm-5.3

Ailoot · OpenAI Responses POST /v1/responses glm

glm

Z.ai /glm

ID del modelo

glm-5.3
glm
glm-5
glm-5.1
glm-5.2
glm-latest

Primeros pasos

Entradas aceptadas: Texto
Resultados: Texto

Disponible en Ailoot · entradas y métodos

Ailoot · OpenAI Responses POST /v1/responses

Tipos de entrada: text
Tipos de salida: text
Contexto: 1.000.000 tokens
Salida máxima: 131.072 tokens
Formato de salida: json o SSE

Campo	Tipo	Requisito	Valores y límites	Predeterminado
Campo`model`	Tipo`string`	RequisitoObligatorio	Valores y límites glm	Predeterminado—
Campo`input`	Tipo`string\|input_item[]`	RequisitoObligatorio	Valores y límites	Predeterminado—
Campo`instructions`	Tipo`string`	RequisitoOpcional	Valores y límites	Predeterminado—
Campo`input[].type`	Tipo`string`	RequisitoOpcional	Valores y límites message, reasoning, function_call, function_call_output	Predeterminado—
Campo`input[].content`	Tipo`string\|content_part[]`	RequisitoOpcional	Valores y límites	Predeterminado—
Campo`input[].call_id`	Tipo`string`	RequisitoOpcional	Valores y límites Se aplica cuando: function_call_output; conserva el call_id real devuelto	Predeterminado—
Campo`input[].output`	Tipo`string\|content_part[]`	RequisitoOpcional	Valores y límites Se aplica cuando: function_call_output	Predeterminado—
Campo`max_output_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`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`tools`	Tipo`tool[]`	RequisitoOpcional	Valores y límites Depende del modelo	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`reasoning.effort`	Tipo`string`	RequisitoOpcional	Valores y límites Depende del modelo	Predeterminado—
Campo`reasoning.summary`	Tipo`string`	RequisitoOpcional	Valores y límites Depende del modelo	Predeterminado—
Campo`text.format`	Tipo`object`	RequisitoOpcional	Valores y límites Depende del modelo	Predeterminado—
Campo`text.verbosity`	Tipo`string`	RequisitoOpcional	Valores y límites Depende del modelo	Predeterminado—
Campo`include`	Tipo`string[]`	RequisitoOpcional	Valores y límites Depende del modelo	Predeterminado—
Campo`store`	Tipo`boolean`	RequisitoOpcional	Valores y límites Depende del modelo	Predeterminado—
Campo`previous_response_id`	Tipo`string`	RequisitoOpcional	Valores y límites Requisito de ID: Solo un ID real de respuesta de una continuación compatible Depende del modelo	Predeterminado—
Campo`service_tier`	Tipo`string`	RequisitoOpcional	Valores y límites Depende del modelo	Predeterminado—
Campo`prompt_cache_key`	Tipo`string`	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

texto en input o parte input_text

Parámetros del método y ciclo de vida

Parámetro	Contrato
Parámetro`material_types`	Contratotext
Parámetro`required`	Contratomodel, input
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.

Planes

Tarifas de métodos Ailoot

Ailoot OpenAI ResponsesPOST /v1/responses

Entrada: 0,0014 US$ / 1K
Salida: 0,0044 US$ / 1K
Lectura de caché: ≈0,00026 US$ / 1K

Detalles de la tarifa de referencia

Las tablas de referencia del modelo no cambian la selección del método, las estimaciones de coste ni los cargos. Los cargos aplicados usan las tarifas del método Ailoot seleccionado.

Tablas de referencia del modelo

Precios por configuración

Relaciona cada cargo con las condiciones mostradas. Usa una tarifa para cada conjunto de configuraciones alternativas.

Configuración	Tabla de tarifas	Tokens de contexto, más de	Tokens de contexto, hasta inclusive	Cargo
ConfiguraciónOpenAI Chat · Tarifas base por token	Tabla de tarifasTarifa base	Tokens de contexto, más de—	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens
ConfiguraciónOpenAI Chat · Nivel 1 según la longitud de la solicitud	Tabla de tarifas—	Tokens de contexto, más de0	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens
ConfiguraciónAnthropic Messages · Tarifas base por token	Tabla de tarifasTarifa base	Tokens de contexto, más de—	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens
ConfiguraciónAnthropic Messages · Nivel 1 según la longitud de la solicitud	Tabla de tarifas—	Tokens de contexto, más de0	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens

Solicitudes de ejemplo

Ailoot · OpenAI Responses

Ejemplo de textoPython SDKNode.js SDKFlujo en Python

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": "glm", "input": ""}')
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["input"]="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/responses \
  -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 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(json.loads(Path("result.json").read_text(encoding="utf-8")))
PY_RESULT

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.responses.create(model="glm", input="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"))

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.responses.create({ model: "glm", input: "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);

from openai import OpenAI
import os
from pathlib import Path
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))

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)
with client.responses.stream(model="glm", input="Explain the difference between an observation and a hypothesis 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_response()
    save_result(final.to_dict(mode="json"),"stream-result")

Recibir y guardar resultados

Ailoot · OpenAI Responses

json o SSE

Conserva todos los resultados completados

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

Si es necesario revisar la respuesta original

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

Campos de respuesta

Campo	Tipo
Campo`id`	Tipostring
Campo`status`	Tipostring
Campo`output[]`	Tipomessage\|reasoning\|function_call\|other item
Campo`output[].content[]`	Tipocontent part
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 glm-5.3, glm, glm-5, glm-5.1, glm-5.2, glm-latest
Ailoot Ultra glm-5.3, z-ai/glm-5.3, ~z-ai/glm-latest

Alias de rutas de métodos

/chat/completions

ID de modelo relacionados

z-ai/glm-5.3, glm, glm-5, glm-5.1, glm-5.2, glm-latest, ~z-ai/glm-latest, glm-5.3, glm-5.3

Ailoot · OpenAI Chat POST /v1/chat/completions glm

glm

Z.ai /glm

ID del modelo

glm-5.3
glm
glm-5
glm-5.1
glm-5.2
glm-latest

Primeros pasos

Entradas aceptadas: Texto
Resultados: Texto

Disponible en Ailoot · entradas y métodos

Ailoot · OpenAI Chat POST /v1/chat/completions

Tipos de entrada: text
Tipos de salida: text
Contexto: 1.000.000 tokens
Salida máxima: 131.072 tokens
Formato de salida: json o SSE

Campo	Tipo	Requisito	Valores y límites	Predeterminado
Campo`model`	Tipo`string`	RequisitoObligatorio	Valores y límites glm	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.

Planes

Tarifas de métodos Ailoot

Ailoot OpenAI ChatPOST /v1/chat/completions

Entrada: 0,0014 US$ / 1K
Salida: 0,0044 US$ / 1K
Lectura de caché: ≈0,00026 US$ / 1K

Detalles de la tarifa de referencia

Las tablas de referencia del modelo no cambian la selección del método, las estimaciones de coste ni los cargos. Los cargos aplicados usan las tarifas del método Ailoot seleccionado.

Tablas de referencia del modelo

Precios por configuración

Relaciona cada cargo con las condiciones mostradas. Usa una tarifa para cada conjunto de configuraciones alternativas.

Configuración	Tabla de tarifas	Tokens de contexto, más de	Tokens de contexto, hasta inclusive	Cargo
ConfiguraciónOpenAI Chat · Tarifas base por token	Tabla de tarifasTarifa base	Tokens de contexto, más de—	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens
ConfiguraciónOpenAI Chat · Nivel 1 según la longitud de la solicitud	Tabla de tarifas—	Tokens de contexto, más de0	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens
ConfiguraciónAnthropic Messages · Tarifas base por token	Tabla de tarifasTarifa base	Tokens de contexto, más de—	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens
ConfiguraciónAnthropic Messages · Nivel 1 según la longitud de la solicitud	Tabla de tarifas—	Tokens de contexto, más de0	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens

Solicitudes de ejemplo

Ailoot · OpenAI Chat

Ejemplo de textoPython SDKNode.js SDKFlujo en Python

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": "glm", "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

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="glm",
    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"))

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: "glm",
  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);

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='glm',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.

Si es necesario revisar la respuesta original

Conserva los ID de solicitud y respuesta y las cabeceras. 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 glm-5.3, glm, glm-5, glm-5.1, glm-5.2, glm-latest
Ailoot Ultra glm-5.3, z-ai/glm-5.3, ~z-ai/glm-latest

Alias de rutas de métodos

/chat/completions

ID de modelo relacionados

z-ai/glm-5.3, glm, glm-5, glm-5.1, glm-5.2, glm-latest, ~z-ai/glm-latest, glm-5.3, glm-5.3

Ailoot · Anthropic Messages POST /v1/messages glm-5

glm-5

Z.ai /glm-5

ID del modelo

glm-5.3
glm
glm-5
glm-5.1
glm-5.2
glm-latest

Primeros pasos

Entradas aceptadas: Texto
Resultados: Texto

Disponible en Ailoot · entradas y métodos

Ailoot · Anthropic Messages POST /v1/messages

Tipos de entrada: text
Tipos de salida: text
Contexto: 1.000.000 tokens
Salida máxima: 131.072 tokens
Formato de salida: json o SSE

Campo	Tipo	Requisito	Valores y límites	Predeterminado
Campo`model`	Tipo`string`	RequisitoObligatorio	Valores y límites glm-5	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.

Planes

Tarifas de métodos Ailoot

Ailoot Anthropic MessagesPOST /v1/messages

Entrada: 0,0014 US$ / 1K
Salida: 0,0044 US$ / 1K
Lectura de caché: ≈0,00026 US$ / 1K

Detalles de la tarifa de referencia

Las tablas de referencia del modelo no cambian la selección del método, las estimaciones de coste ni los cargos. Los cargos aplicados usan las tarifas del método Ailoot seleccionado.

Tablas de referencia del modelo

Precios por configuración

Relaciona cada cargo con las condiciones mostradas. Usa una tarifa para cada conjunto de configuraciones alternativas.

Configuración	Tabla de tarifas	Tokens de contexto, más de	Tokens de contexto, hasta inclusive	Cargo
ConfiguraciónOpenAI Chat · Tarifas base por token	Tabla de tarifasTarifa base	Tokens de contexto, más de—	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens
ConfiguraciónOpenAI Chat · Nivel 1 según la longitud de la solicitud	Tabla de tarifas—	Tokens de contexto, más de0	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens
ConfiguraciónAnthropic Messages · Tarifas base por token	Tabla de tarifasTarifa base	Tokens de contexto, más de—	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens
ConfiguraciónAnthropic Messages · Nivel 1 según la longitud de la solicitud	Tabla de tarifas—	Tokens de contexto, más de0	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens

Solicitudes de ejemplo

Ailoot · Anthropic Messages

Ejemplo de textoPython SDKNode.js SDKFlujo en Python

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": "glm-5", "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

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="glm-5",
    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"))

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: "glm-5",
  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);

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='glm-5',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.

Si es necesario revisar la respuesta original

Conserva los ID de solicitud y respuesta y las cabeceras. 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 glm-5.3, glm, glm-5, glm-5.1, glm-5.2, glm-latest
Ailoot Ultra glm-5.3, z-ai/glm-5.3, ~z-ai/glm-latest

Alias de rutas de métodos

/chat/completions

ID de modelo relacionados

z-ai/glm-5.3, glm, glm-5, glm-5.1, glm-5.2, glm-latest, ~z-ai/glm-latest, glm-5.3, glm-5.3

Ailoot · OpenAI Responses POST /v1/responses glm-5

glm-5

Z.ai /glm-5

ID del modelo

glm-5.3
glm
glm-5
glm-5.1
glm-5.2
glm-latest

Primeros pasos

Entradas aceptadas: Texto
Resultados: Texto

Disponible en Ailoot · entradas y métodos

Ailoot · OpenAI Responses POST /v1/responses

Tipos de entrada: text
Tipos de salida: text
Contexto: 1.000.000 tokens
Salida máxima: 131.072 tokens
Formato de salida: json o SSE

Campo	Tipo	Requisito	Valores y límites	Predeterminado
Campo`model`	Tipo`string`	RequisitoObligatorio	Valores y límites glm-5	Predeterminado—
Campo`input`	Tipo`string\|input_item[]`	RequisitoObligatorio	Valores y límites	Predeterminado—
Campo`instructions`	Tipo`string`	RequisitoOpcional	Valores y límites	Predeterminado—
Campo`input[].type`	Tipo`string`	RequisitoOpcional	Valores y límites message, reasoning, function_call, function_call_output	Predeterminado—
Campo`input[].content`	Tipo`string\|content_part[]`	RequisitoOpcional	Valores y límites	Predeterminado—
Campo`input[].call_id`	Tipo`string`	RequisitoOpcional	Valores y límites Se aplica cuando: function_call_output; conserva el call_id real devuelto	Predeterminado—
Campo`input[].output`	Tipo`string\|content_part[]`	RequisitoOpcional	Valores y límites Se aplica cuando: function_call_output	Predeterminado—
Campo`max_output_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`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`tools`	Tipo`tool[]`	RequisitoOpcional	Valores y límites Depende del modelo	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`reasoning.effort`	Tipo`string`	RequisitoOpcional	Valores y límites Depende del modelo	Predeterminado—
Campo`reasoning.summary`	Tipo`string`	RequisitoOpcional	Valores y límites Depende del modelo	Predeterminado—
Campo`text.format`	Tipo`object`	RequisitoOpcional	Valores y límites Depende del modelo	Predeterminado—
Campo`text.verbosity`	Tipo`string`	RequisitoOpcional	Valores y límites Depende del modelo	Predeterminado—
Campo`include`	Tipo`string[]`	RequisitoOpcional	Valores y límites Depende del modelo	Predeterminado—
Campo`store`	Tipo`boolean`	RequisitoOpcional	Valores y límites Depende del modelo	Predeterminado—
Campo`previous_response_id`	Tipo`string`	RequisitoOpcional	Valores y límites Requisito de ID: Solo un ID real de respuesta de una continuación compatible Depende del modelo	Predeterminado—
Campo`service_tier`	Tipo`string`	RequisitoOpcional	Valores y límites Depende del modelo	Predeterminado—
Campo`prompt_cache_key`	Tipo`string`	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

texto en input o parte input_text

Parámetros del método y ciclo de vida

Parámetro	Contrato
Parámetro`material_types`	Contratotext
Parámetro`required`	Contratomodel, input
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.

Planes

Tarifas de métodos Ailoot

Ailoot OpenAI ResponsesPOST /v1/responses

Entrada: 0,0014 US$ / 1K
Salida: 0,0044 US$ / 1K
Lectura de caché: ≈0,00026 US$ / 1K

Detalles de la tarifa de referencia

Las tablas de referencia del modelo no cambian la selección del método, las estimaciones de coste ni los cargos. Los cargos aplicados usan las tarifas del método Ailoot seleccionado.

Tablas de referencia del modelo

Precios por configuración

Relaciona cada cargo con las condiciones mostradas. Usa una tarifa para cada conjunto de configuraciones alternativas.

Configuración	Tabla de tarifas	Tokens de contexto, más de	Tokens de contexto, hasta inclusive	Cargo
ConfiguraciónOpenAI Chat · Tarifas base por token	Tabla de tarifasTarifa base	Tokens de contexto, más de—	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens
ConfiguraciónOpenAI Chat · Nivel 1 según la longitud de la solicitud	Tabla de tarifas—	Tokens de contexto, más de0	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens
ConfiguraciónAnthropic Messages · Tarifas base por token	Tabla de tarifasTarifa base	Tokens de contexto, más de—	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens
ConfiguraciónAnthropic Messages · Nivel 1 según la longitud de la solicitud	Tabla de tarifas—	Tokens de contexto, más de0	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens

Solicitudes de ejemplo

Ailoot · OpenAI Responses

Ejemplo de textoPython SDKNode.js SDKFlujo en Python

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": "glm-5", "input": ""}')
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["input"]="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/responses \
  -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 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(json.loads(Path("result.json").read_text(encoding="utf-8")))
PY_RESULT

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.responses.create(model="glm-5", input="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"))

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.responses.create({ model: "glm-5", input: "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);

from openai import OpenAI
import os
from pathlib import Path
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))

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)
with client.responses.stream(model="glm-5", input="Explain the difference between an observation and a hypothesis 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_response()
    save_result(final.to_dict(mode="json"),"stream-result")

Recibir y guardar resultados

Ailoot · OpenAI Responses

json o SSE

Conserva todos los resultados completados

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

Si es necesario revisar la respuesta original

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

Campos de respuesta

Campo	Tipo
Campo`id`	Tipostring
Campo`status`	Tipostring
Campo`output[]`	Tipomessage\|reasoning\|function_call\|other item
Campo`output[].content[]`	Tipocontent part
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 glm-5.3, glm, glm-5, glm-5.1, glm-5.2, glm-latest
Ailoot Ultra glm-5.3, z-ai/glm-5.3, ~z-ai/glm-latest

Alias de rutas de métodos

/chat/completions

ID de modelo relacionados

z-ai/glm-5.3, glm, glm-5, glm-5.1, glm-5.2, glm-latest, ~z-ai/glm-latest, glm-5.3, glm-5.3

Ailoot · OpenAI Chat POST /v1/chat/completions glm-5

glm-5

Z.ai /glm-5

ID del modelo

glm-5.3
glm
glm-5
glm-5.1
glm-5.2
glm-latest

Primeros pasos

Entradas aceptadas: Texto
Resultados: Texto

Disponible en Ailoot · entradas y métodos

Ailoot · OpenAI Chat POST /v1/chat/completions

Tipos de entrada: text
Tipos de salida: text
Contexto: 1.000.000 tokens
Salida máxima: 131.072 tokens
Formato de salida: json o SSE

Campo	Tipo	Requisito	Valores y límites	Predeterminado
Campo`model`	Tipo`string`	RequisitoObligatorio	Valores y límites glm-5	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.

Planes

Tarifas de métodos Ailoot

Ailoot OpenAI ChatPOST /v1/chat/completions

Entrada: 0,0014 US$ / 1K
Salida: 0,0044 US$ / 1K
Lectura de caché: ≈0,00026 US$ / 1K

Detalles de la tarifa de referencia

Las tablas de referencia del modelo no cambian la selección del método, las estimaciones de coste ni los cargos. Los cargos aplicados usan las tarifas del método Ailoot seleccionado.

Tablas de referencia del modelo

Precios por configuración

Relaciona cada cargo con las condiciones mostradas. Usa una tarifa para cada conjunto de configuraciones alternativas.

Configuración	Tabla de tarifas	Tokens de contexto, más de	Tokens de contexto, hasta inclusive	Cargo
ConfiguraciónOpenAI Chat · Tarifas base por token	Tabla de tarifasTarifa base	Tokens de contexto, más de—	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens
ConfiguraciónOpenAI Chat · Nivel 1 según la longitud de la solicitud	Tabla de tarifas—	Tokens de contexto, más de0	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens
ConfiguraciónAnthropic Messages · Tarifas base por token	Tabla de tarifasTarifa base	Tokens de contexto, más de—	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens
ConfiguraciónAnthropic Messages · Nivel 1 según la longitud de la solicitud	Tabla de tarifas—	Tokens de contexto, más de0	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens

Solicitudes de ejemplo

Ailoot · OpenAI Chat

Ejemplo de textoPython SDKNode.js SDKFlujo en Python

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": "glm-5", "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

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="glm-5",
    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"))

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: "glm-5",
  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);

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='glm-5',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.

Si es necesario revisar la respuesta original

Conserva los ID de solicitud y respuesta y las cabeceras. 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 glm-5.3, glm, glm-5, glm-5.1, glm-5.2, glm-latest
Ailoot Ultra glm-5.3, z-ai/glm-5.3, ~z-ai/glm-latest

Alias de rutas de métodos

/chat/completions

ID de modelo relacionados

z-ai/glm-5.3, glm, glm-5, glm-5.1, glm-5.2, glm-latest, ~z-ai/glm-latest, glm-5.3, glm-5.3

Ailoot · Anthropic Messages POST /v1/messages glm-5.1

glm-5.1

Z.ai /glm-5.1

ID del modelo

glm-5.3
glm
glm-5
glm-5.1
glm-5.2
glm-latest

Primeros pasos

Entradas aceptadas: Texto
Resultados: Texto

Disponible en Ailoot · entradas y métodos

Ailoot · Anthropic Messages POST /v1/messages

Tipos de entrada: text
Tipos de salida: text
Contexto: 1.000.000 tokens
Salida máxima: 131.072 tokens
Formato de salida: json o SSE

Campo	Tipo	Requisito	Valores y límites	Predeterminado
Campo`model`	Tipo`string`	RequisitoObligatorio	Valores y límites glm-5.1	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.

Planes

Tarifas de métodos Ailoot

Ailoot Anthropic MessagesPOST /v1/messages

Entrada: 0,0014 US$ / 1K
Salida: 0,0044 US$ / 1K
Lectura de caché: ≈0,00026 US$ / 1K

Detalles de la tarifa de referencia

Las tablas de referencia del modelo no cambian la selección del método, las estimaciones de coste ni los cargos. Los cargos aplicados usan las tarifas del método Ailoot seleccionado.

Tablas de referencia del modelo

Precios por configuración

Relaciona cada cargo con las condiciones mostradas. Usa una tarifa para cada conjunto de configuraciones alternativas.

Configuración	Tabla de tarifas	Tokens de contexto, más de	Tokens de contexto, hasta inclusive	Cargo
ConfiguraciónOpenAI Chat · Tarifas base por token	Tabla de tarifasTarifa base	Tokens de contexto, más de—	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens
ConfiguraciónOpenAI Chat · Nivel 1 según la longitud de la solicitud	Tabla de tarifas—	Tokens de contexto, más de0	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens
ConfiguraciónAnthropic Messages · Tarifas base por token	Tabla de tarifasTarifa base	Tokens de contexto, más de—	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens
ConfiguraciónAnthropic Messages · Nivel 1 según la longitud de la solicitud	Tabla de tarifas—	Tokens de contexto, más de0	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens

Solicitudes de ejemplo

Ailoot · Anthropic Messages

Ejemplo de textoPython SDKNode.js SDKFlujo en Python

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": "glm-5.1", "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

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="glm-5.1",
    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"))

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: "glm-5.1",
  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);

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='glm-5.1',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.

Si es necesario revisar la respuesta original

Conserva los ID de solicitud y respuesta y las cabeceras. 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 glm-5.3, glm, glm-5, glm-5.1, glm-5.2, glm-latest
Ailoot Ultra glm-5.3, z-ai/glm-5.3, ~z-ai/glm-latest

Alias de rutas de métodos

/chat/completions

ID de modelo relacionados

z-ai/glm-5.3, glm, glm-5, glm-5.1, glm-5.2, glm-latest, ~z-ai/glm-latest, glm-5.3, glm-5.3

Ailoot · OpenAI Responses POST /v1/responses glm-5.1

glm-5.1

Z.ai /glm-5.1

ID del modelo

glm-5.3
glm
glm-5
glm-5.1
glm-5.2
glm-latest

Primeros pasos

Entradas aceptadas: Texto
Resultados: Texto

Disponible en Ailoot · entradas y métodos

Ailoot · OpenAI Responses POST /v1/responses

Tipos de entrada: text
Tipos de salida: text
Contexto: 1.000.000 tokens
Salida máxima: 131.072 tokens
Formato de salida: json o SSE

Campo	Tipo	Requisito	Valores y límites	Predeterminado
Campo`model`	Tipo`string`	RequisitoObligatorio	Valores y límites glm-5.1	Predeterminado—
Campo`input`	Tipo`string\|input_item[]`	RequisitoObligatorio	Valores y límites	Predeterminado—
Campo`instructions`	Tipo`string`	RequisitoOpcional	Valores y límites	Predeterminado—
Campo`input[].type`	Tipo`string`	RequisitoOpcional	Valores y límites message, reasoning, function_call, function_call_output	Predeterminado—
Campo`input[].content`	Tipo`string\|content_part[]`	RequisitoOpcional	Valores y límites	Predeterminado—
Campo`input[].call_id`	Tipo`string`	RequisitoOpcional	Valores y límites Se aplica cuando: function_call_output; conserva el call_id real devuelto	Predeterminado—
Campo`input[].output`	Tipo`string\|content_part[]`	RequisitoOpcional	Valores y límites Se aplica cuando: function_call_output	Predeterminado—
Campo`max_output_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`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`tools`	Tipo`tool[]`	RequisitoOpcional	Valores y límites Depende del modelo	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`reasoning.effort`	Tipo`string`	RequisitoOpcional	Valores y límites Depende del modelo	Predeterminado—
Campo`reasoning.summary`	Tipo`string`	RequisitoOpcional	Valores y límites Depende del modelo	Predeterminado—
Campo`text.format`	Tipo`object`	RequisitoOpcional	Valores y límites Depende del modelo	Predeterminado—
Campo`text.verbosity`	Tipo`string`	RequisitoOpcional	Valores y límites Depende del modelo	Predeterminado—
Campo`include`	Tipo`string[]`	RequisitoOpcional	Valores y límites Depende del modelo	Predeterminado—
Campo`store`	Tipo`boolean`	RequisitoOpcional	Valores y límites Depende del modelo	Predeterminado—
Campo`previous_response_id`	Tipo`string`	RequisitoOpcional	Valores y límites Requisito de ID: Solo un ID real de respuesta de una continuación compatible Depende del modelo	Predeterminado—
Campo`service_tier`	Tipo`string`	RequisitoOpcional	Valores y límites Depende del modelo	Predeterminado—
Campo`prompt_cache_key`	Tipo`string`	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

texto en input o parte input_text

Parámetros del método y ciclo de vida

Parámetro	Contrato
Parámetro`material_types`	Contratotext
Parámetro`required`	Contratomodel, input
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.

Planes

Tarifas de métodos Ailoot

Ailoot OpenAI ResponsesPOST /v1/responses

Entrada: 0,0014 US$ / 1K
Salida: 0,0044 US$ / 1K
Lectura de caché: ≈0,00026 US$ / 1K

Detalles de la tarifa de referencia

Las tablas de referencia del modelo no cambian la selección del método, las estimaciones de coste ni los cargos. Los cargos aplicados usan las tarifas del método Ailoot seleccionado.

Tablas de referencia del modelo

Precios por configuración

Relaciona cada cargo con las condiciones mostradas. Usa una tarifa para cada conjunto de configuraciones alternativas.

Configuración	Tabla de tarifas	Tokens de contexto, más de	Tokens de contexto, hasta inclusive	Cargo
ConfiguraciónOpenAI Chat · Tarifas base por token	Tabla de tarifasTarifa base	Tokens de contexto, más de—	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens
ConfiguraciónOpenAI Chat · Nivel 1 según la longitud de la solicitud	Tabla de tarifas—	Tokens de contexto, más de0	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens
ConfiguraciónAnthropic Messages · Tarifas base por token	Tabla de tarifasTarifa base	Tokens de contexto, más de—	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens
ConfiguraciónAnthropic Messages · Nivel 1 según la longitud de la solicitud	Tabla de tarifas—	Tokens de contexto, más de0	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens

Solicitudes de ejemplo

Ailoot · OpenAI Responses

Ejemplo de textoPython SDKNode.js SDKFlujo en Python

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": "glm-5.1", "input": ""}')
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["input"]="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/responses \
  -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 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(json.loads(Path("result.json").read_text(encoding="utf-8")))
PY_RESULT

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.responses.create(model="glm-5.1", input="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"))

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.responses.create({ model: "glm-5.1", input: "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);

from openai import OpenAI
import os
from pathlib import Path
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))

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)
with client.responses.stream(model="glm-5.1", input="Explain the difference between an observation and a hypothesis 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_response()
    save_result(final.to_dict(mode="json"),"stream-result")

Recibir y guardar resultados

Ailoot · OpenAI Responses

json o SSE

Conserva todos los resultados completados

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

Si es necesario revisar la respuesta original

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

Campos de respuesta

Campo	Tipo
Campo`id`	Tipostring
Campo`status`	Tipostring
Campo`output[]`	Tipomessage\|reasoning\|function_call\|other item
Campo`output[].content[]`	Tipocontent part
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 glm-5.3, glm, glm-5, glm-5.1, glm-5.2, glm-latest
Ailoot Ultra glm-5.3, z-ai/glm-5.3, ~z-ai/glm-latest

Alias de rutas de métodos

/chat/completions

ID de modelo relacionados

z-ai/glm-5.3, glm, glm-5, glm-5.1, glm-5.2, glm-latest, ~z-ai/glm-latest, glm-5.3, glm-5.3

Ailoot · OpenAI Chat POST /v1/chat/completions glm-5.1

glm-5.1

Z.ai /glm-5.1

ID del modelo

glm-5.3
glm
glm-5
glm-5.1
glm-5.2
glm-latest

Primeros pasos

Entradas aceptadas: Texto
Resultados: Texto

Disponible en Ailoot · entradas y métodos

Ailoot · OpenAI Chat POST /v1/chat/completions

Tipos de entrada: text
Tipos de salida: text
Contexto: 1.000.000 tokens
Salida máxima: 131.072 tokens
Formato de salida: json o SSE

Campo	Tipo	Requisito	Valores y límites	Predeterminado
Campo`model`	Tipo`string`	RequisitoObligatorio	Valores y límites glm-5.1	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.

Planes

Tarifas de métodos Ailoot

Ailoot OpenAI ChatPOST /v1/chat/completions

Entrada: 0,0014 US$ / 1K
Salida: 0,0044 US$ / 1K
Lectura de caché: ≈0,00026 US$ / 1K

Detalles de la tarifa de referencia

Las tablas de referencia del modelo no cambian la selección del método, las estimaciones de coste ni los cargos. Los cargos aplicados usan las tarifas del método Ailoot seleccionado.

Tablas de referencia del modelo

Precios por configuración

Relaciona cada cargo con las condiciones mostradas. Usa una tarifa para cada conjunto de configuraciones alternativas.

Configuración	Tabla de tarifas	Tokens de contexto, más de	Tokens de contexto, hasta inclusive	Cargo
ConfiguraciónOpenAI Chat · Tarifas base por token	Tabla de tarifasTarifa base	Tokens de contexto, más de—	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens
ConfiguraciónOpenAI Chat · Nivel 1 según la longitud de la solicitud	Tabla de tarifas—	Tokens de contexto, más de0	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens
ConfiguraciónAnthropic Messages · Tarifas base por token	Tabla de tarifasTarifa base	Tokens de contexto, más de—	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens
ConfiguraciónAnthropic Messages · Nivel 1 según la longitud de la solicitud	Tabla de tarifas—	Tokens de contexto, más de0	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens

Solicitudes de ejemplo

Ailoot · OpenAI Chat

Ejemplo de textoPython SDKNode.js SDKFlujo en Python

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": "glm-5.1", "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

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="glm-5.1",
    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"))

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: "glm-5.1",
  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);

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='glm-5.1',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.

Si es necesario revisar la respuesta original

Conserva los ID de solicitud y respuesta y las cabeceras. 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 glm-5.3, glm, glm-5, glm-5.1, glm-5.2, glm-latest
Ailoot Ultra glm-5.3, z-ai/glm-5.3, ~z-ai/glm-latest

Alias de rutas de métodos

/chat/completions

ID de modelo relacionados

z-ai/glm-5.3, glm, glm-5, glm-5.1, glm-5.2, glm-latest, ~z-ai/glm-latest, glm-5.3, glm-5.3

Ailoot · Anthropic Messages POST /v1/messages glm-5.2

glm-5.2

Z.ai /glm-5.2

ID del modelo

glm-5.3
glm
glm-5
glm-5.1
glm-5.2
glm-latest

Primeros pasos

Entradas aceptadas: Texto
Resultados: Texto

Disponible en Ailoot · entradas y métodos

Ailoot · Anthropic Messages POST /v1/messages

Tipos de entrada: text
Tipos de salida: text
Contexto: 1.000.000 tokens
Salida máxima: 131.072 tokens
Formato de salida: json o SSE

Campo	Tipo	Requisito	Valores y límites	Predeterminado
Campo`model`	Tipo`string`	RequisitoObligatorio	Valores y límites glm-5.2	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.

Planes

Tarifas de métodos Ailoot

Ailoot Anthropic MessagesPOST /v1/messages

Entrada: 0,0014 US$ / 1K
Salida: 0,0044 US$ / 1K
Lectura de caché: ≈0,00026 US$ / 1K

Detalles de la tarifa de referencia

Las tablas de referencia del modelo no cambian la selección del método, las estimaciones de coste ni los cargos. Los cargos aplicados usan las tarifas del método Ailoot seleccionado.

Tablas de referencia del modelo

Precios por configuración

Relaciona cada cargo con las condiciones mostradas. Usa una tarifa para cada conjunto de configuraciones alternativas.

Configuración	Tabla de tarifas	Tokens de contexto, más de	Tokens de contexto, hasta inclusive	Cargo
ConfiguraciónOpenAI Chat · Tarifas base por token	Tabla de tarifasTarifa base	Tokens de contexto, más de—	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens
ConfiguraciónOpenAI Chat · Nivel 1 según la longitud de la solicitud	Tabla de tarifas—	Tokens de contexto, más de0	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens
ConfiguraciónAnthropic Messages · Tarifas base por token	Tabla de tarifasTarifa base	Tokens de contexto, más de—	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens
ConfiguraciónAnthropic Messages · Nivel 1 según la longitud de la solicitud	Tabla de tarifas—	Tokens de contexto, más de0	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens

Solicitudes de ejemplo

Ailoot · Anthropic Messages

Ejemplo de textoPython SDKNode.js SDKFlujo en Python

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": "glm-5.2", "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

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="glm-5.2",
    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"))

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: "glm-5.2",
  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);

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='glm-5.2',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.

Si es necesario revisar la respuesta original

Conserva los ID de solicitud y respuesta y las cabeceras. 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 glm-5.3, glm, glm-5, glm-5.1, glm-5.2, glm-latest
Ailoot Ultra glm-5.3, z-ai/glm-5.3, ~z-ai/glm-latest

Alias de rutas de métodos

/chat/completions

ID de modelo relacionados

z-ai/glm-5.3, glm, glm-5, glm-5.1, glm-5.2, glm-latest, ~z-ai/glm-latest, glm-5.3, glm-5.3

Ailoot · OpenAI Responses POST /v1/responses glm-5.2

glm-5.2

Z.ai /glm-5.2

ID del modelo

glm-5.3
glm
glm-5
glm-5.1
glm-5.2
glm-latest

Primeros pasos

Entradas aceptadas: Texto
Resultados: Texto

Disponible en Ailoot · entradas y métodos

Ailoot · OpenAI Responses POST /v1/responses

Tipos de entrada: text
Tipos de salida: text
Contexto: 1.000.000 tokens
Salida máxima: 131.072 tokens
Formato de salida: json o SSE

Campo	Tipo	Requisito	Valores y límites	Predeterminado
Campo`model`	Tipo`string`	RequisitoObligatorio	Valores y límites glm-5.2	Predeterminado—
Campo`input`	Tipo`string\|input_item[]`	RequisitoObligatorio	Valores y límites	Predeterminado—
Campo`instructions`	Tipo`string`	RequisitoOpcional	Valores y límites	Predeterminado—
Campo`input[].type`	Tipo`string`	RequisitoOpcional	Valores y límites message, reasoning, function_call, function_call_output	Predeterminado—
Campo`input[].content`	Tipo`string\|content_part[]`	RequisitoOpcional	Valores y límites	Predeterminado—
Campo`input[].call_id`	Tipo`string`	RequisitoOpcional	Valores y límites Se aplica cuando: function_call_output; conserva el call_id real devuelto	Predeterminado—
Campo`input[].output`	Tipo`string\|content_part[]`	RequisitoOpcional	Valores y límites Se aplica cuando: function_call_output	Predeterminado—
Campo`max_output_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`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`tools`	Tipo`tool[]`	RequisitoOpcional	Valores y límites Depende del modelo	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`reasoning.effort`	Tipo`string`	RequisitoOpcional	Valores y límites Depende del modelo	Predeterminado—
Campo`reasoning.summary`	Tipo`string`	RequisitoOpcional	Valores y límites Depende del modelo	Predeterminado—
Campo`text.format`	Tipo`object`	RequisitoOpcional	Valores y límites Depende del modelo	Predeterminado—
Campo`text.verbosity`	Tipo`string`	RequisitoOpcional	Valores y límites Depende del modelo	Predeterminado—
Campo`include`	Tipo`string[]`	RequisitoOpcional	Valores y límites Depende del modelo	Predeterminado—
Campo`store`	Tipo`boolean`	RequisitoOpcional	Valores y límites Depende del modelo	Predeterminado—
Campo`previous_response_id`	Tipo`string`	RequisitoOpcional	Valores y límites Requisito de ID: Solo un ID real de respuesta de una continuación compatible Depende del modelo	Predeterminado—
Campo`service_tier`	Tipo`string`	RequisitoOpcional	Valores y límites Depende del modelo	Predeterminado—
Campo`prompt_cache_key`	Tipo`string`	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

texto en input o parte input_text

Parámetros del método y ciclo de vida

Parámetro	Contrato
Parámetro`material_types`	Contratotext
Parámetro`required`	Contratomodel, input
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.

Planes

Tarifas de métodos Ailoot

Ailoot OpenAI ResponsesPOST /v1/responses

Entrada: 0,0014 US$ / 1K
Salida: 0,0044 US$ / 1K
Lectura de caché: ≈0,00026 US$ / 1K

Detalles de la tarifa de referencia

Las tablas de referencia del modelo no cambian la selección del método, las estimaciones de coste ni los cargos. Los cargos aplicados usan las tarifas del método Ailoot seleccionado.

Tablas de referencia del modelo

Precios por configuración

Relaciona cada cargo con las condiciones mostradas. Usa una tarifa para cada conjunto de configuraciones alternativas.

Configuración	Tabla de tarifas	Tokens de contexto, más de	Tokens de contexto, hasta inclusive	Cargo
ConfiguraciónOpenAI Chat · Tarifas base por token	Tabla de tarifasTarifa base	Tokens de contexto, más de—	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens
ConfiguraciónOpenAI Chat · Nivel 1 según la longitud de la solicitud	Tabla de tarifas—	Tokens de contexto, más de0	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens
ConfiguraciónAnthropic Messages · Tarifas base por token	Tabla de tarifasTarifa base	Tokens de contexto, más de—	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens
ConfiguraciónAnthropic Messages · Nivel 1 según la longitud de la solicitud	Tabla de tarifas—	Tokens de contexto, más de0	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens

Solicitudes de ejemplo

Ailoot · OpenAI Responses

Ejemplo de textoPython SDKNode.js SDKFlujo en Python

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": "glm-5.2", "input": ""}')
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["input"]="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/responses \
  -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 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(json.loads(Path("result.json").read_text(encoding="utf-8")))
PY_RESULT

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.responses.create(model="glm-5.2", input="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"))

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.responses.create({ model: "glm-5.2", input: "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);

from openai import OpenAI
import os
from pathlib import Path
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))

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)
with client.responses.stream(model="glm-5.2", input="Explain the difference between an observation and a hypothesis 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_response()
    save_result(final.to_dict(mode="json"),"stream-result")

Recibir y guardar resultados

Ailoot · OpenAI Responses

json o SSE

Conserva todos los resultados completados

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

Si es necesario revisar la respuesta original

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

Campos de respuesta

Campo	Tipo
Campo`id`	Tipostring
Campo`status`	Tipostring
Campo`output[]`	Tipomessage\|reasoning\|function_call\|other item
Campo`output[].content[]`	Tipocontent part
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 glm-5.3, glm, glm-5, glm-5.1, glm-5.2, glm-latest
Ailoot Ultra glm-5.3, z-ai/glm-5.3, ~z-ai/glm-latest

Alias de rutas de métodos

/chat/completions

ID de modelo relacionados

z-ai/glm-5.3, glm, glm-5, glm-5.1, glm-5.2, glm-latest, ~z-ai/glm-latest, glm-5.3, glm-5.3

Ailoot · OpenAI Chat POST /v1/chat/completions glm-5.2

glm-5.2

Z.ai /glm-5.2

ID del modelo

glm-5.3
glm
glm-5
glm-5.1
glm-5.2
glm-latest

Primeros pasos

Entradas aceptadas: Texto
Resultados: Texto

Disponible en Ailoot · entradas y métodos

Ailoot · OpenAI Chat POST /v1/chat/completions

Tipos de entrada: text
Tipos de salida: text
Contexto: 1.000.000 tokens
Salida máxima: 131.072 tokens
Formato de salida: json o SSE

Campo	Tipo	Requisito	Valores y límites	Predeterminado
Campo`model`	Tipo`string`	RequisitoObligatorio	Valores y límites glm-5.2	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.

Planes

Tarifas de métodos Ailoot

Ailoot OpenAI ChatPOST /v1/chat/completions

Entrada: 0,0014 US$ / 1K
Salida: 0,0044 US$ / 1K
Lectura de caché: ≈0,00026 US$ / 1K

Detalles de la tarifa de referencia

Las tablas de referencia del modelo no cambian la selección del método, las estimaciones de coste ni los cargos. Los cargos aplicados usan las tarifas del método Ailoot seleccionado.

Tablas de referencia del modelo

Precios por configuración

Relaciona cada cargo con las condiciones mostradas. Usa una tarifa para cada conjunto de configuraciones alternativas.

Configuración	Tabla de tarifas	Tokens de contexto, más de	Tokens de contexto, hasta inclusive	Cargo
ConfiguraciónOpenAI Chat · Tarifas base por token	Tabla de tarifasTarifa base	Tokens de contexto, más de—	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens
ConfiguraciónOpenAI Chat · Nivel 1 según la longitud de la solicitud	Tabla de tarifas—	Tokens de contexto, más de0	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens
ConfiguraciónAnthropic Messages · Tarifas base por token	Tabla de tarifasTarifa base	Tokens de contexto, más de—	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens
ConfiguraciónAnthropic Messages · Nivel 1 según la longitud de la solicitud	Tabla de tarifas—	Tokens de contexto, más de0	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens

Solicitudes de ejemplo

Ailoot · OpenAI Chat

Ejemplo de textoPython SDKNode.js SDKFlujo en Python

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": "glm-5.2", "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

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="glm-5.2",
    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"))

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: "glm-5.2",
  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);

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='glm-5.2',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.

Si es necesario revisar la respuesta original

Conserva los ID de solicitud y respuesta y las cabeceras. 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 glm-5.3, glm, glm-5, glm-5.1, glm-5.2, glm-latest
Ailoot Ultra glm-5.3, z-ai/glm-5.3, ~z-ai/glm-latest

Alias de rutas de métodos

/chat/completions

ID de modelo relacionados

z-ai/glm-5.3, glm, glm-5, glm-5.1, glm-5.2, glm-latest, ~z-ai/glm-latest, glm-5.3, glm-5.3

Ailoot · Anthropic Messages POST /v1/messages glm-latest

glm-latest

Z.ai /glm-latest

ID del modelo

glm-5.3
glm
glm-5
glm-5.1
glm-5.2
glm-latest

Primeros pasos

Entradas aceptadas: Texto
Resultados: Texto

Disponible en Ailoot · entradas y métodos

Ailoot · Anthropic Messages POST /v1/messages

Tipos de entrada: text
Tipos de salida: text
Contexto: 1.000.000 tokens
Salida máxima: 131.072 tokens
Formato de salida: json o SSE

Campo	Tipo	Requisito	Valores y límites	Predeterminado
Campo`model`	Tipo`string`	RequisitoObligatorio	Valores y límites glm-latest	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.

Planes

Tarifas de métodos Ailoot

Ailoot Anthropic MessagesPOST /v1/messages

Entrada: 0,0014 US$ / 1K
Salida: 0,0044 US$ / 1K
Lectura de caché: ≈0,00026 US$ / 1K

Detalles de la tarifa de referencia

Las tablas de referencia del modelo no cambian la selección del método, las estimaciones de coste ni los cargos. Los cargos aplicados usan las tarifas del método Ailoot seleccionado.

Tablas de referencia del modelo

Precios por configuración

Relaciona cada cargo con las condiciones mostradas. Usa una tarifa para cada conjunto de configuraciones alternativas.

Configuración	Tabla de tarifas	Tokens de contexto, más de	Tokens de contexto, hasta inclusive	Cargo
ConfiguraciónOpenAI Chat · Tarifas base por token	Tabla de tarifasTarifa base	Tokens de contexto, más de—	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens
ConfiguraciónOpenAI Chat · Nivel 1 según la longitud de la solicitud	Tabla de tarifas—	Tokens de contexto, más de0	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens
ConfiguraciónAnthropic Messages · Tarifas base por token	Tabla de tarifasTarifa base	Tokens de contexto, más de—	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens
ConfiguraciónAnthropic Messages · Nivel 1 según la longitud de la solicitud	Tabla de tarifas—	Tokens de contexto, más de0	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens

Solicitudes de ejemplo

Ailoot · Anthropic Messages

Ejemplo de textoPython SDKNode.js SDKFlujo en Python

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": "glm-latest", "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

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="glm-latest",
    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"))

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: "glm-latest",
  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);

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='glm-latest',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.

Si es necesario revisar la respuesta original

Conserva los ID de solicitud y respuesta y las cabeceras. 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 glm-5.3, glm, glm-5, glm-5.1, glm-5.2, glm-latest
Ailoot Ultra glm-5.3, z-ai/glm-5.3, ~z-ai/glm-latest

Alias de rutas de métodos

/chat/completions

ID de modelo relacionados

z-ai/glm-5.3, glm, glm-5, glm-5.1, glm-5.2, glm-latest, ~z-ai/glm-latest, glm-5.3, glm-5.3

Ailoot · OpenAI Responses POST /v1/responses glm-latest

glm-latest

Z.ai /glm-latest

ID del modelo

glm-5.3
glm
glm-5
glm-5.1
glm-5.2
glm-latest

Primeros pasos

Entradas aceptadas: Texto
Resultados: Texto

Disponible en Ailoot · entradas y métodos

Ailoot · OpenAI Responses POST /v1/responses

Tipos de entrada: text
Tipos de salida: text
Contexto: 1.000.000 tokens
Salida máxima: 131.072 tokens
Formato de salida: json o SSE

Campo	Tipo	Requisito	Valores y límites	Predeterminado
Campo`model`	Tipo`string`	RequisitoObligatorio	Valores y límites glm-latest	Predeterminado—
Campo`input`	Tipo`string\|input_item[]`	RequisitoObligatorio	Valores y límites	Predeterminado—
Campo`instructions`	Tipo`string`	RequisitoOpcional	Valores y límites	Predeterminado—
Campo`input[].type`	Tipo`string`	RequisitoOpcional	Valores y límites message, reasoning, function_call, function_call_output	Predeterminado—
Campo`input[].content`	Tipo`string\|content_part[]`	RequisitoOpcional	Valores y límites	Predeterminado—
Campo`input[].call_id`	Tipo`string`	RequisitoOpcional	Valores y límites Se aplica cuando: function_call_output; conserva el call_id real devuelto	Predeterminado—
Campo`input[].output`	Tipo`string\|content_part[]`	RequisitoOpcional	Valores y límites Se aplica cuando: function_call_output	Predeterminado—
Campo`max_output_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`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`tools`	Tipo`tool[]`	RequisitoOpcional	Valores y límites Depende del modelo	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`reasoning.effort`	Tipo`string`	RequisitoOpcional	Valores y límites Depende del modelo	Predeterminado—
Campo`reasoning.summary`	Tipo`string`	RequisitoOpcional	Valores y límites Depende del modelo	Predeterminado—
Campo`text.format`	Tipo`object`	RequisitoOpcional	Valores y límites Depende del modelo	Predeterminado—
Campo`text.verbosity`	Tipo`string`	RequisitoOpcional	Valores y límites Depende del modelo	Predeterminado—
Campo`include`	Tipo`string[]`	RequisitoOpcional	Valores y límites Depende del modelo	Predeterminado—
Campo`store`	Tipo`boolean`	RequisitoOpcional	Valores y límites Depende del modelo	Predeterminado—
Campo`previous_response_id`	Tipo`string`	RequisitoOpcional	Valores y límites Requisito de ID: Solo un ID real de respuesta de una continuación compatible Depende del modelo	Predeterminado—
Campo`service_tier`	Tipo`string`	RequisitoOpcional	Valores y límites Depende del modelo	Predeterminado—
Campo`prompt_cache_key`	Tipo`string`	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

texto en input o parte input_text

Parámetros del método y ciclo de vida

Parámetro	Contrato
Parámetro`material_types`	Contratotext
Parámetro`required`	Contratomodel, input
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.

Planes

Tarifas de métodos Ailoot

Ailoot OpenAI ResponsesPOST /v1/responses

Entrada: 0,0014 US$ / 1K
Salida: 0,0044 US$ / 1K
Lectura de caché: ≈0,00026 US$ / 1K

Detalles de la tarifa de referencia

Las tablas de referencia del modelo no cambian la selección del método, las estimaciones de coste ni los cargos. Los cargos aplicados usan las tarifas del método Ailoot seleccionado.

Tablas de referencia del modelo

Precios por configuración

Relaciona cada cargo con las condiciones mostradas. Usa una tarifa para cada conjunto de configuraciones alternativas.

Configuración	Tabla de tarifas	Tokens de contexto, más de	Tokens de contexto, hasta inclusive	Cargo
ConfiguraciónOpenAI Chat · Tarifas base por token	Tabla de tarifasTarifa base	Tokens de contexto, más de—	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens
ConfiguraciónOpenAI Chat · Nivel 1 según la longitud de la solicitud	Tabla de tarifas—	Tokens de contexto, más de0	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens
ConfiguraciónAnthropic Messages · Tarifas base por token	Tabla de tarifasTarifa base	Tokens de contexto, más de—	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens
ConfiguraciónAnthropic Messages · Nivel 1 según la longitud de la solicitud	Tabla de tarifas—	Tokens de contexto, más de0	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens

Solicitudes de ejemplo

Ailoot · OpenAI Responses

Ejemplo de textoPython SDKNode.js SDKFlujo en Python

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": "glm-latest", "input": ""}')
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["input"]="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/responses \
  -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 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(json.loads(Path("result.json").read_text(encoding="utf-8")))
PY_RESULT

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.responses.create(model="glm-latest", input="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"))

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.responses.create({ model: "glm-latest", input: "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);

from openai import OpenAI
import os
from pathlib import Path
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))

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)
with client.responses.stream(model="glm-latest", input="Explain the difference between an observation and a hypothesis 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_response()
    save_result(final.to_dict(mode="json"),"stream-result")

Recibir y guardar resultados

Ailoot · OpenAI Responses

json o SSE

Conserva todos los resultados completados

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

Si es necesario revisar la respuesta original

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

Campos de respuesta

Campo	Tipo
Campo`id`	Tipostring
Campo`status`	Tipostring
Campo`output[]`	Tipomessage\|reasoning\|function_call\|other item
Campo`output[].content[]`	Tipocontent part
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 glm-5.3, glm, glm-5, glm-5.1, glm-5.2, glm-latest
Ailoot Ultra glm-5.3, z-ai/glm-5.3, ~z-ai/glm-latest

Alias de rutas de métodos

/chat/completions

ID de modelo relacionados

z-ai/glm-5.3, glm, glm-5, glm-5.1, glm-5.2, glm-latest, ~z-ai/glm-latest, glm-5.3, glm-5.3

Ailoot · OpenAI Chat POST /v1/chat/completions glm-latest

glm-latest

Z.ai /glm-latest

ID del modelo

glm-5.3
glm
glm-5
glm-5.1
glm-5.2
glm-latest

Primeros pasos

Entradas aceptadas: Texto
Resultados: Texto

Disponible en Ailoot · entradas y métodos

Ailoot · OpenAI Chat POST /v1/chat/completions

Tipos de entrada: text
Tipos de salida: text
Contexto: 1.000.000 tokens
Salida máxima: 131.072 tokens
Formato de salida: json o SSE

Campo	Tipo	Requisito	Valores y límites	Predeterminado
Campo`model`	Tipo`string`	RequisitoObligatorio	Valores y límites glm-latest	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.

Planes

Tarifas de métodos Ailoot

Ailoot OpenAI ChatPOST /v1/chat/completions

Entrada: 0,0014 US$ / 1K
Salida: 0,0044 US$ / 1K
Lectura de caché: ≈0,00026 US$ / 1K

Detalles de la tarifa de referencia

Las tablas de referencia del modelo no cambian la selección del método, las estimaciones de coste ni los cargos. Los cargos aplicados usan las tarifas del método Ailoot seleccionado.

Tablas de referencia del modelo

Precios por configuración

Relaciona cada cargo con las condiciones mostradas. Usa una tarifa para cada conjunto de configuraciones alternativas.

Configuración	Tabla de tarifas	Tokens de contexto, más de	Tokens de contexto, hasta inclusive	Cargo
ConfiguraciónOpenAI Chat · Tarifas base por token	Tabla de tarifasTarifa base	Tokens de contexto, más de—	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens
ConfiguraciónOpenAI Chat · Nivel 1 según la longitud de la solicitud	Tabla de tarifas—	Tokens de contexto, más de0	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens
ConfiguraciónAnthropic Messages · Tarifas base por token	Tabla de tarifasTarifa base	Tokens de contexto, más de—	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens
ConfiguraciónAnthropic Messages · Nivel 1 según la longitud de la solicitud	Tabla de tarifas—	Tokens de contexto, más de0	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens

Solicitudes de ejemplo

Ailoot · OpenAI Chat

Ejemplo de textoPython SDKNode.js SDKFlujo en Python

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": "glm-latest", "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

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="glm-latest",
    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"))

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: "glm-latest",
  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);

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='glm-latest',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.

Si es necesario revisar la respuesta original

Conserva los ID de solicitud y respuesta y las cabeceras. 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 glm-5.3, glm, glm-5, glm-5.1, glm-5.2, glm-latest
Ailoot Ultra glm-5.3, z-ai/glm-5.3, ~z-ai/glm-latest

Alias de rutas de métodos

/chat/completions

ID de modelo relacionados

z-ai/glm-5.3, glm, glm-5, glm-5.1, glm-5.2, glm-latest, ~z-ai/glm-latest, glm-5.3, glm-5.3

Ailoot Ultra · OpenAI Chat POST /v1/chat/completions z-ai/glm-5.3

z-ai/glm-5.3

Z.ai /z-ai/glm-5.3

ID del modelo

glm-5.3
z-ai/glm-5.3
~z-ai/glm-latest

Primeros pasos

Entradas aceptadas: Texto
Resultados: Texto

Disponible en Ailoot · entradas y métodos

Ailoot Ultra · OpenAI Chat POST /v1/chat/completions

Tipos de entrada: text
Tipos de salida: text
Formato de salida: json o SSE

Campo	Tipo	Requisito	Valores y límites	Predeterminado
Campo`model`	Tipo`string`	RequisitoObligatorio	Valores y límites z-ai/glm-5.3	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 function 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—
Campo`modalities`	Tipo`string[]`	RequisitoOpcional	Valores y límites text	Predeterminado—
Campo`provider`	Tipo`object`	RequisitoOpcional	Valores y límites Condiciones: provider.options se rechaza en esta ruta de texto Ultra	Predeterminado—
Campo`cache_control.ttl`	Tipo`string`	RequisitoOpcional	Valores y límites Condiciones: 1h se rechaza en los campos reales de caché de instrucciones	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`content_type`	Contratoapplication/json
Parámetro`required`	Contratomodel, messages
Parámetro`material_types`	Contratotext
Parámetro`messages`	Contratomatriz de mensajes con estructura role/content
Parámetro`file_material`	Contratodocumento real en UTF-8 insertado como texto literal; no se deduce ningún ID de archivo
Parámetro`optional_controls`	Contratostream, temperature, top_p, stop, max_tokens, max_completion_tokens, reasoning, response_format, tools, tool_choice
Parámetro`control_scope`	Contratodepende del modelo; las herramientas de funciones del usuario difieren de las herramientas alojadas
Parámetro`output_modalities`	Contratotext
Parámetro`hosted_operations`	Contratofalse
Parámetro`multimodal_input_binding`	Contratonull

Ciclo de vida: synchronous_or_streamed

Envía el ID exacto del modelo junto con messages.

La longitud del contexto no es un límite máximo de salida.

Un archivo de texto puede aportar texto literal; las entradas de imagen, audio u objetos de archivo requieren una vinculación exacta.

Planes

Las referencias tarifarias no añaden opciones a la solicitud. Los parámetros admitidos se indican en el método seleccionado.

Modo rápido: Tarifa estándar Cuando se selecciona el modo rápido
Modo flex: Tarifa estándar Cuando se selecciona el modo flex
Esfuerzo máximo de razonamiento: Tarifa estándar Cuando el esfuerzo máximo de razonamiento utiliza el ajuste predeterminado (default)
Esfuerzo de razonamiento · alto: Tarifa estándar Cuando el esfuerzo de razonamiento es alto
Esfuerzo de razonamiento · bajo: Tarifa estándar Cuando el esfuerzo de razonamiento es bajo
Esfuerzo de razonamiento · máximo: Tarifa estándar Cuando el esfuerzo de razonamiento es máximo

Tarifas de Ailoot

Precios por configuración

Relaciona cada cargo con las condiciones mostradas. Usa una tarifa para cada conjunto de configuraciones alternativas.

Configuración	Tabla de tarifas	Tokens de contexto, más de	Tokens de contexto, hasta inclusive	Cargo
ConfiguraciónTarifas base por token	Tabla de tarifasTarifa base	Tokens de contexto, más de—	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens
ConfiguraciónTramo 1 por longitud de la solicitud	Tabla de tarifas—	Tokens de contexto, más de0	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens

Solicitudes de ejemplo

Ailoot Ultra · OpenAI Chat

curlPython SDKFlujo en Python

set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "z-ai/glm-5.3", "messages": [{"role": "user", "content": "Explain the difference between an observation and a hypothesis in three sentences."}]}')

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
r=json.loads(Path("result.json").read_text())
for x in r.get("choices",[]):
    if x.get("message",{}).get("content"): print(x["message"]["content"])
PY_RESULT

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)
result=client.chat.completions.create(model='z-ai/glm-5.3',messages=[{"role":"user","content":"Explain observations and hypotheses 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(result.to_dict(mode="json"))

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='z-ai/glm-5.3',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 Ultra · OpenAI Chat

json o SSE

Conserva todos los resultados completados

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

Si es necesario revisar la respuesta original

Conserva los ID de solicitud y respuesta y las cabeceras. 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 glm-5.3, glm, glm-5, glm-5.1, glm-5.2, glm-latest
Ailoot Ultra glm-5.3, z-ai/glm-5.3, ~z-ai/glm-latest

Alias de rutas de métodos

/chat/completions

ID de modelo relacionados

z-ai/glm-5.3, glm, glm-5, glm-5.1, glm-5.2, glm-latest, ~z-ai/glm-latest, glm-5.3, glm-5.3

Ailoot Ultra · Anthropic Messages POST /v1/messages z-ai/glm-5.3

z-ai/glm-5.3

Z.ai /z-ai/glm-5.3

ID del modelo

glm-5.3
z-ai/glm-5.3
~z-ai/glm-latest

Primeros pasos

Entradas aceptadas: Texto
Resultados: json · sse

Disponible en Ailoot · entradas y métodos

Ailoot Ultra · Anthropic Messages POST /v1/messages

Tipos de entrada: text
Tipos de salida: json, sse
Formato de salida: JSON o SSE

Campo	Tipo	Requisito	Valores y límites	Predeterminado
Campo`model`	Tipo`string`	RequisitoObligatorio	Valores y límites z-ai/glm-5.3	Predeterminado—
Campo`messages`	Tipo`message[]`	RequisitoObligatorio	Valores y límites	Predeterminado—
Campo`messages[].role`	Tipo`string`	RequisitoObligatorio	Valores y límites user, assistant	Predeterminado—
Campo`messages[].content`	Tipo`string`	RequisitoObligatorio	Valores y límites	Predeterminado—
Campo`max_tokens`	Tipo`integer`	RequisitoObligatorio	Valores y límites	Predeterminado—
Campo`stream`	Tipo`boolean`	RequisitoOpcional	Valores y límites	Predeterminadofalse

Combinaciones de materiales de entrada

Texto · Texto UTF-8

cadena messages[].content

Parámetros del método y ciclo de vida

Parámetro	Contrato
Parámetro`content_type`	Contratoapplication/json
Parámetro`required`	Contratomodel, messages, max_tokens
Parámetro`optional_controls`	Contratostream
Parámetro`material_types`	Contratotext
Parámetro`text_file_material`	ContratoLee el documento real en UTF-8 y coloca su texto en el campo input indicado o en la cadena de contenido del mensaje.

Ciclo de vida: synchronous_or_streamed

Planes

Las referencias tarifarias no añaden opciones a la solicitud. Los parámetros admitidos se indican en el método seleccionado.

Modo rápido: Tarifa estándar Cuando se selecciona el modo rápido
Modo flex: Tarifa estándar Cuando se selecciona el modo flex
Esfuerzo máximo de razonamiento: Tarifa estándar Cuando el esfuerzo máximo de razonamiento utiliza el ajuste predeterminado (default)
Esfuerzo de razonamiento · alto: Tarifa estándar Cuando el esfuerzo de razonamiento es alto
Esfuerzo de razonamiento · bajo: Tarifa estándar Cuando el esfuerzo de razonamiento es bajo
Esfuerzo de razonamiento · máximo: Tarifa estándar Cuando el esfuerzo de razonamiento es máximo

Tarifas de Ailoot

Precios por configuración

Relaciona cada cargo con las condiciones mostradas. Usa una tarifa para cada conjunto de configuraciones alternativas.

Configuración	Tabla de tarifas	Tokens de contexto, más de	Tokens de contexto, hasta inclusive	Cargo
ConfiguraciónTarifas base por token	Tabla de tarifasTarifa base	Tokens de contexto, más de—	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens
ConfiguraciónTramo 1 por longitud de la solicitud	Tabla de tarifas—	Tokens de contexto, más de0	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens

Solicitudes de ejemplo

Ailoot Ultra · Anthropic Messages

Cuerpo JSON mínimo completocurl · usa tu documento en UTF-8Python · guarda el resultado completo

{
  "model": "z-ai/glm-5.3",
  "max_tokens": 128,
  "messages": [
    {
      "role": "user",
      "content": "Summarize the incident report."
    }
  ],
  "stream": false
}

set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_TEXT_FILE:?Set your actual UTF-8 document}"
export AILOOT_TEXT_FILE
python3 - <<'PY_REQUEST'
import json, os
from pathlib import Path

source_file = Path(os.environ['AILOOT_TEXT_FILE'])
if not source_file.is_file():
    raise SystemExit('Set AILOOT_TEXT_FILE to your actual UTF-8 document')
text = source_file.read_text(encoding='utf-8')
if not text.strip():
    raise SystemExit('Choose a document containing text')
payload = {'model': 'z-ai/glm-5.3', 'max_tokens': 128, 'messages': [{'role': 'user', 'content': 'Summarize the incident report.'}]}
payload['messages'][0]['content'] = 'Summarize this material and quote supporting source passages.\n\n' + text
Path('request.json').write_text(json.dumps(payload, ensure_ascii=False), encoding='utf-8')
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

result = json.loads(Path('result.json').read_text(encoding='utf-8'))
print(json.dumps(result, ensure_ascii=False, indent=2))
PY_RESULT

import json, os
from pathlib import Path

source_file = Path(os.environ['AILOOT_TEXT_FILE'])
if not source_file.is_file():
    raise SystemExit('Set AILOOT_TEXT_FILE to your actual UTF-8 document')
text = source_file.read_text(encoding='utf-8')
if not text.strip():
    raise SystemExit('Choose a document containing text')
payload = {'model': 'z-ai/glm-5.3', 'max_tokens': 128, 'messages': [{'role': 'user', 'content': 'Summarize the incident report.'}]}
payload['messages'][0]['content'] = 'Summarize this material and quote supporting source passages.\n\n' + text
from urllib.request import Request, urlopen
from urllib.error import HTTPError

api_key = os.environ['AILOOT_API_KEY']
if not api_key.strip():
    raise SystemExit('Set AILOOT_API_KEY before making a request')
headers = {'x-api-key': 'PLACEHOLDER_KEY', 'anthropic-version': '2023-06-01', 'Content-Type': 'application/json'}
headers['x-api-key'] = api_key
request = Request('https://api.ailoot.ai/v1/messages', data=json.dumps(payload, ensure_ascii=False).encode('utf-8'), headers=headers, method='POST')
try:
    with urlopen(request, timeout=120) as response:
        raw = response.read()
        Path('response-headers.txt').write_text(str(response.headers), encoding='utf-8')
except HTTPError as error:
    Path('result.json').write_bytes(error.read())
    Path('response-headers.txt').write_text(str(error.headers), encoding='utf-8')
    raise
Path('result.json').write_bytes(raw)
import json
from pathlib import Path

result = json.loads(Path('result.json').read_text(encoding='utf-8'))
print(json.dumps(result, ensure_ascii=False, indent=2))

Recibir y guardar resultados

Ailoot Ultra · Anthropic Messages

JSON o SSE

Conserva todos los resultados completados

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

Si es necesario revisar la respuesta original

Conserva los ID de solicitud y respuesta y las cabeceras. 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 glm-5.3, glm, glm-5, glm-5.1, glm-5.2, glm-latest
Ailoot Ultra glm-5.3, z-ai/glm-5.3, ~z-ai/glm-latest

Alias de rutas de métodos

/chat/completions

ID de modelo relacionados

z-ai/glm-5.3, glm, glm-5, glm-5.1, glm-5.2, glm-latest, ~z-ai/glm-latest, glm-5.3, glm-5.3

Ailoot Ultra · OpenAI Chat POST /v1/chat/completions ~z-ai/glm-latest

~z-ai/glm-latest

Z.ai /~z-ai/glm-latest

ID del modelo

glm-5.3
z-ai/glm-5.3
~z-ai/glm-latest

Primeros pasos

Entradas aceptadas: Texto
Resultados: Texto

Disponible en Ailoot · entradas y métodos

Ailoot Ultra · OpenAI Chat POST /v1/chat/completions

Tipos de entrada: text
Tipos de salida: text
Formato de salida: json o SSE

Campo	Tipo	Requisito	Valores y límites	Predeterminado
Campo`model`	Tipo`string`	RequisitoObligatorio	Valores y límites ~z-ai/glm-latest	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 function 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—
Campo`modalities`	Tipo`string[]`	RequisitoOpcional	Valores y límites text	Predeterminado—
Campo`provider`	Tipo`object`	RequisitoOpcional	Valores y límites Condiciones: provider.options se rechaza en esta ruta de texto Ultra	Predeterminado—
Campo`cache_control.ttl`	Tipo`string`	RequisitoOpcional	Valores y límites Condiciones: 1h se rechaza en los campos reales de caché de instrucciones	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`content_type`	Contratoapplication/json
Parámetro`required`	Contratomodel, messages
Parámetro`material_types`	Contratotext
Parámetro`messages`	Contratomatriz de mensajes con estructura role/content
Parámetro`file_material`	Contratodocumento real en UTF-8 insertado como texto literal; no se deduce ningún ID de archivo
Parámetro`optional_controls`	Contratostream, temperature, top_p, stop, max_tokens, max_completion_tokens, reasoning, response_format, tools, tool_choice
Parámetro`control_scope`	Contratodepende del modelo; las herramientas de funciones del usuario difieren de las herramientas alojadas
Parámetro`output_modalities`	Contratotext
Parámetro`hosted_operations`	Contratofalse
Parámetro`multimodal_input_binding`	Contratonull

Ciclo de vida: synchronous_or_streamed

Envía el ID exacto del modelo junto con messages.

La longitud del contexto no es un límite máximo de salida.

Un archivo de texto puede aportar texto literal; las entradas de imagen, audio u objetos de archivo requieren una vinculación exacta.

Planes

Las referencias tarifarias no añaden opciones a la solicitud. Los parámetros admitidos se indican en el método seleccionado.

Modo rápido: Tarifa estándar Cuando se selecciona el modo rápido
Modo flex: Tarifa estándar Cuando se selecciona el modo flex
Esfuerzo máximo de razonamiento: Tarifa estándar Cuando el esfuerzo máximo de razonamiento utiliza el ajuste predeterminado (default)
Esfuerzo de razonamiento · alto: Tarifa estándar Cuando el esfuerzo de razonamiento es alto
Esfuerzo de razonamiento · bajo: Tarifa estándar Cuando el esfuerzo de razonamiento es bajo
Esfuerzo de razonamiento · máximo: Tarifa estándar Cuando el esfuerzo de razonamiento es máximo

Tarifas de Ailoot

Precios por configuración

Relaciona cada cargo con las condiciones mostradas. Usa una tarifa para cada conjunto de configuraciones alternativas.

Configuración	Tabla de tarifas	Tokens de contexto, más de	Tokens de contexto, hasta inclusive	Cargo
ConfiguraciónTarifas base por token	Tabla de tarifasTarifa base	Tokens de contexto, más de—	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens
ConfiguraciónTramo 1 por longitud de la solicitud	Tabla de tarifas—	Tokens de contexto, más de0	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens

Solicitudes de ejemplo

Ailoot Ultra · OpenAI Chat

curlPython SDKFlujo en Python

set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "~z-ai/glm-latest", "messages": [{"role": "user", "content": "Explain the difference between an observation and a hypothesis in three sentences."}]}')

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
r=json.loads(Path("result.json").read_text())
for x in r.get("choices",[]):
    if x.get("message",{}).get("content"): print(x["message"]["content"])
PY_RESULT

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)
result=client.chat.completions.create(model='~z-ai/glm-latest',messages=[{"role":"user","content":"Explain observations and hypotheses 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(result.to_dict(mode="json"))

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='~z-ai/glm-latest',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 Ultra · OpenAI Chat

json o SSE

Conserva todos los resultados completados

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

Si es necesario revisar la respuesta original

Conserva los ID de solicitud y respuesta y las cabeceras. 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 glm-5.3, glm, glm-5, glm-5.1, glm-5.2, glm-latest
Ailoot Ultra glm-5.3, z-ai/glm-5.3, ~z-ai/glm-latest

Alias de rutas de métodos

/chat/completions

ID de modelo relacionados

z-ai/glm-5.3, glm, glm-5, glm-5.1, glm-5.2, glm-latest, ~z-ai/glm-latest, glm-5.3, glm-5.3

Ailoot Ultra · Anthropic Messages POST /v1/messages ~z-ai/glm-latest

~z-ai/glm-latest

Z.ai /~z-ai/glm-latest

ID del modelo

glm-5.3
z-ai/glm-5.3
~z-ai/glm-latest

Primeros pasos

Entradas aceptadas: Texto
Resultados: json · sse

Disponible en Ailoot · entradas y métodos

Ailoot Ultra · Anthropic Messages POST /v1/messages

Tipos de entrada: text
Tipos de salida: json, sse
Formato de salida: JSON o SSE

Campo	Tipo	Requisito	Valores y límites	Predeterminado
Campo`model`	Tipo`string`	RequisitoObligatorio	Valores y límites ~z-ai/glm-latest	Predeterminado—
Campo`messages`	Tipo`message[]`	RequisitoObligatorio	Valores y límites	Predeterminado—
Campo`messages[].role`	Tipo`string`	RequisitoObligatorio	Valores y límites user, assistant	Predeterminado—
Campo`messages[].content`	Tipo`string`	RequisitoObligatorio	Valores y límites	Predeterminado—
Campo`max_tokens`	Tipo`integer`	RequisitoObligatorio	Valores y límites	Predeterminado—
Campo`stream`	Tipo`boolean`	RequisitoOpcional	Valores y límites	Predeterminadofalse

Combinaciones de materiales de entrada

Texto · Texto UTF-8

cadena messages[].content

Parámetros del método y ciclo de vida

Parámetro	Contrato
Parámetro`content_type`	Contratoapplication/json
Parámetro`required`	Contratomodel, messages, max_tokens
Parámetro`optional_controls`	Contratostream
Parámetro`material_types`	Contratotext
Parámetro`text_file_material`	ContratoLee el documento real en UTF-8 y coloca su texto en el campo input indicado o en la cadena de contenido del mensaje.

Ciclo de vida: synchronous_or_streamed

Planes

Las referencias tarifarias no añaden opciones a la solicitud. Los parámetros admitidos se indican en el método seleccionado.

Modo rápido: Tarifa estándar Cuando se selecciona el modo rápido
Modo flex: Tarifa estándar Cuando se selecciona el modo flex
Esfuerzo máximo de razonamiento: Tarifa estándar Cuando el esfuerzo máximo de razonamiento utiliza el ajuste predeterminado (default)
Esfuerzo de razonamiento · alto: Tarifa estándar Cuando el esfuerzo de razonamiento es alto
Esfuerzo de razonamiento · bajo: Tarifa estándar Cuando el esfuerzo de razonamiento es bajo
Esfuerzo de razonamiento · máximo: Tarifa estándar Cuando el esfuerzo de razonamiento es máximo

Tarifas de Ailoot

Precios por configuración

Relaciona cada cargo con las condiciones mostradas. Usa una tarifa para cada conjunto de configuraciones alternativas.

Configuración	Tabla de tarifas	Tokens de contexto, más de	Tokens de contexto, hasta inclusive	Cargo
ConfiguraciónTarifas base por token	Tabla de tarifasTarifa base	Tokens de contexto, más de—	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens
ConfiguraciónTramo 1 por longitud de la solicitud	Tabla de tarifas—	Tokens de contexto, más de0	Tokens de contexto, hasta inclusiveSin límite superior	Cargo Entrada · Tokens de entrada $0.0028 / 1K tokens Salida · Tokens de salida $0.0088 / 1K tokens Entrada · Lectura de caché $0.00052 / 1K tokens Entrada · Escritura en caché — / 1K tokens Entrada · Escritura en caché, 1 hora — / 1K tokens

Solicitudes de ejemplo

Ailoot Ultra · Anthropic Messages

Cuerpo JSON mínimo completocurl · usa tu documento en UTF-8Python · guarda el resultado completo

{
  "model": "~z-ai/glm-latest",
  "max_tokens": 128,
  "messages": [
    {
      "role": "user",
      "content": "Summarize the incident report."
    }
  ],
  "stream": false
}

set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_TEXT_FILE:?Set your actual UTF-8 document}"
export AILOOT_TEXT_FILE
python3 - <<'PY_REQUEST'
import json, os
from pathlib import Path

source_file = Path(os.environ['AILOOT_TEXT_FILE'])
if not source_file.is_file():
    raise SystemExit('Set AILOOT_TEXT_FILE to your actual UTF-8 document')
text = source_file.read_text(encoding='utf-8')
if not text.strip():
    raise SystemExit('Choose a document containing text')
payload = {'model': '~z-ai/glm-latest', 'max_tokens': 128, 'messages': [{'role': 'user', 'content': 'Summarize the incident report.'}]}
payload['messages'][0]['content'] = 'Summarize this material and quote supporting source passages.\n\n' + text
Path('request.json').write_text(json.dumps(payload, ensure_ascii=False), encoding='utf-8')
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

result = json.loads(Path('result.json').read_text(encoding='utf-8'))
print(json.dumps(result, ensure_ascii=False, indent=2))
PY_RESULT

import json, os
from pathlib import Path

source_file = Path(os.environ['AILOOT_TEXT_FILE'])
if not source_file.is_file():
    raise SystemExit('Set AILOOT_TEXT_FILE to your actual UTF-8 document')
text = source_file.read_text(encoding='utf-8')
if not text.strip():
    raise SystemExit('Choose a document containing text')
payload = {'model': '~z-ai/glm-latest', 'max_tokens': 128, 'messages': [{'role': 'user', 'content': 'Summarize the incident report.'}]}
payload['messages'][0]['content'] = 'Summarize this material and quote supporting source passages.\n\n' + text
from urllib.request import Request, urlopen
from urllib.error import HTTPError

api_key = os.environ['AILOOT_API_KEY']
if not api_key.strip():
    raise SystemExit('Set AILOOT_API_KEY before making a request')
headers = {'x-api-key': 'PLACEHOLDER_KEY', 'anthropic-version': '2023-06-01', 'Content-Type': 'application/json'}
headers['x-api-key'] = api_key
request = Request('https://api.ailoot.ai/v1/messages', data=json.dumps(payload, ensure_ascii=False).encode('utf-8'), headers=headers, method='POST')
try:
    with urlopen(request, timeout=120) as response:
        raw = response.read()
        Path('response-headers.txt').write_text(str(response.headers), encoding='utf-8')
except HTTPError as error:
    Path('result.json').write_bytes(error.read())
    Path('response-headers.txt').write_text(str(error.headers), encoding='utf-8')
    raise
Path('result.json').write_bytes(raw)
import json
from pathlib import Path

result = json.loads(Path('result.json').read_text(encoding='utf-8'))
print(json.dumps(result, ensure_ascii=False, indent=2))

Recibir y guardar resultados

Ailoot Ultra · Anthropic Messages

JSON o SSE

Conserva todos los resultados completados

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

Si es necesario revisar la respuesta original

Conserva los ID de solicitud y respuesta y las cabeceras. 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 glm-5.3, glm, glm-5, glm-5.1, glm-5.2, glm-latest
Ailoot Ultra glm-5.3, z-ai/glm-5.3, ~z-ai/glm-latest

Alias de rutas de métodos

/chat/completions

ID de modelo relacionados

z-ai/glm-5.3, glm, glm-5, glm-5.1, glm-5.2, glm-latest, ~z-ai/glm-latest, glm-5.3, glm-5.3

FAQ · Z.ai: GLM 5.3

¿Qué entradas y resultados están disponibles?

POST /v1/messages · glm-5.3: text → text

POST /v1/responses · glm-5.3: text → text

POST /v1/chat/completions · glm-5.3: text → text

POST /v1/messages · glm-5.3: text → json, sse

POST /v1/messages · glm: text → text

POST /v1/responses · glm: text → text

POST /v1/chat/completions · glm: text → text

POST /v1/messages · glm-5: text → text

POST /v1/responses · glm-5: text → text

POST /v1/chat/completions · glm-5: text → text

POST /v1/messages · glm-5.1: text → text

POST /v1/responses · glm-5.1: text → text

POST /v1/chat/completions · glm-5.1: text → text

POST /v1/messages · glm-5.2: text → text

POST /v1/responses · glm-5.2: text → text

POST /v1/chat/completions · glm-5.2: text → text

POST /v1/messages · glm-latest: text → text

POST /v1/responses · glm-latest: text → text

POST /v1/chat/completions · glm-latest: text → text

POST /v1/chat/completions · z-ai/glm-5.3: text → text

POST /v1/messages · z-ai/glm-5.3: text → json, sse

POST /v1/chat/completions · ~z-ai/glm-latest: text → text

POST /v1/messages · ~z-ai/glm-latest: text → json, sse

¿Qué campos utiliza la solicitud?

POST /v1/messages · glm-5.3: model, messages, system, max_tokens, stream, metadata

POST /v1/responses · glm-5.3: model, input, instructions, stream

POST /v1/chat/completions · glm-5.3: model, messages, stream

POST /v1/messages · glm-5.3: model, messages, max_tokens, stream

POST /v1/messages · glm: model, messages, system, max_tokens, stream, metadata

POST /v1/responses · glm: model, input, instructions, stream

POST /v1/chat/completions · glm: model, messages, stream

POST /v1/messages · glm-5: model, messages, system, max_tokens, stream, metadata

POST /v1/responses · glm-5: model, input, instructions, stream

POST /v1/chat/completions · glm-5: model, messages, stream

POST /v1/messages · glm-5.1: model, messages, system, max_tokens, stream, metadata

POST /v1/responses · glm-5.1: model, input, instructions, stream

POST /v1/chat/completions · glm-5.1: model, messages, stream

POST /v1/messages · glm-5.2: model, messages, system, max_tokens, stream, metadata

POST /v1/responses · glm-5.2: model, input, instructions, stream

POST /v1/chat/completions · glm-5.2: model, messages, stream

POST /v1/messages · glm-latest: model, messages, system, max_tokens, stream, metadata

POST /v1/responses · glm-latest: model, input, instructions, stream

POST /v1/chat/completions · glm-latest: model, messages, stream

POST /v1/chat/completions · z-ai/glm-5.3: model, messages, stream, modalities, provider

POST /v1/messages · z-ai/glm-5.3: model, messages, max_tokens, stream

POST /v1/chat/completions · ~z-ai/glm-latest: model, messages, stream, modalities, provider

POST /v1/messages · ~z-ai/glm-latest: model, messages, max_tokens, stream

¿Qué límites se aplican?

POST /v1/messages · glm-5.3: ctx: 1000000; max_out: 131072; messages.min_items: 1; max_tokens.minimum: 1

POST /v1/responses · glm-5.3: ctx: 1000000; max_out: 131072

POST /v1/chat/completions · glm-5.3: ctx: 1000000; max_out: 131072; messages.min_items: 1

POST /v1/chat/completions · glm-5.3: messages.min_items: 1

POST /v1/messages · glm: ctx: 1000000; max_out: 131072; messages.min_items: 1; max_tokens.minimum: 1

POST /v1/responses · glm: ctx: 1000000; max_out: 131072

POST /v1/chat/completions · glm: ctx: 1000000; max_out: 131072; messages.min_items: 1

POST /v1/messages · glm-5: ctx: 1000000; max_out: 131072; messages.min_items: 1; max_tokens.minimum: 1

POST /v1/responses · glm-5: ctx: 1000000; max_out: 131072

POST /v1/chat/completions · glm-5: ctx: 1000000; max_out: 131072; messages.min_items: 1

POST /v1/messages · glm-5.1: ctx: 1000000; max_out: 131072; messages.min_items: 1; max_tokens.minimum: 1

POST /v1/responses · glm-5.1: ctx: 1000000; max_out: 131072

POST /v1/chat/completions · glm-5.1: ctx: 1000000; max_out: 131072; messages.min_items: 1

POST /v1/messages · glm-5.2: ctx: 1000000; max_out: 131072; messages.min_items: 1; max_tokens.minimum: 1

POST /v1/responses · glm-5.2: ctx: 1000000; max_out: 131072

POST /v1/chat/completions · glm-5.2: ctx: 1000000; max_out: 131072; messages.min_items: 1

POST /v1/messages · glm-latest: ctx: 1000000; max_out: 131072; messages.min_items: 1; max_tokens.minimum: 1

POST /v1/responses · glm-latest: ctx: 1000000; max_out: 131072

POST /v1/chat/completions · glm-latest: ctx: 1000000; max_out: 131072; messages.min_items: 1

POST /v1/chat/completions · z-ai/glm-5.3: messages.min_items: 1

POST /v1/chat/completions · ~z-ai/glm-latest: messages.min_items: 1