MiniMax: MiniMax M2

MiniMax M2 é o modelo de texto da MiniMax para programação de ponta a ponta e fluxos de trabalho com agentes, com 10B parâmetros ativos de um total de 230B. O seu perfil publicado inclui raciocínio, ferramentas de função, saídas estruturadas e um contexto de catálogo de 204 800 tokens.

Ailoot · Anthropic Messages POST /v1/messages MiniMax-M2
Ailoot · OpenAI Responses POST /v1/responses MiniMax-M2
Ailoot · OpenAI Chat POST /v1/chat/completions MiniMax-M2
Ailoot Ultra · OpenAI Chat POST /v1/chat/completions MiniMax-M2
Ailoot Ultra · Anthropic Messages POST /v1/messages MiniMax-M2
Ailoot · Anthropic Messages POST /v1/messages minimax/minimax-m2
Ailoot · OpenAI Responses POST /v1/responses minimax/minimax-m2
Ailoot · OpenAI Chat POST /v1/chat/completions minimax/minimax-m2
Ailoot Ultra · OpenAI Chat POST /v1/chat/completions minimax/minimax-m2
Ailoot Ultra · Anthropic Messages POST /v1/messages minimax/minimax-m2

Sobre o modelo

Esta descrição apresenta as capacidades do modelo. As entradas, saídas e opções disponíveis no Ailoot para o método selecionado estão indicadas abaixo.

MiniMax M2 é o modelo de linguagem da MiniMax para programação de ponta a ponta e fluxos de trabalho de agentes. Tem 230 mil milhões de parâmetros no total, dos quais dez mil milhões são ativados. A entrada de texto produz saída de texto. Os metadados publicados do modelo enumeram raciocínio, ferramentas de chamada de funções e saídas estruturadas, com uma janela de contexto de catálogo de 204 800 tokens.

Uma tarefa de programação com um resultado claro

Forneça a implementação relevante, o comportamento observado e o resultado necessário após a alteração. Preserve a entrada que falha e a saída real do erro quando forem determinantes para o diagnóstico. Um pedido de funcionalidade pode identificar as interfaces afetadas e o comportamento que tem de permanecer correto durante a alteração.

Peça um resultado concreto: uma correção focada, um diagnóstico baseado no código-fonte ou a verificação seguinte que esclareça uma questão em aberto. Mantenha as localizações dos ficheiros e os contratos relacionados junto do resultado, para que o trabalho proposto possa ser examinado na parte da aplicação a que se destina.

Raciocínio e observações das ferramentas

Defina as operações disponíveis para a aplicação envolvente. Quando a interface selecionada disponibiliza ferramentas de chamada de funções, o modelo pode propor uma chamada de ferramenta e usar a observação devolvida como evidência para o passo seguinte. Conserve os resultados reais de comandos, consultas ou ficheiros, em vez de tratar a operação proposta como trabalho concluído.

Para um resultado estruturado, especifique os campos, os tipos e o tratamento da informação em falta. Valide tanto a forma devolvida como os seus valores substantivos. Um registo de planeamento ou um facto extraído deve permanecer ligado às evidências de origem que lhe dão significado.

Continue a partir do estado estabelecido

Planeie de acordo com o espaço real de contexto e saída permitido pela interface, reservando lugar para a resposta. Mantenha visíveis as decisões concluídas, as observações atuais e as questões restantes numa tarefa mais longa. Um resultado útil do M2 reúne o resultado com o comportamento a que responde e a validação necessária antes da etapa seguinte de desenvolvimento ou da aplicação.

Tarefa prática

Exemplo técnico em inglês

Preserve omitted fields in an update

A profile update handler uses name = body.get('name') and email = body.get('email'), then writes both fields. A request containing only name erases the stored email. Propose a minimal Python update-building function that changes only supplied fields and preserves explicit null values. Include tests distinguishing an omitted email from an email set to null.

Resultado esperado

A focused partial-update function and two tests showing omission and explicit-null behavior.

Verificar o resultado

The tests demonstrate that absent and present-with-null fields produce different update records.

Ailoot · Anthropic Messages POST /v1/messages MiniMax-M2

MiniMax-M2

MiniMax /MiniMax-M2

ID do modelo

MiniMax-M2
minimax/minimax-m2

Introdução

Entradas aceites: Texto
Resultados: Texto

Disponível no Ailoot · entradas e métodos

Ailoot · Anthropic Messages POST /v1/messages

Entrada: text
Saída: text
Contexto: 204 800 tokens
Saída máxima: 204 800 tokens
Formato de saída: json ou SSE

Campo	Tipo	Requisito	Valores e limites	Predefinição
Campo`model`	Tipo`string`	RequisitoObrigatório	Valores e limites MiniMax-M2	Predefinição—
Campo`messages`	Tipo`message[]`	RequisitoObrigatório	Valores e limites Número mínimo de elementos: 1	Predefinição—
Campo`messages[].role`	Tipo`string`	RequisitoObrigatório	Valores e limites user, assistant	Predefinição—
Campo`messages[].content`	Tipo`string\|content_block[]`	RequisitoObrigatório	Valores e limites	Predefinição—
Campo`system`	Tipo`string\|content_block[]`	RequisitoOpcional	Valores e limites	Predefinição—
Campo`max_tokens`	Tipo`integer`	RequisitoObrigatório	Valores e limites Mínimo: 1 O limite aplica-se a: Limite exato do modelo ou da ficha selecionados	Predefinição—
Campo`stream`	Tipo`boolean`	RequisitoOpcional	Valores e limites	Predefiniçãofalse
Campo`temperature`	Tipo`number`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`top_p`	Tipo`number`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`stop_sequences`	Tipo`string[]`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`tools`	Tipo`tool[]`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`tools[].name`	Tipo`string`	RequisitoOpcional	Valores e limites Aplica-se quando: Ferramenta fornecida	Predefinição—
Campo`tools[].description`	Tipo`string`	RequisitoOpcional	Valores e limites	Predefinição—
Campo`tools[].input_schema`	Tipo`JSON_schema`	RequisitoOpcional	Valores e limites	Predefinição—
Campo`tool_choice`	Tipo`object`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`thinking.type`	Tipo`string`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`thinking.budget_tokens`	Tipo`integer`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`output_config.effort`	Tipo`string`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`metadata`	Tipo`object`	RequisitoOpcional	Valores e limites	Predefinição—
Campo`cache_control`	Tipo`object`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—

Combinações de materiais de entrada

Texto · Texto UTF8

messages[].content ou bloco type=text

