Call and choose models

This guide covers the complete path from an API key to a usable model response. It uses the OpenAI-compatible route first, then shows the equivalent Anthropic SDK setup.

Before you begin

Create a Planck API key from API Keys, then load it as a server-side environment variable:

export PLANCK_API_KEY="sk-planck-..."

Keep this key in a server-side secret store. Never place it in browser code, a NEXT_PUBLIC_* variable, a mobile application bundle, or a public Git repository.

1. List the models available to you

GET /v1/models is authenticated and returns models accessible with your credentials, Planck credit availability, and organization policy.

curl -s https://api.inquantum.ai/v1/models \
  -H "Authorization: Bearer $PLANCK_API_KEY" | \
  jq -r '.data[] | [.id, (.operations | join(",")), .hasPtb, .hasByok] | @tsv'

Each model contains provider-specific endpoints. Capabilities can differ between endpoints offering the same model, so check one endpoint satisfies all of your requirements together.

2. Filter by your use case

Models with chat and image input

curl -s https://api.inquantum.ai/v1/models \
  -H "Authorization: Bearer $PLANCK_API_KEY" | \
  jq -r '.data[]
    | select((.operations | index("chat_completions")) != null)
    | select((.inputModalities | index("image")) != null)
    | .id'

Models with tools and streaming on one endpoint

curl -s https://api.inquantum.ai/v1/models \
  -H "Authorization: Bearer $PLANCK_API_KEY" | \
  jq -r '.data[]
    | select(any(.endpoints[];
        ((.supportedOperations | index("chat_completions")) != null) and
        ((.supportedParameters | index("tools")) != null) and
        ((.supportedParameters | index("stream")) != null)))
    | .id'

Reasoning models available with Planck credits

curl -s https://api.inquantum.ai/v1/models \
  -H "Authorization: Bearer $PLANCK_API_KEY" | \
  jq -r '.data[]
    | select(.supportsReasoningEffort and .hasPtb)
    | .id'

Models available through a specific provider

curl -s https://api.inquantum.ai/v1/models \
  -H "Authorization: Bearer $PLANCK_API_KEY" | \
  jq -r '.data[]
    | select(any(.endpoints[]; .provider == "groq" and (.hasPtb or .hasByok)))
    | .id'

See Model capabilities for every discovery field and the provider-specific parameterContract.

3. Call the selected model

The request format does not determine the provider. You can use an OpenAI-compatible client to call supported Claude, Gemini, Qwen, and other models through Planck.

cURL
Python
TypeScript
Anthropic SDK

curl https://api.inquantum.ai/v1/chat/completions \
  -H "Authorization: Bearer $PLANCK_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-4o-mini",
    "messages": [
      {"role": "system", "content": "Answer clearly and concisely."},
      {"role": "user", "content": "Explain vector search in one sentence."}
    ]
  }'

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["PLANCK_API_KEY"],
    base_url="https://api.inquantum.ai/v1",
)

response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {"role": "system", "content": "Answer clearly and concisely."},
        {"role": "user", "content": "Explain vector search in one sentence."},
    ],
)

print(response.choices[0].message.content)

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.PLANCK_API_KEY,
  baseURL: "https://api.inquantum.ai/v1",
});

const response = await client.chat.completions.create({
  model: "gpt-4o-mini",
  messages: [
    { role: "system", content: "Answer clearly and concisely." },
    { role: "user", content: "Explain vector search in one sentence." },
  ],
});

console.log(response.choices[0].message.content);

import os
from anthropic import Anthropic

client = Anthropic(
    api_key=os.environ["PLANCK_API_KEY"],
    base_url="https://api.inquantum.ai/anthropic",
)

message = client.messages.create(
    model="gpt-4o-mini",
    max_tokens=256,
    system="Answer clearly and concisely.",
    messages=[
        {"role": "user", "content": "Explain vector search in one sentence."}
    ],
)

for block in message.content:
    if block.type == "text":
        print(block.text)

The Anthropic SDK appends /v1/messages to the base URL. Its api_key option must contain your actual Planck API key. Anthropic-compatible Messages requests require max_tokens.

To lock the request to one endpoint, prefix the model with the provider—for example, groq/qwen/qwen3.8-27b. Leave the prefix off to let Planck select an accessible endpoint.

4. Read the response

An OpenAI-compatible non-streaming response has this shape:

{
  "id": "chatcmpl_123",
  "object": "chat.completion",
  "model": "gpt-4o-mini",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "Vector search finds records whose embeddings are closest in meaning to a query embedding."
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 24,
    "completion_tokens": 17,
    "total_tokens": 41,
    "cost_usd": 0.00002
  }
}

What you need	OpenAI-compatible location
Assistant text	`choices[0].message.content`
Why generation stopped	`choices[0].finish_reason`
Tool requests	`choices[0].message.tool_calls`
Reasoning, when requested and supported	`choices[0].message.reasoning` or reasoning detail fields
Token counts	`usage.prompt_tokens`, `usage.completion_tokens`, and `usage.total_tokens`
Calculated request cost	`usage.cost_usd`, when present

Extract only the assistant text with jq:

curl -s https://api.inquantum.ai/v1/chat/completions \
  -H "Authorization: Bearer $PLANCK_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-4o-mini",
    "messages": [{"role": "user", "content": "Say hello."}]
  }' | jq -r '.choices[0].message.content'

Do not assume choices[0] contains text for every operation. Tool-calling responses can contain tool_calls, Anthropic-compatible responses contain typed content blocks, and streaming responses arrive as a sequence of deltas.

5. Choose the next pattern

Use case	Start here
Render text as it arrives	Streaming chat completions
Build a complete browser chat	Build a streaming chat UI
Return machine-validated JSON	Structured JSON
Let the model invoke your code	Tool calling
Send image input	Model capabilities
Configure thinking effort	Reasoning and thinking
Use the Responses API	Responses API
Generate embeddings	Embeddings
Rerank search results	Reranking
Configure providers or BYOK	Provider routing

Common mistakes

Sending a Planck key to a provider URL instead of https://api.inquantum.ai.
Putting the API key in client-side code.
Assuming a model-level capability means every provider endpoint supports it.
Treating the model’s maximum output as a default. OpenAI-compatible output limits are optional; Anthropic Messages requires max_tokens.
Parsing every response as plain text without checking finish_reason, tool calls, reasoning fields, or stream events.

For authentication, validation, rate-limit, and provider failures, follow the error-handling guide.

Start Here

API Basics

Applications

Prompting

Call and choose models

Before you begin

1. List the models available to you

2. Filter by your use case

Models with chat and image input

Models with tools and streaming on one endpoint

Reasoning models available with Planck credits

Models available through a specific provider

3. Call the selected model

4. Read the response

5. Choose the next pattern

Common mistakes

​Before you begin

​1. List the models available to you

​2. Filter by your use case

​Models with chat and image input

​Models with tools and streaming on one endpoint

​Reasoning models available with Planck credits

​Models available through a specific provider

​3. Call the selected model

​4. Read the response

​5. Choose the next pattern

​Common mistakes

Before you begin

1. List the models available to you

2. Filter by your use case

Models with chat and image input

Models with tools and streaming on one endpoint

Reasoning models available with Planck credits

Models available through a specific provider

3. Call the selected model

4. Read the response

5. Choose the next pattern

Common mistakes