This quick start shows how to send a first text chat-completions request to Ling 3.0 Flash Sante through Novita’s OpenAI-compatible API. Use https://api.novita.ai/openai as the base URL, inclusionai/ling-3.0-flash-sante as the model ID, and POST https://api.novita.ai/openai/v1/chat/completions as the request path. The current Novita listing describes a 124B-parameter Mixture-of-Experts model with approximately 5.1B active parameters per token, a 262,144-token context window, a 32,768-token maximum output, text input and output, reasoning, and function calling. For model positioning and pricing context, see Ling 3.0 Flash Sante on Novita AI: Capabilities and Pricing.
When to Use This Quick Start
Use this page when the practical question is how to authenticate, confirm the model route, send a small request, and parse the response. It is designed for a first integration test, not for choosing a clinical workflow or validating a model for a high-consequence use case.
Ling 3.0 Flash Sante is a text model. The hosted listing highlights medical knowledge reasoning, clinical safety, evidence-based retrieval, and long-horizon medical tasks, while also listing general reasoning, coding, and agentic capabilities. Those labels describe the model’s intended capability areas; they do not replace evaluation on your data, source checking, privacy controls, or qualified review.
Step 1: Get Your Novita API Key
Create a Novita API key, then keep it outside source control. For a local smoke test, export it as an environment variable:
export NOVITA_API_KEY="your_api_key"Do not put the key in a browser bundle, a public repository, or a client-side application. For a deployed service, load it from the service’s secret manager and rotate it according to your team’s credential policy.
Step 2: Confirm the Model ID and Endpoint
Before writing application code, check the live Ling 3.0 Flash Sante model page. The values below were checked on September 4, 2026.
| Field | Value |
|---|---|
| Model ID | inclusionai/ling-3.0-flash-sante |
| Base URL | https://api.novita.ai/openai |
| Chat completions endpoint | POST https://api.novita.ai/openai/v1/chat/completions |
| Context window | 262,144 tokens (displayed as 256K) |
| Maximum output | 32,768 tokens (displayed as 32K) |
| Input and output | Text |
| Listed features | Function calling, reasoning |
| Catalog request rate | 30 requests per minute |
| Listed input price | $0 per 1M tokens |
| Listed output price | $0 per 1M tokens |
Pricing, limits, and availability are live catalog values. Recheck them before budgeting or moving an integration into production. The catalog request-rate value is not a promise that every account or workload will receive the same throughput.
Step 3: Send Your First Request
Start with a short, non-sensitive prompt. A small request isolates authentication and routing errors before you add long context, tools, or application-specific data.
curl "https://api.novita.ai/openai/v1/chat/completions" \
-H "Content-Type: application/json" \
-H "Authorization: Bearer ${NOVITA_API_KEY}" \
-d '{
"model": "inclusionai/ling-3.0-flash-sante",
"messages": [
{
"role": "system",
"content": "You are a concise technical assistant. Do not provide diagnosis or treatment advice."
},
{
"role": "user",
"content": "Return a three-item checklist for testing a text classification API."
}
],
"max_tokens": 256,
"temperature": 0.2
}'The request uses the standard messages array and the model’s exact ID. The max_tokens value is deliberately small for a smoke test. Increase it only after the request, response parsing, timeout handling, and error handling work reliably.
Step 4: Read the Response
A successful chat completion returns an assistant message in the first choice. In a client or service, check the status code before parsing JSON, then handle the response defensively:
{
"choices": [
{
"message": {
"role": "assistant",
"content": "1. Prepare representative labeled inputs.\n2. Measure classification accuracy and refusal behavior.\n3. Inspect errors before increasing traffic."
}
}
]
}For the first test, confirm that:
- the request returns a successful HTTP response;
choices[0].message.contentcontains the assistant text;- the returned
modelis the expected model when the field is present; - your application handles missing content, non-200 responses, and timeouts;
- logs contain request metadata but never the API key or unnecessary sensitive input.
Do not treat a successful HTTP response as evidence that a medical or regulated workflow is ready. It only confirms that this request path, credential, model ID, and basic response parser work together.
Step 5: Check Pricing, Limits, and Common Errors
Before using real traffic, re-check the live model page for pricing, context, maximum output, supported features, and request-rate information. Then test the limits that matter to your application: long prompts, output truncation, retries, concurrent requests, and tool-call parsing.
The most common first-call failures are straightforward:
- 401 or authentication error:
NOVITA_API_KEYis unset, expired, malformed, or not being sent as a bearer token. - Model not found: the request uses a display name or a typo instead of
inclusionai/ling-3.0-flash-sante. - 404 endpoint error: the client has duplicated or omitted the
/v1/chat/completionspath. Use the base URL only in SDK configuration, or use the full URL in cURL. - 400 request error: inspect JSON syntax and supported fields. Begin with
modelandmessages, then add optional parameters one at a time. - 429 rate-limit response: apply bounded exponential backoff, reduce concurrency, and compare your traffic with the current account and catalog limits.
- Truncated answer: increase
max_tokenswhen the application needs more output, while staying within the model’s current maximum and your total context budget.
Python Example
The OpenAI Python SDK can use Novita’s compatible base URL. Install the SDK in your own environment, keep NOVITA_API_KEY set, and run this example from a server-side process:
import os
from openai import OpenAI
client = OpenAI(
base_url="https://api.novita.ai/openai",
api_key=os.environ["NOVITA_API_KEY"],
)
response = client.chat.completions.create(
model="inclusionai/ling-3.0-flash-sante",
messages=[
{
"role": "system",
"content": "You are a concise technical assistant. Do not provide diagnosis or treatment advice.",
},
{
"role": "user",
"content": "Explain how to test a text API response parser in three steps.",
},
],
max_tokens=256,
temperature=0.2,
)
print(response.choices[0].message.content)This example uses only the common chat-completions fields. Once it works, add application-specific system instructions, structured output handling, or tools and test each change independently.
cURL Example
For a shell-based integration check, keep the request in a script and fail loudly on HTTP errors:
curl --fail-with-body "https://api.novita.ai/openai/v1/chat/completions" \
-H "Content-Type: application/json" \
-H "Authorization: Bearer ${NOVITA_API_KEY}" \
-d '{
"model": "inclusionai/ling-3.0-flash-sante",
"messages": [
{
"role": "user",
"content": "List three checks for a reliable JSON response parser."
}
],
"max_tokens": 256,
"temperature": 0.2
}'--fail-with-body makes cURL return a failure status for HTTP errors while retaining the response body for debugging. Do not paste that body into public logs if it contains prompts or other sensitive data.
Key Parameters
model: Use the exact hosted model ID,inclusionai/ling-3.0-flash-sante.messages: Provide the conversation history as role/content objects. Keep system instructions specific and make the expected output format explicit.max_tokens: Set an output ceiling appropriate for the task. The current catalog maximum is 32,768 tokens, but smaller values make early tests easier to inspect.temperature: A lower value can make repeatable extraction or classification tests easier to compare. Measure the effect on your own prompts rather than assuming one setting is universally best.tools: The listing includes function calling. If you add tools, define narrow schemas, validate arguments in your application, and keep execution outside the model.- Reasoning controls: The listing includes reasoning, but do not assume every optional reasoning field is portable across SDKs. Confirm the current API reference and model behavior before adding provider-specific fields.
For health-related text, separate generation from verification. Supply only the data your application is authorized to process, retain source references where possible, and route consequential outputs to qualified reviewers. This article does not provide diagnosis or treatment guidance.
Troubleshooting
When a request fails, reduce it to the smallest reproducible call: the exact model ID, one user message, a low max_tokens value, and the bearer header. This makes it easier to distinguish an account issue from a client-wrapper issue.
If the minimal cURL call succeeds but the SDK call fails, print the SDK’s resolved request URL in a safe local debug environment and compare it with https://api.novita.ai/openai/v1/chat/completions. Do not print authorization headers. If both calls succeed but application output is unreliable, keep the integration and model-access test separate from task-quality evaluation.
For long-context work, start below the 262,144-token context ceiling. Count the input messages, tool definitions, and expected output together, then test truncation and timeout behavior with representative requests. A large advertised context does not guarantee that every prompt will be useful or economical.
FAQ
What model ID should I send?
Send inclusionai/ling-3.0-flash-sante. The display name, Ling 3.0 Flash Sante, is not a substitute for the model ID in the request body.
Which endpoint does the quick start use?
It uses the OpenAI-compatible chat-completions route at https://api.novita.ai/openai/v1/chat/completions. In SDK configuration, use https://api.novita.ai/openai as the base URL and let the SDK append its versioned path.
Is the hosted model multimodal?
The current Novita listing identifies text as both the input and output modality. Do not send image or audio content unless the live model listing explicitly adds support.
Can I use this for clinical decisions?
This quick start is an API integration guide, not clinical guidance. A successful API response does not establish clinical safety, factual accuracy, regulatory suitability, or authorization to process protected information. Evaluate any proposed use with qualified domain experts and the controls required for your environment.