Parâmetros e ciclo de vida do método

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`	ContratoConteúdo UTF-8 real inserido como texto; ID de ficheiros/URLs precisam de suporte separado e exato

Ciclo de vida: exact retained published method

As estruturas dos métodos e os ID são exatos; a capacidade do fornecedor é distinta da admissão dos pedidos.

Tarifários

Tarifas dos métodos Ailoot

Ailoot Anthropic MessagesPOST /v1/messages

Entrada: 0,0003 US$ / 1K
Saída: 0,0012 US$ / 1K
Leitura da cache: ≈0,00003 US$ / 1K
Escrita na cache: 0,000375 US$ / 1K
Escrita na cache, 5 min: 0,000375 US$ / 1K tokens

O Ailoot reserva um montante estimado antes de um pedido. Após o resultado, liquida o custo final com base na utilização medida. No streaming, a liquidação usa o registo final de utilização. Como funcionam a reserva e a liquidação →

Detalhes da tarifa de referência

As tabelas de referência do modelo não alteram a seleção do método, as cotações ou os custos. Os custos ativos usam as tarifas do método Ailoot selecionado.

Tabelas de referência do modelo

Preços por configuração

Associe cada custo às condições apresentadas. Use uma única tarifa para cada conjunto de configurações alternativas.

Configuração	Tabela de tarifas	Custo
ConfiguraçãoOpenAI Chat · Tarifas de base por token	Tabela de tarifasTarifa base	Custo Entrada · Tokens de entrada $0.0006 / 1K tokens Saída · Tokens de saída $0.0024 / 1K tokens Entrada · Leitura da cache $0.00006 / 1K tokens Entrada · Escrita na cache $0.00075 / 1K tokens Entrada · Escrita na cache, 1 hora — / 1K tokens
ConfiguraçãoAnthropic Messages · Tarifas de base por token	Tabela de tarifasTarifa base	Custo Entrada · Tokens de entrada $0.0006 / 1K tokens Saída · Tokens de saída $0.0024 / 1K tokens Entrada · Leitura da cache $0.00006 / 1K tokens Entrada · Escrita na cache $0.00075 / 1K tokens Entrada · Escrita na cache, 1 hora — / 1K tokens

Exemplos de pedidos

Ailoot · Anthropic Messages

Exemplo de textoPython SDKNode.js SDKStreaming em 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": "MiniMax-M2", "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="MiniMax-M2",
    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: "MiniMax-M2",
  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='MiniMax-M2',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")

Receber e guardar os resultados

Ailoot · Anthropic Messages

json ou SSE

Guardar todos os resultados concluídos

Guarde cada resposta, ficheiro e parte de conteúdo devolvidos na íntegra.

Conserve todos os blocos de conteúdo, as assinaturas de raciocínio e os ID reais de utilização de ferramentas. Junte todos os deltas de blocos SSE; o primeiro bloco de texto não é a saída completa.

Se for necessário verificar a resposta original

Conserve os ID e cabeçalhos de pedido/resposta. Não é fornecido um URL genérico para obter uma tarefa textual.

Campos da resposta

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

Erros e passos seguintes

Resposta	Condição	Passo seguinte
Resposta400 · `invalid_request_error`	CondiçãoCampos obrigatórios, representação do material ou valor do parâmetro inválidos	Passo seguinteCorrija os campos indicados antes de um novo pedido de criação.

Aliases

Aliases do modelo

Ailoot MiniMax-M2, minimax/minimax-m2
Ailoot Ultra MiniMax-M2, minimax/minimax-m2

Aliases dos caminhos dos métodos

/chat/completions

IDs de chamada relacionados

minimax/minimax-m2, minimax/minimax-m2, MiniMax-M2, MiniMax-M2

Ailoot · OpenAI Responses POST /v1/responses MiniMax-M2

MiniMax-M2

MiniMax /MiniMax-M2

ID do modelo

MiniMax-M2
minimax/minimax-m2

Introdução

Entradas aceites: Texto
Resultados: Texto

Disponível no Ailoot · entradas e métodos

Ailoot · OpenAI Responses POST /v1/responses

Entrada: text
Saída: text
Contexto: 204 800 tokens
Saída máxima: 204 800 tokens
Formato de saída: json ou SSE

Campo	Tipo	Requisito	Valores e limites	Predefinição
Campo`model`	Tipo`string`	RequisitoObrigatório	Valores e limites MiniMax-M2	Predefinição—
Campo`input`	Tipo`string\|input_item[]`	RequisitoObrigatório	Valores e limites	Predefinição—
Campo`instructions`	Tipo`string`	RequisitoOpcional	Valores e limites	Predefinição—
Campo`input[].type`	Tipo`string`	RequisitoOpcional	Valores e limites message, reasoning, function_call, function_call_output	Predefinição—
Campo`input[].content`	Tipo`string\|content_part[]`	RequisitoOpcional	Valores e limites	Predefinição—
Campo`input[].call_id`	Tipo`string`	RequisitoOpcional	Valores e limites Aplica-se quando: function_call_output; conserve o call_id realmente devolvido	Predefinição—
Campo`input[].output`	Tipo`string\|content_part[]`	RequisitoOpcional	Valores e limites Aplica-se quando: function_call_output	Predefinição—
Campo`max_output_tokens`	Tipo`integer`	RequisitoOpcional	Valores e limites Mínimo: 1 Depende do modelo	Predefinição—
Campo`stream`	Tipo`boolean`	RequisitoOpcional	Valores e limites	Predefiniçãofalse
Campo`temperature`	Tipo`number`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`top_p`	Tipo`number`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`tools`	Tipo`tool[]`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`tool_choice`	Tipo`string\|object`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`parallel_tool_calls`	Tipo`boolean`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`reasoning.effort`	Tipo`string`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`reasoning.summary`	Tipo`string`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`text.format`	Tipo`object`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`text.verbosity`	Tipo`string`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`include`	Tipo`string[]`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`store`	Tipo`boolean`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`previous_response_id`	Tipo`string`	RequisitoOpcional	Valores e limites Requisito do ID: Só um ID de resposta real de uma continuação suportada Depende do modelo	Predefinição—
Campo`service_tier`	Tipo`string`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`prompt_cache_key`	Tipo`string`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`prompt_cache_options`	Tipo`object`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—

Combinações de materiais de entrada

Texto · Texto UTF8

Texto de entrada ou parte input_text

Parâmetros e ciclo de vida do método

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`	ContratoConteúdo UTF-8 real inserido como texto; ID de ficheiros/URLs precisam de suporte separado e exato

Ciclo de vida: exact retained published method

As estruturas dos métodos e os ID são exatos; a capacidade do fornecedor é distinta da admissão dos pedidos.

Tarifários

Tarifas dos métodos Ailoot

Ailoot OpenAI ResponsesPOST /v1/responses

Entrada: 0,0003 US$ / 1K
Saída: 0,0012 US$ / 1K
Leitura da cache: ≈0,00003 US$ / 1K
Escrita na cache: 0,000375 US$ / 1K
Escrita na cache, 5 min: 0,000375 US$ / 1K tokens

Detalhes da tarifa de referência

As tabelas de referência do modelo não alteram a seleção do método, as cotações ou os custos. Os custos ativos usam as tarifas do método Ailoot selecionado.

Tabelas de referência do modelo

Preços por configuração

Associe cada custo às condições apresentadas. Use uma única tarifa para cada conjunto de configurações alternativas.

Configuração	Tabela de tarifas	Custo
ConfiguraçãoOpenAI Chat · Tarifas de base por token	Tabela de tarifasTarifa base	Custo Entrada · Tokens de entrada $0.0006 / 1K tokens Saída · Tokens de saída $0.0024 / 1K tokens Entrada · Leitura da cache $0.00006 / 1K tokens Entrada · Escrita na cache $0.00075 / 1K tokens Entrada · Escrita na cache, 1 hora — / 1K tokens
ConfiguraçãoAnthropic Messages · Tarifas de base por token	Tabela de tarifasTarifa base	Custo Entrada · Tokens de entrada $0.0006 / 1K tokens Saída · Tokens de saída $0.0024 / 1K tokens Entrada · Leitura da cache $0.00006 / 1K tokens Entrada · Escrita na cache $0.00075 / 1K tokens Entrada · Escrita na cache, 1 hora — / 1K tokens

Exemplos de pedidos

Ailoot · OpenAI Responses

Exemplo de textoPython SDKNode.js SDKStreaming em 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": "MiniMax-M2", "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="MiniMax-M2", 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: "MiniMax-M2", 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="MiniMax-M2", 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")

Receber e guardar os resultados

Ailoot · OpenAI Responses

json ou SSE

Guardar todos os resultados concluídos

Guarde cada resposta, ficheiro e parte de conteúdo devolvidos na íntegra.

Conserve cada elemento de saída e parte de conteúdo, o call_id real da função, o raciocínio cifrado e os dados de utilização. Em streaming, mantenha a identidade completa dos eventos e elementos.

Se for necessário verificar a resposta original

Conserve os ID e cabeçalhos de pedido/resposta. Não é fornecido um URL genérico para obter uma tarefa textual.

Campos da resposta

Campo	Tipo
Campo`id`	Tipostring
Campo`status`	Tipostring
Campo`output[]`	Tipomessage\|reasoning\|function_call\|other item
Campo`output[].content[]`	Tipocontent part
Campo`usage`	Tipoobject

Erros e passos seguintes

Resposta	Condição	Passo seguinte
Resposta400 · `invalid_request_error`	CondiçãoCampos obrigatórios, representação do material ou valor do parâmetro inválidos	Passo seguinteCorrija os campos indicados antes de um novo pedido de criação.

