OpenAPI 3.1

Customer API reference

This page describes the supported customer inference request and response. Download the machine-readable OpenAPI document for tooling.

Download OpenAPI JSON

Model API examples

Choose a published model identifier, API protocol, and language to view a request example. Keep customer API keys on a trusted server.

Model

Language

Protocol requirements

OpenAI-compatible requests use POST /chat/completions at the configured customer API base URL (default https://fusionpointai.com/api/v1). Authenticate with Authorization: Bearer using a customer key with inference access. The full default URL is https://fusionpointai.com/api/v1/chat/completions.

Supported capabilities

The current OpenAI-compatible chat endpoint handles synchronous text messages. Streaming and tool calls are not supported by this endpoint.

Install a client

Install the Python and Node.js clients as separate packages:

Python: pip install openai anthropic

Node.js: npm install openai @anthropic-ai/sdk

curl 'https://fusionpointai.com/api/v1/chat/completions' \
  -H "Authorization: Bearer $FUSIONPOINTAI_API_KEY" \
  -H "Content-Type: application/json" \
  --data '{
    "model": "Astra 6",
    "messages": [
        {
            "role": "user",
            "content": "Summarize this in one sentence."
        }
    ],
    "temperature": 0.7,
    "max_tokens": 300
}'

Request patterns

Set up API keys safely

Create a customer API key with inference access and provide it to a server process through its secret manager or environment.

Set FUSIONPOINTAI_API_KEY in the server environment; do not embed the key in browser code or commit it to source control.
Use HTTPS and restrict the key to the account and inference permissions required by the application.
Redact authorization and x-api-key headers from logs, traces, and support requests; revoke a key if it may have been exposed.

export FUSIONPOINTAI_API_KEY="YOUR_CUSTOMER_API_KEY"

Select an exact model identifier

The model field is a routing value, not a display label. Choose an identifier published in the live model catalogue.

Select an active or legacy model that is marked available for inference.
Copy its identifier exactly, including punctuation and version suffixes; never derive an ID from the model name.
If no identifier is published, wait for the catalogue to provide one rather than substituting a guessed value.

model_id = "Astra 6"
# Use this exact identifier with either protocol.

Send system and multi-turn messages

Keep conversation turns in their original order and use only the roles and content shapes supported by the selected protocol and model.

For OpenAI-compatible requests, send system, user, and assistant messages as ordered string-content entries.
For Claude Messages, send the supported system instruction and ordered user/assistant turns in the protocol-native fields.
Retain only the conversation context your application needs and observe the selected model’s context limits.

response = client.messages.create(
    model="Astra 6",
    max_tokens=512,
    system="Answer in clear, concise German.",
    messages=[
        {"role": "user", "content": "What is an API?"},
        {"role": "assistant", "content": "An API lets software exchange requests and responses."},
        {"role": "user", "content": "Give a practical example."},
    ],
)
for block in response.content:
    if block.type == "text":
        print(block.text)

Request JSON responses

When an application needs structured output, validate the response against its own schema before using it.

Use the structured-output controls supported by the chosen protocol and the selected upstream model.
Treat generated JSON as untrusted input: parse it, validate required fields and types, and handle invalid output.
Do not assume that a model or protocol combination supports a JSON mode unless the model documentation says so.

import json

# JSON is generated content, not trusted application input.
response = client.messages.create(
    model="Astra 6", max_tokens=256,
    messages=[{"role": "user", "content": 'Return only JSON with a string field named "summary". Explain an API in one sentence.'}],
)
text = "".join(block.text for block in response.content if block.type == "text")
try:
    result = json.loads(text)
    if not isinstance(result, dict) or not isinstance(result.get("summary"), str):
        raise ValueError("Unexpected response schema")
    print(result["summary"])
except (json.JSONDecodeError, ValueError) as error:
    print("Handle invalid model output:", error)

Receive real-time SSE output

Streaming behavior depends on the selected protocol and upstream model; an ordinary JSON response is not a stream.

OpenAI-compatible chat currently returns synchronous text and does not provide streaming.
For Claude Messages, use stream mode where the selected upstream model supports it; the proxy forwards native server-sent events.
Consume events incrementally, stop cleanly on completion or error, and do not treat partial output as a completed answer.

# client is the Anthropic client configured above.
with client.messages.stream(
    model="Astra 6", max_tokens=512,
    messages=[{"role": "user", "content": "Explain API authentication."}],
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)
    final_message = stream.get_final_message()
print("\nStop reason:", final_message.stop_reason)

Handle tools, content blocks, and errors

