Unang request sa Rust gamit ang async-openai: base URL, key, usage

Para tumawag sa CheapTokens mula sa Rust gamit ang async-openai, bumuo ng OpenAIConfig gamit ang base URL na https://api.cheaptokens.dev/v1 at ang iyong key, pagkatapos ipadala ang request gamit ang create_byot at isang JSON body. Ang text ng reply at ang mga token count ay lumalabas mula sa JSON na bumabalik. Mga 25 linya lang ng code iyon, at gumagana ang parehong programa para sa kahit anong modelo sa pahina ng mga modelo ng CheapTokens kapag binago mo ang isang string.

Ang docs.rs page ng crate (sinuri noong 8 Nobyembre 2026) ay naglilista ng bersyon 0.43.0 sa ilalim ng MIT license, at iyon ang bersyong sinusundan ng gabay na ito.

Bakit create_byot sa halip na mga typed request#

Karaniwang nagbibigay ang async-openai ng typed request builder: pinupuno mo ang isang struct, ibinabalik nito ang isang struct. Komportable iyon hanggang sa magbalik ang isang gateway ng field na hindi alam ng mga struct. Ang byot feature ("bring your own types") ay nagdadagdag ng mga *_byot method na tumatanggap ng kahit anong JSON body at nagbabalik ng kahit anong type na maaari mong i-deserialize, kasama na ang plain serde_json::Value.

Para sa unang request, iyon talaga ang kailangan mo. Isusulat mo ang parehong JSON na ilalagay mo sa isang curl call, at babasahin mo ang usage diretso mula sa response, na walang type na hahanapin.

I-set up ang proyekto#

cargo add async-openai --features byot,chat-completion
cargo add tokio --features macros,rt-multi-thread
cargo add serde_json

export CHEAPTOKENS_API_KEY="paste-your-key-here"

cargo run

Ang programa#

use async_openai::{config::OpenAIConfig, Client};
use serde_json::{json, Value};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let key = std::env::var("CHEAPTOKENS_API_KEY")?;

    let config = OpenAIConfig::new()
        .with_api_key(key)
        .with_api_base("https://api.cheaptokens.dev/v1");
    let client = Client::with_config(config);

    let response: Value = client
        .chat()
        .create_byot(json!({
            "model": "deepseek-ai/DeepSeek-V4-Flash-0731",
            "messages": [
                {"role": "user", "content": "Explain what a token is in one sentence."}
            ],
            "max_tokens": 100
        }))
        .await?;

    let choice = &response["choices"][0];
    println!("{}", choice["message"]["content"].as_str().unwrap_or("(no text)"));
    println!("finish_reason: {}", choice["finish_reason"]);
    println!("input tokens:  {}", response["usage"]["prompt_tokens"]);
    println!("output tokens: {}", response["usage"]["completion_tokens"]);
    Ok(())
}

Tatlong linya ang nagdadala ng buong ideya. Ang with_api_base ang pinapasok ng CheapTokens: nagtatapos ang base URL sa /v1, at ang async-openai mismo ang nagdadagdag ng endpoint path. Kinukuha ng with_api_key ang value na binasa namin mula sa environment. At ang model ay ang buong id na deepseek-ai/DeepSeek-V4-Flash-0731 — hindi tinatanggap ng API ang mga maiikling pangalan mula sa mga price table.

Ang pag-index ng Value na kulang ang key ay nagbibigay ng null sa halip na panic, kaya ang typo sa pangalan ng field ay lumalabas bilang null sa output sa halip na crash. Kapaki-pakinabang iyon kapag nag-e-explore ka ng response.

Ano ang bumabalik#

Nagsasalita ang gateway ng OpenAI Chat Completions format, kaya ang response ay may karaniwang hugis (pinaikli dito, ang ... ay nagmamarka ng mga field na nilalaktawan namin):

{
  "choices": [
    { "message": { "role": "assistant", "content": "..." }, "finish_reason": "stop" }
  ],
  "usage": { "prompt_tokens": 0, "completion_tokens": 0 }
}

Ang mga numero sa usage ay totoong count para sa iyong request, kaya pinapalitan nila ang mga zero kapag pinatakbo mo ito. Ang prompt_tokens ay ang ipinadala mo, ang completion_tokens ay ang isinulat ng modelo. Magkaiba ang presyo ng singil sa kanila, at iyon ang dahilan ng pag-print sa kanila. Kung bago sa iyo ang pagkakaiba, ipinapaliwanag ng input vs output tokens iyon sa limang minuto.

Magkano ang isang request#

Sabihin nating pinapatakbo mo ang call na ito sa isang loop, maliit na tanong ang papasok at maikling sagot ang lalabas: 300 input tokens at 200 output tokens bawat isa. Sa DeepSeek-V4-Flash, iyon ay $0.000025 bawat request, mula sa live na presyo na $0.015 kada 1M input tokens at $0.10 kada 1M output tokens. Kung pagsasamahin, input at output, mas mura iyon kaysa OpenRouter, at pinapanatili ng modelo ang 380K context at sumasagot ng hanggang 32,768 tokens.

Ipinapakita ng talahanayan sa ibaba ang parehong request sa bawat modelo, pinarami ng 1,000.

Nasa pricing page ang mga presyo.

Pagpapalit ng modelo#

Hindi nagbabago ang code kapag nagbago ang modelo; ang string lang sa "model" ang nagbabago. Halimbawa, ang zai-org/GLM-5.3-Flash ay may 390K context at sumasagot ng hanggang 8,192 tokens. Para hindi na mag-edit ng code, basahin ang id mula sa pangalawang variable gamit ang std::env::var("CHEAPTOKENS_MODEL"). Kung hindi ka sigurado kung aling mga id ang nakikita ng iyong key, ilista ang mga modelo gamit ang GET /v1/models.

Kung hindi ito gumana#

• environment variable not found sa pinakasimula: hindi naka-export ang key sa terminal na ito. I-export itong muli sa parehong window kung saan mo pinapatakbo ang cargo run.
• Isang 401 error mula sa API: mali ang key o may sumamang space o quote sa paligid nito.
• Isang 404 error: tiyakin na nagtatapos ang base URL sa /v1 at ang model id ay ang buo, kasama ang deepseek-ai/ prefix. Dinadaanan ng API 401 o 404: key, base URL, model id iyon.
• Hindi mahanap ng compiler ang create_byot: hindi naka-enable ang byot feature. Patakbuhin muli ang cargo add linya mula sa setup.

Para sa problema sa koneksyon na wala sa mga iyon, tingnan ang mga karaniwang error sa koneksyon.

May parehong unang request para sa ibang mga wika: Go at Ruby. Para sa higit pa tungkol sa API mismo, buksan ang mga doc ng CheapTokens.