Aliases

Aliases do modelo

Ailoot MiniMax-M2, minimax/minimax-m2
Ailoot Ultra MiniMax-M2, minimax/minimax-m2

Aliases dos caminhos dos métodos

/chat/completions

IDs de chamada relacionados

minimax/minimax-m2, minimax/minimax-m2, MiniMax-M2, MiniMax-M2

Ailoot · OpenAI Chat POST /v1/chat/completions MiniMax-M2

MiniMax-M2

MiniMax /MiniMax-M2

ID do modelo

MiniMax-M2
minimax/minimax-m2

Introdução

Entradas aceites: Texto
Resultados: Texto

Disponível no Ailoot · entradas e métodos

Ailoot · OpenAI Chat POST /v1/chat/completions

Entrada: text
Saída: text
Contexto: 204 800 tokens
Saída máxima: 204 800 tokens
Formato de saída: json ou SSE

Campo	Tipo	Requisito	Valores e limites	Predefinição
Campo`model`	Tipo`string`	RequisitoObrigatório	Valores e limites MiniMax-M2	Predefinição—
Campo`messages`	Tipo`message[]`	RequisitoObrigatório	Valores e limites Número mínimo de elementos: 1	Predefinição—
Campo`messages[].role`	Tipo`string`	RequisitoObrigatório	Valores e limites Exemplos: system, user, assistant, tool, function Condições: Estes papéis são representados explicitamente pelos tipos de compatibilidade do código-fonte; o conjunto exato de papéis continua específico do modelo. Depende do modelo	Predefinição—
Campo`messages[].content`	Tipo`string\|content_part[]\|null`	RequisitoOpcional	Valores e limites	Predefinição—
Campo`messages[].tool_calls`	Tipo`tool_call[]`	RequisitoOpcional	Valores e limites	Predefinição—
Campo`messages[].tool_call_id`	Tipo`string`	RequisitoOpcional	Valores e limites Aplica-se quando: role=tool; use o ID realmente devolvido	Predefinição—
Campo`messages[].name`	Tipo`string`	RequisitoOpcional	Valores e limites	Predefinição—
Campo`messages[].reasoning_content`	Tipo`string`	RequisitoOpcional	Valores e limites Aplica-se quando: Reintroduza o raciocínio realmente devolvido quando este modelo o utiliza	Predefinição—
Campo`messages[].reasoning_details`	Tipo`object\|array`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`max_tokens`	Tipo`integer`	RequisitoOpcional	Valores e limites Mínimo: 1 Depende do modelo	Predefinição—
Campo`max_completion_tokens`	Tipo`integer`	RequisitoOpcional	Valores e limites Mínimo: 1 Depende do modelo	Predefinição—
Campo`stream`	Tipo`boolean`	RequisitoOpcional	Valores e limites	Predefiniçãofalse
Campo`stream_options.include_usage`	Tipo`boolean`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`temperature`	Tipo`number`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`top_p`	Tipo`number`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`stop`	Tipo`string\|string[]`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`tools`	Tipo`function_tool[]`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`tools[].type`	Tipo`string`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`tools[].function.name`	Tipo`string`	RequisitoObrigatório	Valores e limites Aplica-se quando: Função fornecida como ferramenta	Predefinição—
Campo`tools[].function.description`	Tipo`string`	RequisitoOpcional	Valores e limites	Predefinição—
Campo`tools[].function.parameters`	Tipo`JSON_schema`	RequisitoOpcional	Valores e limites	Predefinição—
Campo`tool_choice`	Tipo`string\|object`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`parallel_tool_calls`	Tipo`boolean`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`response_format`	Tipo`object`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`reasoning_effort`	Tipo`string`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`reasoning`	Tipo`object`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`service_tier`	Tipo`string`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`instructions`	Tipo`string`	RequisitoOpcional	Valores e limites Campo de compatibilidade	Predefinição—
Campo`functions`	Tipo`function[]`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`function_call`	Tipo`string\|object`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`prompt_cache_options`	Tipo`object`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—

Combinações de materiais de entrada

Texto · Texto UTF8

messages[].content