Keep protocol-native structures intact and make application behavior explicit for tool calls, multimodal content, and failures.

OpenAI-compatible chat currently supports neither tool calls nor non-text content blocks.
Claude preserves native content blocks and tool-use/result data when supported by the selected upstream model; validate tool names and arguments before execution.
Check the HTTP status and response body, distinguish authentication, permission, validation, and rate-limit failures, and retry transient errors with backoff.

import json
from datetime import datetime, timezone
from anthropic import APIError

messages = [{"role": "user", "content": "What time is it in UTC?"}]
tools = [{
    "name": "current_utc_time", "description": "Read the current UTC time.",
    "input_schema": {"type": "object", "properties": {}, "additionalProperties": False},
}]
try:
    reply = client.messages.create(model="Astra 6", max_tokens=256, messages=messages, tools=tools)
    results = []
    for block in reply.content:
        if block.type == "tool_use":
            if block.name != "current_utc_time" or block.input != {}:
                raise ValueError("Unapproved tool request")
            results.append({"type": "tool_result", "tool_use_id": block.id,
                            "content": json.dumps({"utc": datetime.now(timezone.utc).isoformat()})})
    if results:
        messages.append({"role": "assistant", "content": reply.content})
        messages.append({"role": "user", "content": results})
        reply = client.messages.create(model="Astra 6", max_tokens=256, messages=messages, tools=tools)
    print("".join(block.text for block in reply.content if block.type == "text"))
except APIError as error:
    # Log status only; never log keys or private prompts.
    print("API request failed:", getattr(error, "status_code", None))

Frequently asked questions

Can I use a model display name in a request?

Use only the exact identifier published for inference. A display name is not a routing value, and an unpublished identifier should never be guessed.

Which environment variable holds the customer key?

Use FUSIONPOINTAI_API_KEY for both protocols. Keep its value in a trusted server environment and out of client-side code and logs.

What URL should the OpenAI client use?

Use the configured customer API base URL, which defaults to https://fusionpointai.com/api/v1. The chat-completions endpoint adds /chat/completions.

Why is the Claude SDK base URL different from cURL?

The Anthropic SDK appends /v1/messages, so set its base URL to https://fusionpointai.com/api. A direct HTTP request uses the full /api/v1/messages URL.

Does OpenAI-compatible chat support streaming or tools?

No. The current endpoint supports synchronous text messages only; streaming and tool calls are not available there.

Are all Claude models guaranteed to support blocks, tools, or streaming?

No. These native features are preserved when supported by the selected upstream model. Check that model’s capabilities and handle unsupported requests.

Claude Messages · `POST /messages`

Claude Messages requests use POST /api/v1/messages. Send the customer key in x-api-key and set anthropic-version to 2023-06-01. The Anthropic SDK base URL is https://fusionpointai.com/api because the SDK appends /v1/messages; bearer authentication is also supported.

The Claude Messages proxy preserves native content blocks, tool data, and real server-sent event streaming when the selected upstream model supports them.

Field	Type	Required	Constraints
`model`	`string`	Yes	`{"minLength":1,"maxLength":160}`
`max_tokens`	`integer`	Yes	`{"minimum":1,"maximum":100000}`
`messages`	`array`	Yes	`{"minItems":1,"maxItems":100,"items":{"type":"object","required":["role","content"],"properties":{"role":{"type":"string","enum":["user","assistant"]},"content":{"oneOf":[{"type":"string"},{"type":"array","items":{"type":"object","required":["type"],"properties":{"type":{"type":"string","maxLength":80}},"additionalProperties":true}}]}}}}`
`system`	`string \| array`	No	`{"oneOf":[{"type":"string"},{"type":"array","items":{"type":"object","required":["type","text"],"properties":{"type":{"const":"text"},"text":{"type":"string"}},"additionalProperties":true}}]}`
`stream`	`boolean`	No	`{"default":false}`
`temperature`	`number`	No	`{"minimum":0,"maximum":1}`
`top_p`	`number`	No	`{"minimum":0,"maximum":1}`
`top_k`	`integer`	No	`{"minimum":0,"maximum":100000}`
`stop_sequences`	`array`	No	`{"items":{"type":"string"}}`
`tools`	`array`	No	`{"items":{"type":"object","additionalProperties":true}}`
`tool_choice`	`object`	No	`{"additionalProperties":true}`
`thinking`	`object`	No	`{"additionalProperties":true}`
`metadata`	`object`	No	`{"additionalProperties":true}`
`output_config`	`object`	No	`{"additionalProperties":true}`
`service_tier`	`string`	No	`[]`

