Travel Flask
Small
Capacity: 350 ml
Large
Capacity: 600 ml
Schematron V2 Small is Inference.net’s extraction-quality model for turning HTML into schema-conforming JSON. The manufacturer develops it for complex schemas and long pages, with a distinct workload role from the throughput-focused V2 Turbo. It reads the HTML and the caller’s schema and returns the corresponding structured record. The goal is extracting the facts needed by a downstream application, not generating a broad conversational response.
The producer guide says extraction instructions belong in the schema rather than a natural-language system or user prompt. Define each property’s type and explain its meaning in the field description. Nested objects and lists are supported. A product record, for example, can distinguish a product identifier from its displayed name and group specification values in their own object.
For a complex page, resolve ambiguous field meanings before asking for extraction. Explain whether a date refers to publication, an event or a revision, and how multiple source values should be represented. Use a schema convention for missing information so the model does not have to invent a value to make the object appear complete. The maker demonstrates typed models and JSON Schema alongside validation of the returned JSON.
The recommended HTML preprocessing removes scripts, styles and boilerplate while retaining relevant content. The manufacturer advises being conservative: removing too much can lose the information the extraction needs. Keep table headings, nested labels and the nearby text that establishes what a value means. Trim to the relevant region when the page contains unrelated navigation or repeated material.
An illustrative task is to extract a technical record from a product page with several configuration tables. The input should preserve which table belongs to which variant, and the schema should describe the specific variant or the list of variants required. The resulting JSON can then be checked against those source rows rather than treated as a summary of the whole website.
V2 Small emphasises extraction quality for difficult schemas and long HTML. Turbo is the separate version optimised for processing pages at higher throughput. Both share the V2 family’s documented 128K context and strict schema-guided JSON workflow. The context budget contains the input and requested output together, so focus a large page around the record the task actually needs.
A structured object can support catalogue ingestion, document parsing or an evidence layer for a search-assisted answer. The application obtains the source page, provides the schema and validates the output before using it. Retain the page identifier or source association in that surrounding workflow. If the record includes numbers, compare the units and the intended interpretation with the source.
Schema conformity establishes the form of the result; it does not independently verify every extracted fact. Review representative records against the original HTML and define the handling of conflicting or absent information. V2 Small remains its own named release, separate from V1 open-weight checkpoints. Its documented interface is HTML-to-JSON extraction and does not imply image inputs, general conversation, automatic web access or a native tool-execution workflow.
", "aboutText": "Schematron V2 Small is Inference.net’s extraction-quality model for turning HTML into schema-conforming JSON. The manufacturer develops it for complex schemas and long pages, with a distinct workload role from the throughput-focused V2 Turbo. It reads the HTML and the caller’s schema and returns the corresponding structured record. The goal is extracting the facts needed by a downstream application, not generating a broad conversational response.\n\n### Schema as the task specification\n\nThe producer guide says extraction instructions belong in the schema rather than a natural-language system or user prompt. Define each property’s type and explain its meaning in the field description. Nested objects and lists are supported. A product record, for example, can distinguish a product identifier from its displayed name and group specification values in their own object.\n\nFor a complex page, resolve ambiguous field meanings before asking for extraction. Explain whether a date refers to publication, an event or a revision, and how multiple source values should be represented. Use a schema convention for missing information so the model does not have to invent a value to make the object appear complete. The maker demonstrates typed models and JSON Schema alongside validation of the returned JSON.\n\n### Preparing a long document\n\nThe recommended HTML preprocessing removes scripts, styles and boilerplate while retaining relevant content. The manufacturer advises being conservative: removing too much can lose the information the extraction needs. Keep table headings, nested labels and the nearby text that establishes what a value means. Trim to the relevant region when the page contains unrelated navigation or repeated material.\n\nAn illustrative task is to extract a technical record from a product page with several configuration tables. The input should preserve which table belongs to which variant, and the schema should describe the specific variant or the list of variants required. The resulting JSON can then be checked against those source rows rather than treated as a summary of the whole website.\n\n### Small and Turbo are separate choices\n\nV2 Small emphasises extraction quality for difficult schemas and long HTML. Turbo is the separate version optimised for processing pages at higher throughput. Both share the V2 family’s documented 128K context and strict schema-guided JSON workflow. The context budget contains the input and requested output together, so focus a large page around the record the task actually needs.\n\n### From extraction to application data\n\nA structured object can support catalogue ingestion, document parsing or an evidence layer for a search-assisted answer. The application obtains the source page, provides the schema and validates the output before using it. Retain the page identifier or source association in that surrounding workflow. If the record includes numbers, compare the units and the intended interpretation with the source.\n\nSchema conformity establishes the form of the result; it does not independently verify every extracted fact. Review representative records against the original HTML and define the handling of conflicting or absent information. V2 Small remains its own named release, separate from V1 open-weight checkpoints. Its documented interface is HTML-to-JSON extraction and does not imply image inputs, general conversation, automatic web access or a native tool-execution workflow.", "editorialOverlay": { "copy_fields": { "practical_html": "Technical example in English
Extract product variants from HTML\n\nHTML source: <article><h1>Travel Flask</h1><section><h2>Small</h2><p>Capacity: 350 ml</p></section><section><h2>Large</h2><p>Capacity: 600 ml</p></section></article>. Extraction specification for the existing schema-guided workflow: product_name is the article title; variants is a list of objects containing name, capacity_value as an integer and capacity_unit as text. Return only the extracted record; preserve section-to-value associations.A target JSON record with product_name and two variants, each containing name, integer capacity_value and capacity_unit.Validate the returned record against the configured extraction schema and both source sections; do not swap capacities.inference-net/schematron-v2-smallSchematron V2 Small extracts schema-defined facts from supplied HTML into typed JSON. It is the V2 quality-oriented option for complex schemas and long pages, with a 128K producer context, nested records and field descriptions that specify the data to return.
This description covers the model’s capabilities. Available in Ailoot inputs, outputs and options are listed for the selected method below.
Schematron V2 Small is Inference.net’s extraction-quality model for turning HTML into schema-conforming JSON. The manufacturer develops it for complex schemas and long pages, with a distinct workload role from the throughput-focused V2 Turbo. It reads the HTML and the caller’s schema and returns the corresponding structured record. The goal is extracting the facts needed by a downstream application, not generating a broad conversational response.
The producer guide says extraction instructions belong in the schema rather than a natural-language system or user prompt. Define each property’s type and explain its meaning in the field description. Nested objects and lists are supported. A product record, for example, can distinguish a product identifier from its displayed name and group specification values in their own object.
For a complex page, resolve ambiguous field meanings before asking for extraction. Explain whether a date refers to publication, an event or a revision, and how multiple source values should be represented. Use a schema convention for missing information so the model does not have to invent a value to make the object appear complete. The maker demonstrates typed models and JSON Schema alongside validation of the returned JSON.
The recommended HTML preprocessing removes scripts, styles and boilerplate while retaining relevant content. The manufacturer advises being conservative: removing too much can lose the information the extraction needs. Keep table headings, nested labels and the nearby text that establishes what a value means. Trim to the relevant region when the page contains unrelated navigation or repeated material.
An illustrative task is to extract a technical record from a product page with several configuration tables. The input should preserve which table belongs to which variant, and the schema should describe the specific variant or the list of variants required. The resulting JSON can then be checked against those source rows rather than treated as a summary of the whole website.
V2 Small emphasises extraction quality for difficult schemas and long HTML. Turbo is the separate version optimised for processing pages at higher throughput. Both share the V2 family’s documented 128K context and strict schema-guided JSON workflow. The context budget contains the input and requested output together, so focus a large page around the record the task actually needs.
A structured object can support catalogue ingestion, document parsing or an evidence layer for a search-assisted answer. The application obtains the source page, provides the schema and validates the output before using it. Retain the page identifier or source association in that surrounding workflow. If the record includes numbers, compare the units and the intended interpretation with the source.
Schema conformity establishes the form of the result; it does not independently verify every extracted fact. Review representative records against the original HTML and define the handling of conflicting or absent information. V2 Small remains its own named release, separate from V1 open-weight checkpoints. Its documented interface is HTML-to-JSON extraction and does not imply image inputs, general conversation, automatic web access or a native tool-execution workflow.
POST /v1/chat/completionstexttext| Field | Type | Requirement | Values & limits | Default |
|---|---|---|---|---|
Fieldmodel | Typestring | RequirementRequired | Values & limits inference-net/schematron-v2-small | Default— |
Fieldmessages | Typemessage[] | RequirementRequired | Values & limits Minimum items: 1 | Default— |
Fieldmessages[].role | Typestring | RequirementRequired | Values & limits Examples: system, user, assistant, tool, function Conditions: These roles are explicitly represented by Source compatibility types; the exact model role set remains model-specific. Model-specific | Default— |
Fieldmessages[].content | Typestring|content_part[]|null | RequirementOptional | Values & limits | Default— |
Fieldmessages[].tool_calls | Typetool_call[] | RequirementOptional | Values & limits | Default— |
Fieldmessages[].tool_call_id | Typestring | RequirementOptional | Values & limits Applies when: role=tool; use actual returned ID | Default— |
Fieldmessages[].name | Typestring | RequirementOptional | Values & limits | Default— |
Fieldmessages[].reasoning_content | Typestring | RequirementOptional | Values & limits Applies when: Round-trip actual returned reasoning where this model uses it | Default— |
Fieldmessages[].reasoning_details | Typeobject|array | RequirementOptional | Values & limits Model-specific | Default— |
Fieldmax_tokens | Typeinteger | RequirementOptional | Values & limits Minimum: 1 Model-specific | Default— |
Fieldmax_completion_tokens | Typeinteger | RequirementOptional | Values & limits Minimum: 1 Model-specific | Default— |
Fieldstream | Typeboolean | RequirementOptional | Values & limits | Defaultfalse |
Fieldstream_options.include_usage | Typeboolean | RequirementOptional | Values & limits Model-specific | Default— |
Fieldtemperature | Typenumber | RequirementOptional | Values & limits Model-specific | Default— |
Fieldtop_p | Typenumber | RequirementOptional | Values & limits Model-specific | Default— |
Fieldstop | Typestring|string[] | RequirementOptional | Values & limits Model-specific | Default— |
Fieldtools | Typefunction_tool[] | RequirementOptional | Values & limits Model-specific | Default— |
Fieldtools[].type | Typestring | RequirementOptional | Values & limits function Model-specific | Default— |
Fieldtools[].function.name | Typestring | RequirementRequired | Values & limits Applies when: function tool supplied | Default— |
Fieldtools[].function.description | Typestring | RequirementOptional | Values & limits | Default— |
Fieldtools[].function.parameters | TypeJSON_schema | RequirementOptional | Values & limits | Default— |
Fieldtool_choice | Typestring|object | RequirementOptional | Values & limits Model-specific | Default— |
Fieldparallel_tool_calls | Typeboolean | RequirementOptional | Values & limits Model-specific | Default— |
Fieldresponse_format | Typeobject | RequirementOptional | Values & limits Model-specific | Default— |
Fieldreasoning_effort | Typestring | RequirementOptional | Values & limits Model-specific | Default— |
Fieldreasoning | Typeobject | RequirementOptional | Values & limits Model-specific | Default— |
Fieldservice_tier | Typestring | RequirementOptional | Values & limits Model-specific | Default— |
Fieldinstructions | Typestring | RequirementOptional | Values & limits Compatibility field | Default— |
Fieldfunctions | Typefunction[] | RequirementOptional | Values & limits Model-specific | Default— |
Fieldfunction_call | Typestring|object | RequirementOptional | Values & limits Model-specific | Default— |
Fieldprompt_cache_options | Typeobject | RequirementOptional | Values & limits Model-specific | Default— |
Fieldmodalities | Typestring[] | RequirementOptional | Values & limits text | Default— |
Fieldprovider | Typeobject | RequirementOptional | Values & limits Conditions: provider.options is rejected on this Ultra text route | Default— |
Fieldcache_control.ttl | Typestring | RequirementOptional | Values & limits Conditions: 1h is rejected in actual prompt-cache locations | Default— |
Text · UTF8 text
messages[].content
| Parameter | Contract |
|---|---|
Parametercontent_type | Contractapplication/json |
Parameterrequired | Contractmodel, messages |
Parametermaterial_types | Contracttext |
Parametermessages | Contractmessage array with role/content shape |
Parameterfile_material | Contractactual UTF-8 document inserted as literal text; no file ID inferred |
Parameteroptional_controls | Contractstream, temperature, top_p, stop, max_tokens, max_completion_tokens, reasoning, response_format, tools, tool_choice |
Parametercontrol_scope | Contractmodel-specific; user function tools differ from hosted tools |
Parameteroutput_modalities | Contracttext |
Parameterhosted_operations | Contractfalse |
Parametermultimodal_input_binding | Contractnull |
Lifecycle: synchronous_or_streamed
Send exact model ID with messages.
Context length is not an output cap.
A text file may supply literal text; image/audio/file-object inputs need exact binding.
Tariff references do not add request options. Supported parameters are listed for the selected method.
Match each charge to the conditions shown. Use one rate for each set of alternative configurations.
| Configuration | Rate schedule | Context tokens, more than | Context tokens, up to and including | Charge |
|---|---|---|---|---|
| ConfigurationBase token rates | Rate scheduleBase rate | Context tokens, more than— | Context tokens, up to and includingNo upper bound | Charge Input · Input tokens $0.0001 / 1K tokens Output · Output tokens $0.00046 / 1K tokens Input · Cache read $0.0001 / 1K tokens Input · Cache write — / 1K tokens Input · Cache write, 1 hour — / 1K tokens |
| ConfigurationRequest-length tier 1 | Rate schedule— | Context tokens, more than0 | Context tokens, up to and includingNo upper bound | Charge Input · Input tokens $0.0001 / 1K tokens Output · Output tokens $0.00046 / 1K tokens Input · Cache read $0.0001 / 1K tokens Input · Cache write — / 1K tokens Input · Cache write, 1 hour — / 1K tokens |
Ailoot reserves an estimated amount before a request. After the result, it settles the final charge from measured usage. Streaming settlement uses the final usage record. How reservation and settlement work →
set -eu\n: "${AILOOT_API_KEY:?Set your Ailoot API key}"\npython3 - <<'PY_REQUEST'\nimport json,os\nfrom pathlib import Path\np=json.loads('{"model": "inference-net/schematron-v2-small", "messages": [{"role": "user", "content": "Explain the difference between an observation and a hypothesis in three sentences."}]}')\n\nPath("request.json").write_text(json.dumps(p,ensure_ascii=False))\nPY_REQUEST\ncurl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/chat/completions \\\n -H "Authorization: Bearer $AILOOT_API_KEY" -H 'Content-Type: application/json' \\\n --data-binary @request.json -D response-headers.txt -o result.json\npython3 - <<'PY_RESULT'\nimport json\nfrom pathlib import Path\nr=json.loads(Path("result.json").read_text())\nfor x in r.get("choices",[]):\n if x.get("message",{}).get("content"): print(x["message"]["content"])\nPY_RESULT\nfrom openai import OpenAI\nimport os\n\nif not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")\nclient=OpenAI(base_url="https://api.ailoot.ai/v1",api_key=os.environ["AILOOT_API_KEY"],max_retries=0)\nresult=client.chat.completions.create(model='inference-net/schematron-v2-small',messages=[{"role":"user","content":"Explain observations and hypotheses in three sentences."}])\nimport base64, json\nfrom pathlib import Path\n\ndef save_result(data, stem="result"):\n # Keep every field, including usage, IDs, reasoning and tool requests.\n Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")\n print(json.dumps(data, ensure_ascii=False, indent=2))\n def save_blob(encoded, suffix, label):\n raw = base64.b64decode(encoded, altchars=b"-_", validate=True)\n 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\n file = Path(stem + "-" + label + "." + ext)\n file.write_bytes(raw)\n print("Saved", file)\n for index, block in enumerate(data.get("content") or []):\n print("Content", index, json.dumps(block, ensure_ascii=False))\n for choice in data.get("choices") or []:\n print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))\n for index, item in enumerate(data.get("output") or []):\n print("Output", index, json.dumps(item, ensure_ascii=False))\n if item.get("type") == "image_generation_call" and item.get("result"):\n save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))\n for ci, candidate in enumerate(data.get("candidates") or []):\n for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):\n print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))\n blob = part.get("inlineData") or part.get("inline_data")\n if blob and blob.get("data"):\n mime = blob.get("mimeType") or blob.get("mime_type")\n suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")\n save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))\n\nsave_result(result.to_dict(mode="json"))\nfrom openai import OpenAI\nimport os\nfrom pathlib import Path\n\nif not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")\nclient=OpenAI(base_url="https://api.ailoot.ai/v1",api_key=os.environ["AILOOT_API_KEY"],max_retries=0)\nimport base64, json\nfrom pathlib import Path\n\ndef save_result(data, stem="result"):\n # Keep every field, including usage, IDs, reasoning and tool requests.\n Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")\n print(json.dumps(data, ensure_ascii=False, indent=2))\n def save_blob(encoded, suffix, label):\n raw = base64.b64decode(encoded, altchars=b"-_", validate=True)\n 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\n file = Path(stem + "-" + label + "." + ext)\n file.write_bytes(raw)\n print("Saved", file)\n for index, block in enumerate(data.get("content") or []):\n print("Content", index, json.dumps(block, ensure_ascii=False))\n for choice in data.get("choices") or []:\n print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))\n for index, item in enumerate(data.get("output") or []):\n print("Output", index, json.dumps(item, ensure_ascii=False))\n if item.get("type") == "image_generation_call" and item.get("result"):\n save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))\n for ci, candidate in enumerate(data.get("candidates") or []):\n for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):\n print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))\n blob = part.get("inlineData") or part.get("inline_data")\n if blob and blob.get("data"):\n mime = blob.get("mimeType") or blob.get("mime_type")\n suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")\n save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))\n\nwith client.chat.completions.stream(model='inference-net/schematron-v2-small',messages=[{"role":"user","content":"Explain observations and hypotheses in three sentences."}]) as stream:\n with Path("stream-events.jsonl").open("w",encoding="utf-8") as log:\n for event in stream:\n payload=event.to_dict(mode="json")\n log.write(json.dumps(payload,ensure_ascii=False)+"\\n"); log.flush()\n print(json.dumps(payload,ensure_ascii=False))\n final=stream.get_final_completion()\n save_result(final.to_dict(mode="json"),"stream-result")\njson or SSE
Keep every complete returned response, file and content part.
Keep every choice and its content/tool calls/reasoning. In SSE assemble deltas by choice/tool index, retain the final finish reason and usage.
Keep request/response IDs and headers. No generic text job retrieval URL is supplied.
| Field | Type |
|---|---|
Fieldchoices[].index | Typeinteger |
Fieldchoices[].message.content | Typestring|null |
Fieldchoices[].message.tool_calls | Typetool_call[] |
Fieldchoices[].message.reasoning_content | Typestring |
Fieldchoices[].message.reasoning_details | Typeobject|array |
Fieldchoices[].finish_reason | Typestring|null |
Fieldusage | Typeobject |
| Response | Condition | Next step |
|---|---|---|
Response400 · invalid_request_error | ConditionInvalid required fields, material representation or parameter value | Next stepCorrect the indicated fields before a new creation request. |
Ailoot Ultra inference-net/schematron-v2-small
Use the method paths shown above.
inference-net/schematron-v2-smallSchematron V2 Small extracts schema-defined facts from supplied HTML into typed JSON. It is the V2 quality-oriented option for complex schemas and long pages, with a 128K producer context, nested records and field descriptions that specify the data to return.
This description covers the model’s capabilities. Available in Ailoot inputs, outputs and options are listed for the selected method below.
Schematron V2 Small is Inference.net’s extraction-quality model for turning HTML into schema-conforming JSON. The manufacturer develops it for complex schemas and long pages, with a distinct workload role from the throughput-focused V2 Turbo. It reads the HTML and the caller’s schema and returns the corresponding structured record. The goal is extracting the facts needed by a downstream application, not generating a broad conversational response.
The producer guide says extraction instructions belong in the schema rather than a natural-language system or user prompt. Define each property’s type and explain its meaning in the field description. Nested objects and lists are supported. A product record, for example, can distinguish a product identifier from its displayed name and group specification values in their own object.
For a complex page, resolve ambiguous field meanings before asking for extraction. Explain whether a date refers to publication, an event or a revision, and how multiple source values should be represented. Use a schema convention for missing information so the model does not have to invent a value to make the object appear complete. The maker demonstrates typed models and JSON Schema alongside validation of the returned JSON.
The recommended HTML preprocessing removes scripts, styles and boilerplate while retaining relevant content. The manufacturer advises being conservative: removing too much can lose the information the extraction needs. Keep table headings, nested labels and the nearby text that establishes what a value means. Trim to the relevant region when the page contains unrelated navigation or repeated material.
An illustrative task is to extract a technical record from a product page with several configuration tables. The input should preserve which table belongs to which variant, and the schema should describe the specific variant or the list of variants required. The resulting JSON can then be checked against those source rows rather than treated as a summary of the whole website.
V2 Small emphasises extraction quality for difficult schemas and long HTML. Turbo is the separate version optimised for processing pages at higher throughput. Both share the V2 family’s documented 128K context and strict schema-guided JSON workflow. The context budget contains the input and requested output together, so focus a large page around the record the task actually needs.
A structured object can support catalogue ingestion, document parsing or an evidence layer for a search-assisted answer. The application obtains the source page, provides the schema and validates the output before using it. Retain the page identifier or source association in that surrounding workflow. If the record includes numbers, compare the units and the intended interpretation with the source.
Schema conformity establishes the form of the result; it does not independently verify every extracted fact. Review representative records against the original HTML and define the handling of conflicting or absent information. V2 Small remains its own named release, separate from V1 open-weight checkpoints. Its documented interface is HTML-to-JSON extraction and does not imply image inputs, general conversation, automatic web access or a native tool-execution workflow.
POST /v1/messagestextjson, sse| Field | Type | Requirement | Values & limits | Default |
|---|---|---|---|---|
Fieldmodel | Typestring | RequirementRequired | Values & limits inference-net/schematron-v2-small | Default— |
Fieldmessages | Typemessage[] | RequirementRequired | Values & limits | Default— |
Fieldmessages[].role | Typestring | RequirementRequired | Values & limits user, assistant | Default— |
Fieldmessages[].content | Typestring | RequirementRequired | Values & limits | Default— |
Fieldmax_tokens | Typeinteger | RequirementRequired | Values & limits | Default— |
Fieldstream | Typeboolean | RequirementOptional | Values & limits | Defaultfalse |
Text · UTF-8 text
messages[].content string
| Parameter | Contract |
|---|---|
Parametercontent_type | Contractapplication/json |
Parameterrequired | Contractmodel, messages, max_tokens |
Parameteroptional_controls | Contractstream |
Parametermaterial_types | Contracttext |
Parametertext_file_material | ContractRead the actual UTF-8 document and put its text in the indicated input or message content string. |
Lifecycle: synchronous_or_streamed
Tariff references do not add request options. Supported parameters are listed for the selected method.
Match each charge to the conditions shown. Use one rate for each set of alternative configurations.
| Configuration | Rate schedule | Context tokens, more than | Context tokens, up to and including | Charge |
|---|---|---|---|---|
| ConfigurationBase token rates | Rate scheduleBase rate | Context tokens, more than— | Context tokens, up to and includingNo upper bound | Charge Input · Input tokens $0.0001 / 1K tokens Output · Output tokens $0.00046 / 1K tokens Input · Cache read $0.0001 / 1K tokens Input · Cache write — / 1K tokens Input · Cache write, 1 hour — / 1K tokens |
| ConfigurationRequest-length tier 1 | Rate schedule— | Context tokens, more than0 | Context tokens, up to and includingNo upper bound | Charge Input · Input tokens $0.0001 / 1K tokens Output · Output tokens $0.00046 / 1K tokens Input · Cache read $0.0001 / 1K tokens Input · Cache write — / 1K tokens Input · Cache write, 1 hour — / 1K tokens |
Ailoot reserves an estimated amount before a request. After the result, it settles the final charge from measured usage. Streaming settlement uses the final usage record. How reservation and settlement work →
{\n "model": "inference-net/schematron-v2-small",\n "max_tokens": 128,\n "messages": [\n {\n "role": "user",\n "content": "Summarize the incident report."\n }\n ],\n "stream": false\n}set -eu\n: "${AILOOT_API_KEY:?Set your Ailoot API key}"\n: "${AILOOT_TEXT_FILE:?Set your actual UTF-8 document}"\nexport AILOOT_TEXT_FILE\npython3 - <<'PY_REQUEST'\nimport json, os\nfrom pathlib import Path\n\nsource_file = Path(os.environ['AILOOT_TEXT_FILE'])\nif not source_file.is_file():\n raise SystemExit('Set AILOOT_TEXT_FILE to your actual UTF-8 document')\ntext = source_file.read_text(encoding='utf-8')\nif not text.strip():\n raise SystemExit('Choose a document containing text')\npayload = {'model': 'inference-net/schematron-v2-small', 'max_tokens': 128, 'messages': [{'role': 'user', 'content': 'Summarize the incident report.'}]}\npayload['messages'][0]['content'] = 'Summarize this material and quote supporting source passages.\\n\\n' + text\nPath('request.json').write_text(json.dumps(payload, ensure_ascii=False), encoding='utf-8')\nPY_REQUEST\ncurl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/messages \\\n -H "x-api-key: $AILOOT_API_KEY" -H 'anthropic-version: 2023-06-01' -H 'Content-Type: application/json' \\\n --data-binary @request.json -D response-headers.txt -o result.json\npython3 - <<'PY_RESULT'\nimport json\nfrom pathlib import Path\n\nresult = json.loads(Path('result.json').read_text(encoding='utf-8'))\nprint(json.dumps(result, ensure_ascii=False, indent=2))\nPY_RESULT\nimport json, os\nfrom pathlib import Path\n\nsource_file = Path(os.environ['AILOOT_TEXT_FILE'])\nif not source_file.is_file():\n raise SystemExit('Set AILOOT_TEXT_FILE to your actual UTF-8 document')\ntext = source_file.read_text(encoding='utf-8')\nif not text.strip():\n raise SystemExit('Choose a document containing text')\npayload = {'model': 'inference-net/schematron-v2-small', 'max_tokens': 128, 'messages': [{'role': 'user', 'content': 'Summarize the incident report.'}]}\npayload['messages'][0]['content'] = 'Summarize this material and quote supporting source passages.\\n\\n' + text\nfrom urllib.request import Request, urlopen\nfrom urllib.error import HTTPError\n\napi_key = os.environ['AILOOT_API_KEY']\nif not api_key.strip():\n raise SystemExit('Set AILOOT_API_KEY before making a request')\nheaders = {'x-api-key': 'PLACEHOLDER_KEY', 'anthropic-version': '2023-06-01', 'Content-Type': 'application/json'}\nheaders['x-api-key'] = api_key\nrequest = Request('https://api.ailoot.ai/v1/messages', data=json.dumps(payload, ensure_ascii=False).encode('utf-8'), headers=headers, method='POST')\ntry:\n with urlopen(request, timeout=120) as response:\n raw = response.read()\n Path('response-headers.txt').write_text(str(response.headers), encoding='utf-8')\nexcept HTTPError as error:\n Path('result.json').write_bytes(error.read())\n Path('response-headers.txt').write_text(str(error.headers), encoding='utf-8')\n raise\nPath('result.json').write_bytes(raw)\nimport json\nfrom pathlib import Path\n\nresult = json.loads(Path('result.json').read_text(encoding='utf-8'))\nprint(json.dumps(result, ensure_ascii=False, indent=2))\nJSON or SSE
Keep every complete returned response, file and content part.
Keep all content blocks, thinking signatures and actual tool-use IDs. Assemble all SSE block deltas; a first text block is not the complete output.
Keep request/response IDs and headers. No generic text job retrieval URL is supplied.
| Field | Type |
|---|---|
Fieldid | Typestring |
Fieldmodel | Typestring |
Fieldcontent[] | Typetext|thinking|tool_use|other content block |
Fieldstop_reason | Typestring|null |
Fieldusage | Typeobject |
| Response | Condition | Next step |
|---|---|---|
Response400 · invalid_request_error | ConditionInvalid required fields, material representation or parameter value | Next stepCorrect the indicated fields before a new creation request. |
Ailoot Ultra inference-net/schematron-v2-small
Use the method paths shown above.
Technical example in English
Extract product variants from HTML\n\nHTML source: <article><h1>Travel Flask</h1><section><h2>Small</h2><p>Capacity: 350 ml</p></section><section><h2>Large</h2><p>Capacity: 600 ml</p></section></article>. Extraction specification for the existing schema-guided workflow: product_name is the article title; variants is a list of objects containing name, capacity_value as an integer and capacity_unit as text. Return only the extracted record; preserve section-to-value associations.A target JSON record with product_name and two variants, each containing name, integer capacity_value and capacity_unit.Validate the returned record against the configured extraction schema and both source sections; do not swap capacities.Capacity: 350 ml
Capacity: 600 ml