Parâmetros e ciclo de vida do método

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`	ContratoConteúdo UTF-8 real inserido como texto; ID de ficheiros/URLs precisam de suporte separado e exato

Ciclo de vida: exact retained published method

As estruturas dos métodos e os ID são exatos; a capacidade do fornecedor é distinta da admissão dos pedidos.

Tarifários

Tarifas dos métodos Ailoot

Ailoot OpenAI ChatPOST /v1/chat/completions

Entrada: 0,0003 US$ / 1K
Saída: 0,0012 US$ / 1K
Leitura da cache: ≈0,00003 US$ / 1K
Escrita na cache: 0,000375 US$ / 1K
Escrita na cache, 5 min: 0,000375 US$ / 1K tokens

Detalhes da tarifa de referência

As tabelas de referência do modelo não alteram a seleção do método, as cotações ou os custos. Os custos ativos usam as tarifas do método Ailoot selecionado.

Tabelas de referência do modelo

Preços por configuração

Associe cada custo às condições apresentadas. Use uma única tarifa para cada conjunto de configurações alternativas.

Configuração	Tabela de tarifas	Custo
ConfiguraçãoOpenAI Chat · Tarifas de base por token	Tabela de tarifasTarifa base	Custo Entrada · Tokens de entrada $0.0006 / 1K tokens Saída · Tokens de saída $0.0024 / 1K tokens Entrada · Leitura da cache $0.00006 / 1K tokens Entrada · Escrita na cache $0.00075 / 1K tokens Entrada · Escrita na cache, 1 hora — / 1K tokens
ConfiguraçãoAnthropic Messages · Tarifas de base por token	Tabela de tarifasTarifa base	Custo Entrada · Tokens de entrada $0.0006 / 1K tokens Saída · Tokens de saída $0.0024 / 1K tokens Entrada · Leitura da cache $0.00006 / 1K tokens Entrada · Escrita na cache $0.00075 / 1K tokens Entrada · Escrita na cache, 1 hora — / 1K tokens

Exemplos de pedidos

Ailoot · OpenAI Chat

Exemplo de textoPython SDKNode.js SDKStreaming em 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": "MiniMax-M2", "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="MiniMax-M2",
    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: "MiniMax-M2",
  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='MiniMax-M2',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")

Receber e guardar os resultados

Ailoot · OpenAI Chat

json ou SSE

Guardar todos os resultados concluídos

Guarde cada resposta, ficheiro e parte de conteúdo devolvidos na íntegra.

Conserve cada opção com o conteúdo, as chamadas de ferramentas e o raciocínio. Em SSE, junte os deltas por índice de opção e ferramenta e mantenha o motivo final de conclusão e os dados de utilização.

Se for necessário verificar a resposta original

Conserve os ID e cabeçalhos de pedido/resposta. Não é fornecido um URL genérico para obter uma tarefa textual.

Campos da resposta

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

Erros e passos seguintes

Resposta	Condição	Passo seguinte
Resposta400 · `invalid_request_error`	CondiçãoCampos obrigatórios, representação do material ou valor do parâmetro inválidos	Passo seguinteCorrija os campos indicados antes de um novo pedido de criação.

Aliases

Aliases do modelo

Ailoot MiniMax-M2, minimax/minimax-m2
Ailoot Ultra MiniMax-M2, minimax/minimax-m2

Aliases dos caminhos dos métodos

/chat/completions

IDs de chamada relacionados

minimax/minimax-m2, minimax/minimax-m2, MiniMax-M2, MiniMax-M2

Ailoot Ultra · OpenAI Chat POST /v1/chat/completions MiniMax-M2

MiniMax-M2

MiniMax /MiniMax-M2

ID do modelo

MiniMax-M2
minimax/minimax-m2

Introdução

Entradas aceites: Texto
Resultados: Texto

Disponível no Ailoot · entradas e métodos

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

Entrada: text
Saída: text
Formato de saída: json ou SSE

Campo	Tipo	Requisito	Valores e limites	Predefinição
Campo`model`	Tipo`string`	RequisitoObrigatório	Valores e limites MiniMax-M2	Predefinição—
Campo`messages`	Tipo`message[]`	RequisitoObrigatório	Valores e limites Número mínimo de elementos: 1	Predefinição—
Campo`messages[].role`	Tipo`string`	RequisitoObrigatório	Valores e limites Depende do modelo	Predefinição—
Campo`messages[].content`	Tipo`string`	RequisitoOpcional	Valores e limites Aplica-se quando: Conversação textual	Predefinição—
Campo`stream`	Tipo`boolean`	RequisitoOpcional	Valores e limites	Predefiniçãofalse

Combinações de materiais de entrada

Texto · Texto UTF8

messages[].content

Parâmetros e ciclo de vida do método

Parâmetro	Contrato
Parâmetro`content_type`	Contratoapplication/json
Parâmetro`required`	Contratomodel, messages
Parâmetro`material_types`	Contratotext
Parâmetro`messages`	ContratoLista de mensagens com estrutura role/content
Parâmetro`file_material`	ContratoDocumento UTF-8 real inserido como texto literal; nenhum ID de ficheiro inferido
Parâmetro`optional_controls`	Contratostream
Parâmetro`control_scope`	ContratoConversação textual; stream é um booleano e tem false como predefinição.
Parâmetro`output_modalities`	Contratotext
Parâmetro`hosted_operations`	Contratofalse
Parâmetro`multimodal_input_binding`	Contratonull

Aliases do método: /chat/completions

Ciclo de vida: synchronous_or_streamed

Envie o ID exato do modelo com messages.

O comprimento do contexto não é um limite de saída.

Um ficheiro de texto pode fornecer texto literal; as entradas de imagem/áudio/objeto de ficheiro exigem uma associação exata.

Tarifários

As referências tarifárias não acrescentam opções ao pedido. Os parâmetros suportados constam do método selecionado.

Modo rápido: Não especificado Quando o modo rápido está selecionado
Modo flex: Não especificado Quando o modo flex está selecionado
Esforço máximo de raciocínio: Não especificado Quando o esforço máximo de raciocínio usa o ajuste predefinido (default)

Tarifas Ailoot

Preços por configuração

Configuração	Tabela de tarifas	Custo
ConfiguraçãoTarifas base dos tokens	Tabela de tarifasTarifa base	Custo Entrada · Tokens de entrada $0.0006 / 1K tokens Saída · Tokens de saída $0.0024 / 1K tokens Entrada · Leitura da cache $0.00006 / 1K tokens Entrada · Escrita na cache $0.00075 / 1K tokens Entrada · Escrita na cache, 1 hora — / 1K tokens

Exemplos de pedidos

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":"MiniMax-M2","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="MiniMax-M2", 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"))

Receber e guardar os resultados

Ailoot Ultra · OpenAI Chat

json ou SSE

Guardar todos os resultados concluídos

Guarde cada resposta, ficheiro e parte de conteúdo devolvidos na íntegra.

Se for necessário verificar a resposta original

Conserve os ID e cabeçalhos de pedido/resposta. Não é fornecido um URL genérico para obter uma tarefa textual.

Campos da resposta

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

Erros e passos seguintes

Resposta	Condição	Passo seguinte
Resposta400 · `invalid_request_error`	CondiçãoCampos obrigatórios, representação do material ou valor do parâmetro inválidos	Passo seguinteCorrija os campos indicados antes de um novo pedido de criação.

Aliases

Aliases do modelo

Ailoot MiniMax-M2, minimax/minimax-m2
Ailoot Ultra MiniMax-M2, minimax/minimax-m2

Aliases dos caminhos dos métodos

/chat/completions

IDs de chamada relacionados

minimax/minimax-m2, minimax/minimax-m2, MiniMax-M2, MiniMax-M2

Ailoot Ultra · Anthropic Messages POST /v1/messages MiniMax-M2

MiniMax-M2

MiniMax /MiniMax-M2

ID do modelo

MiniMax-M2
minimax/minimax-m2

Introdução

Entradas aceites: Texto
Resultados: json · sse

Disponível no Ailoot · entradas e métodos

Ailoot Ultra · Anthropic Messages POST /v1/messages

Entrada: text
Saída: json, sse
Formato de saída: JSON ou SSE

Campo	Tipo	Requisito	Valores e limites	Predefinição
Campo`model`	Tipo`string`	RequisitoObrigatório	Valores e limites MiniMax-M2	Predefinição—
Campo`messages`	Tipo`message[]`	RequisitoObrigatório	Valores e limites	Predefinição—
Campo`messages[].role`	Tipo`string`	RequisitoObrigatório	Valores e limites user, assistant	Predefinição—
Campo`messages[].content`	Tipo`string`	RequisitoObrigatório	Valores e limites	Predefinição—
Campo`max_tokens`	Tipo`integer`	RequisitoObrigatório	Valores e limites	Predefinição—
Campo`stream`	Tipo`boolean`	RequisitoOpcional	Valores e limites	Predefiniçãofalse

Combinações de materiais de entrada

Texto · Texto UTF-8

Cadeia de caracteres messages[].content

Parâmetros e ciclo de vida do método

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`	ContratoLeia o documento UTF-8 real e coloque o texto na entrada indicada ou na cadeia de conteúdo da mensagem.

Ciclo de vida: synchronous_or_streamed

Tarifários

As referências tarifárias não acrescentam opções ao pedido. Os parâmetros suportados constam do método selecionado.

Modo rápido: Não especificado Quando o modo rápido está selecionado
Modo flex: Não especificado Quando o modo flex está selecionado
Esforço máximo de raciocínio: Não especificado Quando o esforço máximo de raciocínio usa o ajuste predefinido (default)

Tarifas Ailoot

Preços por configuração

Configuração	Tabela de tarifas	Custo
ConfiguraçãoTarifas base dos tokens	Tabela de tarifasTarifa base	Custo Entrada · Tokens de entrada $0.0006 / 1K tokens Saída · Tokens de saída $0.0024 / 1K tokens Entrada · Leitura da cache $0.00006 / 1K tokens Entrada · Escrita na cache $0.00075 / 1K tokens Entrada · Escrita na cache, 1 hora — / 1K tokens

Exemplos de pedidos

Ailoot Ultra · Anthropic Messages

Corpo JSON mínimo completocurl · use o seu documento UTF-8Python · guarde o resultado completo

