Your first call in 30 seconds

Sign in at quicksilverpro.io/dashboard, then copy the key from the "Connect your agent" section.

Set it as the QSP_KEY environment variable so the snippets below work as-is:

export QSP_KEY="sk-..."

Python

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.quicksilverpro.io/v1",
    api_key=os.environ["QSP_KEY"],
)

resp = client.chat.completions.create(
    model="deepseek-v4.1-flash",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(resp.choices[0].message.content)

Node.js / TypeScript

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.quicksilverpro.io/v1",
  apiKey: process.env.QSP_KEY,
});

const resp = await client.chat.completions.create({
  model: "deepseek-v4.1-flash",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(resp.choices[0].message.content);

Turning reasoning off: the first call returns a visible answer with the model’s defaults. For direct chat without a reasoning trace, put the non-standard reasoning field in the Python SDK’s extra_body option.

resp = client.chat.completions.create(
    model="deepseek-v4.1-flash",
    messages=[{"role": "user", "content": "Hello!"}],
    extra_body={"reasoning": {"enabled": False}},
)
print(resp.choices[0].message.content)

For TypeScript, use the documented body request option as the second argument to create. This option replaces the payload, so spread the standard params into it before adding reasoning. See the OpenAI Node SDK.

const params = {
  model: "deepseek-v4.1-flash",
  messages: [{ role: "user" as const, content: "Hello!" }],
};
const resp = await client.chat.completions.create(params, {
  body: { ...params, reasoning: { enabled: false } },
});
console.log(resp.choices[0].message.content);

Swift

import Foundation
import OpenAI

let openAI = OpenAI(
  configuration: .init(
    token: ProcessInfo.processInfo.environment["QSP_KEY"]!,
    host: "api.quicksilverpro.io",
    basePath: "/v1"
  )
)

let query = ChatQuery(
  messages: [.user(.init(content: .string("Hello!")))],
  model: "deepseek-v4.1-flash"
)
let resp = try await openAI.chats(query: query)
print(resp.choices.first?.message.content?.string ?? "")

curl

curl https://api.quicksilverpro.io/v1/chat/completions \
  -H "Authorization: Bearer $QSP_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-v4.1-flash",
    "messages": [{"role": "user", "content": "Hello!"}],
    "reasoning": {"enabled": false}
  }'

Standard OpenAI chat-completions JSON. choices[0].message.content is the model's reply. usage reports prompt and completion tokens plus a synthetic cost field computed from the public per-million rate.

{
  "id": "chatcmpl-...",
  "object": "chat.completion",
  "created": 1715800000,
  "model": "deepseek-v4.1-flash",
  "choices": [{
    "index": 0,
    "message": {"role": "assistant", "content": "Hello! How can I help?"},
    "finish_reason": "stop"
  }],
  "usage": {
    "prompt_tokens": 9,
    "completion_tokens": 8,
    "total_tokens": 17,
    "cost": 0.00000275
  }
}

• Pick the right model for your workload — Models.
• Stream tokens as they generate — Streaming.
• Get typed JSON back — Structured output.

1. Get a key

2. Export your key

export QSP_KEY="YOUR_API_KEY"

3. Generate speech

curl https://api.quicksilverpro.io/v1/audio/speech \
  -H "Authorization: Bearer $QSP_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"chatterbox-turbo","input":"Hello from QuickSilver Pro.","voice":"alloy"}' \
  --output speech.mp3

Transcribe speech.mp3 (optional)

curl https://api.quicksilverpro.io/v1/audio/transcriptions \
  -H "Authorization: Bearer $QSP_KEY" \
  -F "model=qwen3-asr" \
  -F "[email protected]" \
  -F "response_format=json"

Open speech.mp3 to hear the audio.

Models, limits and device notes

For Chinese and English transcription, choose qwen3-asr: 0.3–0.7 s on 3–8 s clips, measured 2026-10-12. Choose whisper-large-v3-turbo for Whisper parity; whisper-1 is its compatibility alias.

For English speech, choose chatterbox-turbo: $1.50 per 1M characters, about 1 s for a sentence, one tenth of the OpenAI tts-1 list price of $15.

For Chinese or mixed Chinese/English speech, choose qwen3-tts: $25 per 1M characters. This is above the OpenAI tts-1 list price of $15; qwen3-tts is the model that reads Chinese correctly.

Transcription supports file, model, language, prompt, temperature and timestamp_granularities[] (word, segment). Speech supports model, input, optional voice, response_format and speed (0.25–4).

voice is optional. Chatterbox Turbo passes any voice string through. Qwen3 TTS ignores voice.

Qwen3 TTS currently has one voice. OpenAI voice names are accepted and ignored.

Compatibility aliases: whisper-1 → whisper-large-v3-turbo; tts-1 → qwen3-tts. tts-1 is billed as qwen3-tts ($25 per 1M characters). chatterbox-turbo is $1.50 per 1M characters, English only; select it explicitly. Billing and reporting use canonical IDs.

Upload limit: 25 MB for the multipart request; four parts maximum, one non-empty audio file, and 8 KB of headers per part. The body must arrive within 120 seconds and average at least 16 KB/s over every 10-second window after the first 10 seconds. Each key can have two simultaneous uploads; shared spool limits return 429 with Retry-After.

Input limit: 4,000 Unicode code points. Empty input is rejected. Each code point counts once, including CJK characters and emoji; combining marks and emoji sequences can count as multiple characters.

Formats: json (default), text, verbose_json, srt, vtt. Duration billing is identical for every response format.

Formats: mp3 (default), wav, opus, flac, pcm. aac is unsupported. Audio streams as it arrives.

Chatterbox Turbo is English only; Chinese input produces unintelligible audio.

A temporary hold is placed for each call and settled to the actual audio duration or character count.

curl https://api.quicksilverpro.io/v1/audio/speech \
  -H "Authorization: Bearer $QSP_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"qwen3-tts","input":"Hello from QuickSilver Pro.","voice":"alloy"}' \
  --output speech.mp3

Devices and microcontrollers

The API host uses a Let’s Encrypt TLS chain (ISRG Root X1 / X2). Firmware that pins another provider’s root must switch to the ISRG root or use its platform certificate bundle. Responses are 24 kHz mono MP3 by default. TTS streams: decode while downloading. Input is limited to 4,000 characters; WAV uploads get exact-duration holds.