{
    "id": "msg_example",
    "type": "message",
    "role": "assistant",
    "model": "Astra 6",
    "content": [
        {
            "type": "text",
            "text": "A concise answer to the supplied question."
        }
    ],
    "stop_reason": "end_turn",
    "stop_sequence": null,
    "usage": {
        "input_tokens": 12,
        "output_tokens": 10
    }
}

{"type":"error","error":{"type":"authentication_error","message":"Invalid or missing API key."}}

SDK quick starts

Use the production base URL with a compatible Python or Node.js client, or send the same JSON request with cURL.

API base URL: https://fusionpointai.com/api/v1

Send the customer API key in the Authorization: Bearer header. The key must have the ai:inference scope and account access for the service. Keep the key on a trusted server.

# Install the client for your application language.
# Python:
python -m pip install openai
# Node.js:
npm install openai

# Bash: enter the key without storing it in shell history.
read -rs -p 'FusionPointAI API key: ' FUSIONPOINTAI_API_KEY
export FUSIONPOINTAI_API_KEY
printf '\n'
# After finishing:
# unset FUSIONPOINTAI_API_KEY

curl 'https://fusionpointai.com/api/v1/chat/completions' \
  -H "Authorization: Bearer $FUSIONPOINTAI_API_KEY" \
  -H "Content-Type: application/json" \
  --data '{
    "model": "Jurassic-2",
    "messages": [
        {
            "role": "user",
            "content": "Summarize this in one sentence."
        }
    ],
    "temperature": 0.7,
    "max_tokens": 300
}'

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["FUSIONPOINTAI_API_KEY"],
    base_url="https://fusionpointai.com/api/v1",
)

response = client.chat.completions.create(
    model="Jurassic-2",
    messages=[{"role": "user", "content": "Summarize this in one sentence."}],
    temperature=0.7,
    max_tokens=300,
)
print(response.choices[0].message.content)

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.FUSIONPOINTAI_API_KEY,
  baseURL: "https://fusionpointai.com/api/v1",
});

const response = await client.chat.completions.create({
  model: "Jurassic-2",
  messages: [{ role: "user", content: "Summarize this in one sentence." }],
  temperature: 0.7,
  max_tokens: 300,
});
console.log(response.choices[0].message.content);

OpenAI · Request fields

Model values are the exact registered identifiers currently published for inference. If none are published, consult the provider catalogue before sending a request.

Field	Type	Required	Constraints
`model`	`string`	Yes	Maximum 160 characters; use an exact published identifier.
`messages`	`array`	Yes	1 to 100 messages, sent in order.
`messages[].role`	`string`	Yes	system, user, or assistant.
`messages[].content`	`string`	Yes	Maximum 100,000 characters per message.
`temperature`	`number`	No	0 through 2.
`max_tokens`	`integer`	No	1 through 100,000; the model may impose a lower limit.

Successful response

A successful JSON response contains id, object (chat.completion), created, model, and choices. A choice includes index, an assistant message, and finish_reason. Token usage may also be returned.

{
    "id": "chatcmpl_example",
    "object": "chat.completion",
    "created": 1700000000,
    "model": "Jurassic-2",
    "choices": [
        {
            "index": 0,
            "message": {
                "role": "assistant",
                "content": "A concise summary of the supplied text."
            },
            "finish_reason": "stop"
        }
    ],
    "usage": {
        "prompt_tokens": 12,
        "completion_tokens": 10,
        "total_tokens": 22
    }
}

Field	Type	Meaning
`id`	`string`	Unique completion identifier.
`object`	`string`	Response kind: chat.completion.
`created`	`integer`	Creation time as a Unix timestamp.
`model`	`string`	Model identifier used for the completion.
`choices`	`array`	Completion alternatives with an assistant message and finish reason.
`usage`	`object`	Token counts when returned.

Rate limits and errors

Live customer subscriptions do not meter request or token usage against a quota; sandbox keys use their published monthly allowance. Model context windows, output limits and temporary traffic controls still apply. Chat Completions is synchronous text; Claude Messages preserves supported native content blocks, tools and SSE. Check the separate operation schemas before sending requests.

The chat operation returns validation and provider failures in an error object. Authentication and scope middleware may instead return a top-level message field; status and envelope depend on which layer rejected the request.

HTTP status	Meaning
`200`	Completion created successfully.
`400`	Invalid request body or parameter.
`401`	Missing or invalid bearer API key.
`403`	Required key scope or account access is missing.
`429`	Application throttle or temporary upstream traffic control; retry with backoff.
`500`	The service could not return a usable completion.