{
  "model": "MiniMax-M2",
  "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': 'MiniMax-M2', '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': 'MiniMax-M2', '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))

Receber e guardar os resultados

Ailoot Ultra · Anthropic Messages

JSON ou SSE

Guardar todos os resultados concluídos

Guarde cada resposta, ficheiro e parte de conteúdo devolvidos na íntegra.

Se for necessário verificar a resposta original

Conserve os ID e cabeçalhos de pedido/resposta. Não é fornecido um URL genérico para obter uma tarefa textual.

Campos da resposta

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

Erros e passos seguintes

Resposta	Condição	Passo seguinte
Resposta400 · `invalid_request_error`	CondiçãoCampos obrigatórios, representação do material ou valor do parâmetro inválidos	Passo seguinteCorrija os campos indicados antes de um novo pedido de criação.

Aliases

Aliases do modelo

Ailoot MiniMax-M2, minimax/minimax-m2
Ailoot Ultra MiniMax-M2, minimax/minimax-m2

Aliases dos caminhos dos métodos

/chat/completions

IDs de chamada relacionados

minimax/minimax-m2, minimax/minimax-m2, MiniMax-M2, MiniMax-M2

Ailoot · Anthropic Messages POST /v1/messages minimax/minimax-m2

minimax/minimax-m2

MiniMax /minimax/minimax-m2

ID do modelo

MiniMax-M2
minimax/minimax-m2

Introdução

Entradas aceites: Texto
Resultados: Texto

Disponível no Ailoot · entradas e métodos

Ailoot · Anthropic Messages POST /v1/messages

Entrada: text
Saída: text
Contexto: 204 800 tokens
Saída máxima: 204 800 tokens
Formato de saída: json ou SSE

Campo	Tipo	Requisito	Valores e limites	Predefinição
Campo`model`	Tipo`string`	RequisitoObrigatório	Valores e limites minimax/minimax-m2	Predefinição—
Campo`messages`	Tipo`message[]`	RequisitoObrigatório	Valores e limites Número mínimo de elementos: 1	Predefinição—
Campo`messages[].role`	Tipo`string`	RequisitoObrigatório	Valores e limites user, assistant	Predefinição—
Campo`messages[].content`	Tipo`string\|content_block[]`	RequisitoObrigatório	Valores e limites	Predefinição—
Campo`system`	Tipo`string\|content_block[]`	RequisitoOpcional	Valores e limites	Predefinição—
Campo`max_tokens`	Tipo`integer`	RequisitoObrigatório	Valores e limites Mínimo: 1 O limite aplica-se a: Limite exato do modelo ou da ficha selecionados	Predefinição—
Campo`stream`	Tipo`boolean`	RequisitoOpcional	Valores e limites	Predefiniçãofalse
Campo`temperature`	Tipo`number`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`top_p`	Tipo`number`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`stop_sequences`	Tipo`string[]`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`tools`	Tipo`tool[]`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`tools[].name`	Tipo`string`	RequisitoOpcional	Valores e limites Aplica-se quando: Ferramenta fornecida	Predefinição—
Campo`tools[].description`	Tipo`string`	RequisitoOpcional	Valores e limites	Predefinição—
Campo`tools[].input_schema`	Tipo`JSON_schema`	RequisitoOpcional	Valores e limites	Predefinição—
Campo`tool_choice`	Tipo`object`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`thinking.type`	Tipo`string`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`thinking.budget_tokens`	Tipo`integer`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`output_config.effort`	Tipo`string`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`metadata`	Tipo`object`	RequisitoOpcional	Valores e limites	Predefinição—
Campo`cache_control`	Tipo`object`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—

Combinações de materiais de entrada

Texto · Texto UTF8

messages[].content ou bloco type=text

Parâmetros e ciclo de vida do método

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`	ContratoConteúdo UTF-8 real inserido como texto; ID de ficheiros/URLs precisam de suporte separado e exato

Ciclo de vida: exact retained published method

As estruturas dos métodos e os ID são exatos; a capacidade do fornecedor é distinta da admissão dos pedidos.

Tarifários

Tarifas dos métodos Ailoot

Ailoot Anthropic MessagesPOST /v1/messages

Entrada: 0,0003 US$ / 1K
Saída: 0,0012 US$ / 1K
Leitura da cache: ≈0,00003 US$ / 1K
Escrita na cache: 0,000375 US$ / 1K
Escrita na cache, 5 min: 0,000375 US$ / 1K tokens

Detalhes da tarifa de referência

As tabelas de referência do modelo não alteram a seleção do método, as cotações ou os custos. Os custos ativos usam as tarifas do método Ailoot selecionado.

Tabelas de referência do modelo

Preços por configuração

Associe cada custo às condições apresentadas. Use uma única tarifa para cada conjunto de configurações alternativas.

Configuração	Tabela de tarifas	Custo
ConfiguraçãoOpenAI Chat · Tarifas de base por token	Tabela de tarifasTarifa base	Custo Entrada · Tokens de entrada $0.0006 / 1K tokens Saída · Tokens de saída $0.0024 / 1K tokens Entrada · Leitura da cache $0.00006 / 1K tokens Entrada · Escrita na cache $0.00075 / 1K tokens Entrada · Escrita na cache, 1 hora — / 1K tokens
ConfiguraçãoAnthropic Messages · Tarifas de base por token	Tabela de tarifasTarifa base	Custo Entrada · Tokens de entrada $0.0006 / 1K tokens Saída · Tokens de saída $0.0024 / 1K tokens Entrada · Leitura da cache $0.00006 / 1K tokens Entrada · Escrita na cache $0.00075 / 1K tokens Entrada · Escrita na cache, 1 hora — / 1K tokens

Exemplos de pedidos

Ailoot · Anthropic Messages

Exemplo de textoPython SDKNode.js SDKStreaming em 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": "minimax/minimax-m2", "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="minimax/minimax-m2",
    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: "minimax/minimax-m2",
  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='minimax/minimax-m2',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")

Receber e guardar os resultados

Ailoot · Anthropic Messages

json ou SSE

Guardar todos os resultados concluídos

Guarde cada resposta, ficheiro e parte de conteúdo devolvidos na íntegra.

Se for necessário verificar a resposta original

Conserve os ID e cabeçalhos de pedido/resposta. Não é fornecido um URL genérico para obter uma tarefa textual.

Campos da resposta

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

Erros e passos seguintes

Resposta	Condição	Passo seguinte
Resposta400 · `invalid_request_error`	CondiçãoCampos obrigatórios, representação do material ou valor do parâmetro inválidos	Passo seguinteCorrija os campos indicados antes de um novo pedido de criação.

Aliases

Aliases do modelo

Ailoot MiniMax-M2, minimax/minimax-m2
Ailoot Ultra MiniMax-M2, minimax/minimax-m2

Aliases dos caminhos dos métodos

/chat/completions

IDs de chamada relacionados

minimax/minimax-m2, minimax/minimax-m2, MiniMax-M2, MiniMax-M2

Ailoot · OpenAI Responses POST /v1/responses minimax/minimax-m2

minimax/minimax-m2

MiniMax /minimax/minimax-m2

ID do modelo

MiniMax-M2
minimax/minimax-m2

Introdução

Entradas aceites: Texto
Resultados: Texto

Disponível no Ailoot · entradas e métodos

Ailoot · OpenAI Responses POST /v1/responses

Entrada: text
Saída: text
Contexto: 204 800 tokens
Saída máxima: 204 800 tokens
Formato de saída: json ou SSE

Campo	Tipo	Requisito	Valores e limites	Predefinição
Campo`model`	Tipo`string`	RequisitoObrigatório	Valores e limites minimax/minimax-m2	Predefinição—
Campo`input`	Tipo`string\|input_item[]`	RequisitoObrigatório	Valores e limites	Predefinição—
Campo`instructions`	Tipo`string`	RequisitoOpcional	Valores e limites	Predefinição—
Campo`input[].type`	Tipo`string`	RequisitoOpcional	Valores e limites message, reasoning, function_call, function_call_output	Predefinição—
Campo`input[].content`	Tipo`string\|content_part[]`	RequisitoOpcional	Valores e limites	Predefinição—
Campo`input[].call_id`	Tipo`string`	RequisitoOpcional	Valores e limites Aplica-se quando: function_call_output; conserve o call_id realmente devolvido	Predefinição—
Campo`input[].output`	Tipo`string\|content_part[]`	RequisitoOpcional	Valores e limites Aplica-se quando: function_call_output	Predefinição—
Campo`max_output_tokens`	Tipo`integer`	RequisitoOpcional	Valores e limites Mínimo: 1 Depende do modelo	Predefinição—
Campo`stream`	Tipo`boolean`	RequisitoOpcional	Valores e limites	Predefiniçãofalse
Campo`temperature`	Tipo`number`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`top_p`	Tipo`number`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`tools`	Tipo`tool[]`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`tool_choice`	Tipo`string\|object`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`parallel_tool_calls`	Tipo`boolean`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`reasoning.effort`	Tipo`string`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`reasoning.summary`	Tipo`string`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`text.format`	Tipo`object`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`text.verbosity`	Tipo`string`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`include`	Tipo`string[]`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`store`	Tipo`boolean`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`previous_response_id`	Tipo`string`	RequisitoOpcional	Valores e limites Requisito do ID: Só um ID de resposta real de uma continuação suportada Depende do modelo	Predefinição—
Campo`service_tier`	Tipo`string`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`prompt_cache_key`	Tipo`string`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`prompt_cache_options`	Tipo`object`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—

Combinações de materiais de entrada

Texto · Texto UTF8

Texto de entrada ou parte input_text

Parâmetros e ciclo de vida do método

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`	ContratoConteúdo UTF-8 real inserido como texto; ID de ficheiros/URLs precisam de suporte separado e exato

Ciclo de vida: exact retained published method

As estruturas dos métodos e os ID são exatos; a capacidade do fornecedor é distinta da admissão dos pedidos.

Tarifários

Tarifas dos métodos Ailoot

Ailoot OpenAI ResponsesPOST /v1/responses

Entrada: 0,0003 US$ / 1K
Saída: 0,0012 US$ / 1K
Leitura da cache: ≈0,00003 US$ / 1K
Escrita na cache: 0,000375 US$ / 1K
Escrita na cache, 5 min: 0,000375 US$ / 1K tokens

Detalhes da tarifa de referência

As tabelas de referência do modelo não alteram a seleção do método, as cotações ou os custos. Os custos ativos usam as tarifas do método Ailoot selecionado.

Tabelas de referência do modelo

Preços por configuração

Associe cada custo às condições apresentadas. Use uma única tarifa para cada conjunto de configurações alternativas.

Configuração	Tabela de tarifas	Custo
ConfiguraçãoOpenAI Chat · Tarifas de base por token	Tabela de tarifasTarifa base	Custo Entrada · Tokens de entrada $0.0006 / 1K tokens Saída · Tokens de saída $0.0024 / 1K tokens Entrada · Leitura da cache $0.00006 / 1K tokens Entrada · Escrita na cache $0.00075 / 1K tokens Entrada · Escrita na cache, 1 hora — / 1K tokens
ConfiguraçãoAnthropic Messages · Tarifas de base por token	Tabela de tarifasTarifa base	Custo Entrada · Tokens de entrada $0.0006 / 1K tokens Saída · Tokens de saída $0.0024 / 1K tokens Entrada · Leitura da cache $0.00006 / 1K tokens Entrada · Escrita na cache $0.00075 / 1K tokens Entrada · Escrita na cache, 1 hora — / 1K tokens

Exemplos de pedidos

Ailoot · OpenAI Responses

Exemplo de textoPython SDKNode.js SDKStreaming em 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": "minimax/minimax-m2", "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="minimax/minimax-m2", 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: "minimax/minimax-m2", 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="minimax/minimax-m2", 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")

Receber e guardar os resultados

Ailoot · OpenAI Responses

json ou SSE

Guardar todos os resultados concluídos

Guarde cada resposta, ficheiro e parte de conteúdo devolvidos na íntegra.

Se for necessário verificar a resposta original

Conserve os ID e cabeçalhos de pedido/resposta. Não é fornecido um URL genérico para obter uma tarefa textual.

Campos da resposta

Campo	Tipo
Campo`id`	Tipostring
Campo`status`	Tipostring
Campo`output[]`	Tipomessage\|reasoning\|function_call\|other item
Campo`output[].content[]`	Tipocontent part
Campo`usage`	Tipoobject

Erros e passos seguintes

Resposta	Condição	Passo seguinte
Resposta400 · `invalid_request_error`	CondiçãoCampos obrigatórios, representação do material ou valor do parâmetro inválidos	Passo seguinteCorrija os campos indicados antes de um novo pedido de criação.

Aliases

Aliases do modelo

Ailoot MiniMax-M2, minimax/minimax-m2
Ailoot Ultra MiniMax-M2, minimax/minimax-m2

Aliases dos caminhos dos métodos

/chat/completions

IDs de chamada relacionados

minimax/minimax-m2, minimax/minimax-m2, MiniMax-M2, MiniMax-M2

Ailoot · OpenAI Chat POST /v1/chat/completions minimax/minimax-m2

minimax/minimax-m2

MiniMax /minimax/minimax-m2

ID do modelo

MiniMax-M2
minimax/minimax-m2

Introdução

Entradas aceites: Texto
Resultados: Texto

Disponível no Ailoot · entradas e métodos

Ailoot · OpenAI Chat POST /v1/chat/completions

Entrada: text
Saída: text
Contexto: 204 800 tokens
Saída máxima: 204 800 tokens
Formato de saída: json ou SSE

Campo	Tipo	Requisito	Valores e limites	Predefinição
Campo`model`	Tipo`string`	RequisitoObrigatório	Valores e limites minimax/minimax-m2	Predefinição—
Campo`messages`	Tipo`message[]`	RequisitoObrigatório	Valores e limites Número mínimo de elementos: 1	Predefinição—
Campo`messages[].role`	Tipo`string`	RequisitoObrigatório	Valores e limites Exemplos: system, user, assistant, tool, function Condições: Estes papéis são representados explicitamente pelos tipos de compatibilidade do código-fonte; o conjunto exato de papéis continua específico do modelo. Depende do modelo	Predefinição—
Campo`messages[].content`	Tipo`string\|content_part[]\|null`	RequisitoOpcional	Valores e limites	Predefinição—
Campo`messages[].tool_calls`	Tipo`tool_call[]`	RequisitoOpcional	Valores e limites	Predefinição—
Campo`messages[].tool_call_id`	Tipo`string`	RequisitoOpcional	Valores e limites Aplica-se quando: role=tool; use o ID realmente devolvido	Predefinição—
Campo`messages[].name`	Tipo`string`	RequisitoOpcional	Valores e limites	Predefinição—
Campo`messages[].reasoning_content`	Tipo`string`	RequisitoOpcional	Valores e limites Aplica-se quando: Reintroduza o raciocínio realmente devolvido quando este modelo o utiliza	Predefinição—
Campo`messages[].reasoning_details`	Tipo`object\|array`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`max_tokens`	Tipo`integer`	RequisitoOpcional	Valores e limites Mínimo: 1 Depende do modelo	Predefinição—
Campo`max_completion_tokens`	Tipo`integer`	RequisitoOpcional	Valores e limites Mínimo: 1 Depende do modelo	Predefinição—
Campo`stream`	Tipo`boolean`	RequisitoOpcional	Valores e limites	Predefiniçãofalse
Campo`stream_options.include_usage`	Tipo`boolean`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`temperature`	Tipo`number`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`top_p`	Tipo`number`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`stop`	Tipo`string\|string[]`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`tools`	Tipo`function_tool[]`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`tools[].type`	Tipo`string`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`tools[].function.name`	Tipo`string`	RequisitoObrigatório	Valores e limites Aplica-se quando: Função fornecida como ferramenta	Predefinição—
Campo`tools[].function.description`	Tipo`string`	RequisitoOpcional	Valores e limites	Predefinição—
Campo`tools[].function.parameters`	Tipo`JSON_schema`	RequisitoOpcional	Valores e limites	Predefinição—
Campo`tool_choice`	Tipo`string\|object`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`parallel_tool_calls`	Tipo`boolean`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`response_format`	Tipo`object`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`reasoning_effort`	Tipo`string`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`reasoning`	Tipo`object`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`service_tier`	Tipo`string`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`instructions`	Tipo`string`	RequisitoOpcional	Valores e limites Campo de compatibilidade	Predefinição—
Campo`functions`	Tipo`function[]`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`function_call`	Tipo`string\|object`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`prompt_cache_options`	Tipo`object`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—

Combinações de materiais de entrada

Texto · Texto UTF8

messages[].content

Parâmetros e ciclo de vida do método

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`	ContratoConteúdo UTF-8 real inserido como texto; ID de ficheiros/URLs precisam de suporte separado e exato

Ciclo de vida: exact retained published method

As estruturas dos métodos e os ID são exatos; a capacidade do fornecedor é distinta da admissão dos pedidos.

Tarifários

Tarifas dos métodos Ailoot

Ailoot OpenAI ChatPOST /v1/chat/completions

Entrada: 0,0003 US$ / 1K
Saída: 0,0012 US$ / 1K
Leitura da cache: ≈0,00003 US$ / 1K
Escrita na cache: 0,000375 US$ / 1K
Escrita na cache, 5 min: 0,000375 US$ / 1K tokens

Detalhes da tarifa de referência

As tabelas de referência do modelo não alteram a seleção do método, as cotações ou os custos. Os custos ativos usam as tarifas do método Ailoot selecionado.

Tabelas de referência do modelo

Preços por configuração

Associe cada custo às condições apresentadas. Use uma única tarifa para cada conjunto de configurações alternativas.

Configuração	Tabela de tarifas	Custo
ConfiguraçãoOpenAI Chat · Tarifas de base por token	Tabela de tarifasTarifa base	Custo Entrada · Tokens de entrada $0.0006 / 1K tokens Saída · Tokens de saída $0.0024 / 1K tokens Entrada · Leitura da cache $0.00006 / 1K tokens Entrada · Escrita na cache $0.00075 / 1K tokens Entrada · Escrita na cache, 1 hora — / 1K tokens
ConfiguraçãoAnthropic Messages · Tarifas de base por token	Tabela de tarifasTarifa base	Custo Entrada · Tokens de entrada $0.0006 / 1K tokens Saída · Tokens de saída $0.0024 / 1K tokens Entrada · Leitura da cache $0.00006 / 1K tokens Entrada · Escrita na cache $0.00075 / 1K tokens Entrada · Escrita na cache, 1 hora — / 1K tokens

Exemplos de pedidos

Ailoot · OpenAI Chat

Exemplo de textoPython SDKNode.js SDKStreaming em 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": "minimax/minimax-m2", "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="minimax/minimax-m2",
    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: "minimax/minimax-m2",
  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='minimax/minimax-m2',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")

Receber e guardar os resultados

Ailoot · OpenAI Chat

json ou SSE

Guardar todos os resultados concluídos

Guarde cada resposta, ficheiro e parte de conteúdo devolvidos na íntegra.

Se for necessário verificar a resposta original

Conserve os ID e cabeçalhos de pedido/resposta. Não é fornecido um URL genérico para obter uma tarefa textual.

Campos da resposta

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

Erros e passos seguintes

Resposta	Condição	Passo seguinte
Resposta400 · `invalid_request_error`	CondiçãoCampos obrigatórios, representação do material ou valor do parâmetro inválidos	Passo seguinteCorrija os campos indicados antes de um novo pedido de criação.

Aliases

Aliases do modelo

Ailoot MiniMax-M2, minimax/minimax-m2
Ailoot Ultra MiniMax-M2, minimax/minimax-m2

Aliases dos caminhos dos métodos

/chat/completions

IDs de chamada relacionados

minimax/minimax-m2, minimax/minimax-m2, MiniMax-M2, MiniMax-M2

Ailoot Ultra · OpenAI Chat POST /v1/chat/completions minimax/minimax-m2

minimax/minimax-m2

MiniMax /minimax/minimax-m2

ID do modelo

MiniMax-M2
minimax/minimax-m2

Introdução

Entradas aceites: Texto
Resultados: Texto

Disponível no Ailoot · entradas e métodos

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

Entrada: text
Saída: text
Formato de saída: json ou SSE

Campo	Tipo	Requisito	Valores e limites	Predefinição
Campo`model`	Tipo`string`	RequisitoObrigatório	Valores e limites minimax/minimax-m2	Predefinição—
Campo`messages`	Tipo`message[]`	RequisitoObrigatório	Valores e limites Número mínimo de elementos: 1	Predefinição—
Campo`messages[].role`	Tipo`string`	RequisitoObrigatório	Valores e limites Exemplos: system, user, assistant, tool, function Condições: Estes papéis são representados explicitamente pelos tipos de compatibilidade do código-fonte; o conjunto exato de papéis continua específico do modelo. Depende do modelo	Predefinição—
Campo`messages[].content`	Tipo`string\|content_part[]\|null`	RequisitoOpcional	Valores e limites	Predefinição—
Campo`messages[].tool_calls`	Tipo`tool_call[]`	RequisitoOpcional	Valores e limites	Predefinição—
Campo`messages[].tool_call_id`	Tipo`string`	RequisitoOpcional	Valores e limites Aplica-se quando: role=tool; use o ID realmente devolvido	Predefinição—
Campo`messages[].name`	Tipo`string`	RequisitoOpcional	Valores e limites	Predefinição—
Campo`messages[].reasoning_content`	Tipo`string`	RequisitoOpcional	Valores e limites Aplica-se quando: Reintroduza o raciocínio realmente devolvido quando este modelo o utiliza	Predefinição—
Campo`messages[].reasoning_details`	Tipo`object\|array`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`max_tokens`	Tipo`integer`	RequisitoOpcional	Valores e limites Mínimo: 1 Depende do modelo	Predefinição—
Campo`max_completion_tokens`	Tipo`integer`	RequisitoOpcional	Valores e limites Mínimo: 1 Depende do modelo	Predefinição—
Campo`stream`	Tipo`boolean`	RequisitoOpcional	Valores e limites	Predefiniçãofalse
Campo`stream_options.include_usage`	Tipo`boolean`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`temperature`	Tipo`number`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`top_p`	Tipo`number`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`stop`	Tipo`string\|string[]`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`tools`	Tipo`function_tool[]`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`tools[].type`	Tipo`string`	RequisitoOpcional	Valores e limites function Depende do modelo	Predefinição—
Campo`tools[].function.name`	Tipo`string`	RequisitoObrigatório	Valores e limites Aplica-se quando: Função fornecida como ferramenta	Predefinição—
Campo`tools[].function.description`	Tipo`string`	RequisitoOpcional	Valores e limites	Predefinição—
Campo`tools[].function.parameters`	Tipo`JSON_schema`	RequisitoOpcional	Valores e limites	Predefinição—
Campo`tool_choice`	Tipo`string\|object`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`parallel_tool_calls`	Tipo`boolean`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`response_format`	Tipo`object`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`reasoning_effort`	Tipo`string`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`reasoning`	Tipo`object`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`service_tier`	Tipo`string`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`instructions`	Tipo`string`	RequisitoOpcional	Valores e limites Campo de compatibilidade	Predefinição—
Campo`functions`	Tipo`function[]`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`function_call`	Tipo`string\|object`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`prompt_cache_options`	Tipo`object`	RequisitoOpcional	Valores e limites Depende do modelo	Predefinição—
Campo`modalities`	Tipo`string[]`	RequisitoOpcional	Valores e limites text	Predefinição—
Campo`provider`	Tipo`object`	RequisitoOpcional	Valores e limites Condições: provider.options é rejeitado nesta rota textual Ultra	Predefinição—
Campo`cache_control.ttl`	Tipo`string`	RequisitoOpcional	Valores e limites Condições: 1h é rejeitado nos locais efetivos da cache de prompts	Predefinição—

Combinações de materiais de entrada

Texto · Texto UTF8

messages[].content

Parâmetros e ciclo de vida do método

Parâmetro	Contrato
Parâmetro`content_type`	Contratoapplication/json
Parâmetro`required`	Contratomodel, messages
Parâmetro`material_types`	Contratotext
Parâmetro`messages`	ContratoLista de mensagens com estrutura role/content
Parâmetro`file_material`	ContratoDocumento UTF-8 real inserido como texto literal; nenhum ID de ficheiro inferido
Parâmetro`optional_controls`	Contratostream, temperature, top_p, stop, max_tokens, max_completion_tokens, reasoning, response_format, tools, tool_choice
Parâmetro`control_scope`	ContratoEspecífico do modelo; as ferramentas de funções do utilizador diferem das ferramentas alojadas
Parâmetro`output_modalities`	Contratotext
Parâmetro`hosted_operations`	Contratofalse
Parâmetro`multimodal_input_binding`	Contratonull

Ciclo de vida: synchronous_or_streamed

Envie o ID exato do modelo com messages.

O comprimento do contexto não é um limite de saída.

Um ficheiro de texto pode fornecer texto literal; as entradas de imagem/áudio/objeto de ficheiro exigem uma associação exata.

Tarifários

As referências tarifárias não acrescentam opções ao pedido. Os parâmetros suportados constam do método selecionado.

Modo rápido: Não especificado Quando o modo rápido está selecionado
Modo flex: Não especificado Quando o modo flex está selecionado
Esforço máximo de raciocínio: Não especificado Quando o esforço máximo de raciocínio usa o ajuste predefinido (default)

Tarifas Ailoot

Preços por configuração

Configuração	Tabela de tarifas	Custo
ConfiguraçãoTarifas base dos tokens	Tabela de tarifasTarifa base	Custo Entrada · Tokens de entrada $0.0006 / 1K tokens Saída · Tokens de saída $0.0024 / 1K tokens Entrada · Leitura da cache $0.00006 / 1K tokens Entrada · Escrita na cache $0.00075 / 1K tokens Entrada · Escrita na cache, 1 hora — / 1K tokens

Exemplos de pedidos

Ailoot Ultra · OpenAI Chat

curlPython SDKStreaming em 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": "minimax/minimax-m2", "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='minimax/minimax-m2',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='minimax/minimax-m2',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")

Receber e guardar os resultados

Ailoot Ultra · OpenAI Chat

json ou SSE

Guardar todos os resultados concluídos

Guarde cada resposta, ficheiro e parte de conteúdo devolvidos na íntegra.

Se for necessário verificar a resposta original

Conserve os ID e cabeçalhos de pedido/resposta. Não é fornecido um URL genérico para obter uma tarefa textual.

Campos da resposta

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

Erros e passos seguintes

Resposta	Condição	Passo seguinte
Resposta400 · `invalid_request_error`	CondiçãoCampos obrigatórios, representação do material ou valor do parâmetro inválidos	Passo seguinteCorrija os campos indicados antes de um novo pedido de criação.

Aliases

Aliases do modelo

Ailoot MiniMax-M2, minimax/minimax-m2
Ailoot Ultra MiniMax-M2, minimax/minimax-m2

Aliases dos caminhos dos métodos

/chat/completions

IDs de chamada relacionados

minimax/minimax-m2, minimax/minimax-m2, MiniMax-M2, MiniMax-M2

Ailoot Ultra · Anthropic Messages POST /v1/messages minimax/minimax-m2

minimax/minimax-m2

MiniMax /minimax/minimax-m2

ID do modelo

MiniMax-M2
minimax/minimax-m2

Introdução

Entradas aceites: Texto
Resultados: json · sse

Disponível no Ailoot · entradas e métodos

Ailoot Ultra · Anthropic Messages POST /v1/messages

Entrada: text
Saída: json, sse
Formato de saída: JSON ou SSE

Campo	Tipo	Requisito	Valores e limites	Predefinição
Campo`model`	Tipo`string`	RequisitoObrigatório	Valores e limites minimax/minimax-m2	Predefinição—
Campo`messages`	Tipo`message[]`	RequisitoObrigatório	Valores e limites	Predefinição—
Campo`messages[].role`	Tipo`string`	RequisitoObrigatório	Valores e limites user, assistant	Predefinição—
Campo`messages[].content`	Tipo`string`	RequisitoObrigatório	Valores e limites	Predefinição—
Campo`max_tokens`	Tipo`integer`	RequisitoObrigatório	Valores e limites	Predefinição—
Campo`stream`	Tipo`boolean`	RequisitoOpcional	Valores e limites	Predefiniçãofalse

Combinações de materiais de entrada

Texto · Texto UTF-8

Cadeia de caracteres messages[].content

Parâmetros e ciclo de vida do método

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`	ContratoLeia o documento UTF-8 real e coloque o texto na entrada indicada ou na cadeia de conteúdo da mensagem.

Ciclo de vida: synchronous_or_streamed

Tarifários

As referências tarifárias não acrescentam opções ao pedido. Os parâmetros suportados constam do método selecionado.

Modo rápido: Não especificado Quando o modo rápido está selecionado
Modo flex: Não especificado Quando o modo flex está selecionado
Esforço máximo de raciocínio: Não especificado Quando o esforço máximo de raciocínio usa o ajuste predefinido (default)

Tarifas Ailoot

Preços por configuração

Configuração	Tabela de tarifas	Custo
ConfiguraçãoTarifas base dos tokens	Tabela de tarifasTarifa base	Custo Entrada · Tokens de entrada $0.0006 / 1K tokens Saída · Tokens de saída $0.0024 / 1K tokens Entrada · Leitura da cache $0.00006 / 1K tokens Entrada · Escrita na cache $0.00075 / 1K tokens Entrada · Escrita na cache, 1 hora — / 1K tokens

Exemplos de pedidos

Ailoot Ultra · Anthropic Messages

Corpo JSON mínimo completocurl · use o seu documento UTF-8Python · guarde o resultado completo

{
  "model": "minimax/minimax-m2",
  "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': 'minimax/minimax-m2', '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': 'minimax/minimax-m2', '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))

Receber e guardar os resultados

Ailoot Ultra · Anthropic Messages

JSON ou SSE

Guardar todos os resultados concluídos

Guarde cada resposta, ficheiro e parte de conteúdo devolvidos na íntegra.

Se for necessário verificar a resposta original

Conserve os ID e cabeçalhos de pedido/resposta. Não é fornecido um URL genérico para obter uma tarefa textual.

Campos da resposta

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

Erros e passos seguintes

Resposta	Condição	Passo seguinte
Resposta400 · `invalid_request_error`	CondiçãoCampos obrigatórios, representação do material ou valor do parâmetro inválidos	Passo seguinteCorrija os campos indicados antes de um novo pedido de criação.

Aliases

Aliases do modelo

Ailoot MiniMax-M2, minimax/minimax-m2
Ailoot Ultra MiniMax-M2, minimax/minimax-m2

Aliases dos caminhos dos métodos

/chat/completions

IDs de chamada relacionados

minimax/minimax-m2, minimax/minimax-m2, MiniMax-M2, MiniMax-M2

FAQ · MiniMax: MiniMax M2

Que entradas e resultados estão disponíveis?

POST /v1/messages · MiniMax-M2: text → text

POST /v1/responses · MiniMax-M2: text → text

POST /v1/chat/completions · MiniMax-M2: text → text

POST /v1/messages · MiniMax-M2: text → json, sse

POST /v1/messages · minimax/minimax-m2: text → text

POST /v1/responses · minimax/minimax-m2: text → text

POST /v1/chat/completions · minimax/minimax-m2: text → text

POST /v1/messages · minimax/minimax-m2: text → json, sse

Que campos utiliza o pedido?

POST /v1/messages · MiniMax-M2: model, messages, system, max_tokens, stream, metadata

POST /v1/responses · MiniMax-M2: model, input, instructions, stream

POST /v1/chat/completions · MiniMax-M2: model, messages, stream

POST /v1/messages · MiniMax-M2: model, messages, max_tokens, stream

POST /v1/messages · minimax/minimax-m2: model, messages, system, max_tokens, stream, metadata

POST /v1/responses · minimax/minimax-m2: model, input, instructions, stream

POST /v1/chat/completions · minimax/minimax-m2: model, messages, stream

POST /v1/chat/completions · minimax/minimax-m2: model, messages, stream, modalities, provider

POST /v1/messages · minimax/minimax-m2: model, messages, max_tokens, stream

Que limites se aplicam?

POST /v1/messages · MiniMax-M2: ctx: 204800; max_out: 204800; messages.min_items: 1; max_tokens.minimum: 1

POST /v1/responses · MiniMax-M2: ctx: 204800; max_out: 204800

POST /v1/chat/completions · MiniMax-M2: ctx: 204800; max_out: 204800; messages.min_items: 1

POST /v1/chat/completions · MiniMax-M2: messages.min_items: 1

POST /v1/messages · minimax/minimax-m2: ctx: 204800; max_out: 204800; messages.min_items: 1; max_tokens.minimum: 1

POST /v1/responses · minimax/minimax-m2: ctx: 204800; max_out: 204800

POST /v1/chat/completions · minimax/minimax-m2: ctx: 204800; max_out: 204800; messages.min_items: 1

POST /v1/chat/completions · minimax/minimax-m2: messages.min_items: 1