DeepSeek GPT API guide

Published DeepSeek GPT models

Names, exact routing identifiers, versions, and inference status are listed from the enabled model registry when available. A blank identifier means the catalogue has not published a routing value; do not derive one from the model name.

Developer

DeepSeek

New customer access

Existing customers only

Existing customers only

Make your first request

Send HTTPS requests to the base URL below. Use POST /chat/completions for OpenAI-compatible text chat or POST /messages for Claude Messages. Select the protocol in the model workbench and use its exact URL and JSON format.

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

Create or manage a customer API key in your account’s API key settings. Send it as a bearer token and keep it on a trusted server; do not place it in browser code, source control, or a public log.

The key needs the ai:inference scope and access to the relevant customer subscription. The public API key is not an account password and must not be shared.

These examples use the registered JSON chat-completion endpoint and the OpenAI-compatible Python and Node.js clients. Store the key in the FUSIONPOINTAI_API_KEY environment variable. Replace the model value only with an exact identifier listed above.

# 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

No active registry model identifiers are currently published. Replace the placeholder in the example only after selecting an identifier from this catalogue.

curl 'https://fusionpointai.com/api/v1/chat/completions' \
  -H "Authorization: Bearer $FUSIONPOINTAI_API_KEY" \
  -H "Content-Type: application/json" \
  --data '{
    "model": "<MODEL_ID_FROM_CATALOGUE>",
    "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="<MODEL_ID_FROM_CATALOGUE>",
    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: "<MODEL_ID_FROM_CATALOGUE>",
  messages: [{ role: "user", content: "Summarize this in one sentence." }],
  temperature: 0.7,
  max_tokens: 300,
});
console.log(response.choices[0].message.content);

OpenAI · Request and response contract

The endpoint accepts JSON. Messages are sent in order; each message has a supported role and string content. Optional generation controls must remain within the validation limits below. The response is a JSON chat.completion object with choices and, when returned by the provider, token usage.

Response shape

A successful response contains id, object (chat.completion), created, model and choices. A choice contains its index, assistant message and finish_reason. Token counts may be returned in usage. Provider-specific limits can apply even when a request passes gateway validation.

{
    "id": "chatcmpl_example",
    "object": "chat.completion",
    "created": 1700000000,
    "model": "<MODEL_ID_FROM_CATALOGUE>",
    "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
    }
}

Access, limits, and operating safely

Live customer subscriptions do not meter request or token usage against a quota; sandbox keys are limited to their published monthly allowance. This subscription statement is separate from model and upstream technical limits.

• Model context windows, maximum output size, supported request features, and temporary upstream traffic controls vary. Check the provider and model information before sending production traffic.
• The endpoint has an application throttle of 60 requests per minute per applicable throttle identity. HTTP 429 can also indicate temporary upstream traffic controls; retry with backoff rather than a tight loop.
• Use HTTPS, keep keys server-side, grant only the inference scope required, and revoke a key promptly if it may have been exposed.
• Chat Completions supports synchronous text. Claude Messages separately supports native content blocks, tools and SSE where the selected model allows them. Other provider endpoints are not part of these contracts.

Provider access and account requirements

Authenticate with a customer API key that has the ai:inference scope and belongs to an account with access to this service. The catalogue indicates whether new customers are currently allowed. It does not grant access, create a subscription, or override account and key permissions.

Errors and troubleshooting

Validation failures and unusable provider results returned by the endpoint use a JSON error object with message, type, and code; validation failures may also include field details. Do not send API keys or private prompt content in support tickets.

Request validation and provider failures returned by the chat operation use an error object. Authentication, scope, and throttle middleware can instead return a top-level message field. Check the status and response body together.

Frequently asked questions