Call Trends API from Rust with reqwest

A Rust Trends API client is a Bearer-authenticated POST to https://api.trendsapi.ai/api, then a second serde_json::from_str of the body string. On 2026-09-10, Google Search for rust programming scored 14.0 for the Saturday-dated week of 2026-09-05, down 6.67% from 15.0 on 2026-08-29. Bare rust scored 76.0, up 18.75% from 64.0, and is not a language series. rust lang scored 50.0. The concatenated token rustlang scored 23.0, up 130.0% from 10.0. The compiler token rustc scored 34.0, up 61.9% from 21.0. The HTTP crate reqwest scored 22.0. YouTube for rust programming sat at 65.0. Google News for rust programming sat at 61.0 with a low-quality warning. Wikipedia title Rust (programming language) had 49,857 August views. Those strings are separate rows.

How does a Rust client call Trends API?

The HTTP shape is one POST. Mode, source, and keyword sit in the JSON body. Auth is Authorization: Bearer. reqwest with the blocking and json features is enough. The first decode yields statusCode and a body string. The second decode yields results.

POST https://api.trendsapi.ai/api
Authorization: Bearer <api_key>
Content-Type: application/json

{"mode":"get_growth","source":"google search","keyword":"rust programming","percent_growth":["7D","30D","3M","12M"]}

use serde_json::{json, Value};
use std::env;

fn trends_post(payload: Value) -> Result<Value, Box<dyn std::error::Error>> {
    let key = env::var("TRENDSAPI_API_KEY")?;
    let client = reqwest::blocking::Client::new();
    let resp = client
        .post("https://api.trendsapi.ai/api")
        .header("Authorization", format!("Bearer {}", key))
        .header("Content-Type", "application/json")
        .json(&payload)
        .send()?;
    if resp.status().as_u16() != 200 {
        return Err(format!("HTTP {}", resp.status().as_u16()).into());
    }
    let envelope: Value = resp.json()?;
    // body is a JSON string; parse it a second time
    let body = envelope["body"].as_str().ok_or("missing body")?;
    Ok(serde_json::from_str(body)?)
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let inner = trends_post(json!({
        "mode": "get_growth",
        "source": "google search",
        "keyword": "rust programming",
        "percent_growth": ["7D", "30D", "3M", "12M"]
    }))?;
    println!("{}", inner);
    Ok(())
}

The first mistake most clients make is treating envelope["body"] as an object after one parse. It is still a JSON string. Parse the envelope, then parse body a second time. Crate docs:

https://docs.rs/reqwest
https://docs.rs/serde_json

Free tier allows 100 successful requests per month. Only HTTP 200 responses count against quota. Starter is 5,000, Pro is 25,000, Business is 100,000. There is no crates.io source on this API. npm covers npmjs package names. python covers PyPI project names. A Rust watchlist that needs crate download counts has to pull those from somewhere else.

What did get_growth return for Rust language tokens?

Pulled on 2026-09-10 with source set to google search. get_growth tips on 2026-09-05. The prior Saturday 2026-08-29 is the last full week in the same series.

Do not treat 76.0 on bare rust as language demand. The metal and game token is mixed the same way bare go and bare ruby are mixed. rust programming at 14.0 is the cleaner language series. rust lang at 50.0 is a third series. rustlang at 23.0 moved +130.0% on 7D and -43.9% on 14D. Store each string. Do not substring-match rust onto rustlang.

rustlang 30D and YTD baselined at 0.0 and printed growth 999999. Report 23.0 versus 0.0. Do not store 999999 as language growth. The same 0.0 baseline showed up for several News windows on the sibling language pages.

Do not alert language adoption off a crate 3M crash. rust programming is 14.0 versus 41.0 on 2026-06-06 (-65.85%). serde is 25.0 versus 64.0 (-60.94%). reqwest is 22.0 versus 62.0 (-64.52%). cargo rust is 26.0 versus 95.0 (-72.63%). tokio over the same 3M window is 49.0 versus 52.0 (-5.77%). python Search in the same pull is 43.0 versus 100.0 (-57.0%). Scores are 0-100 per keyword. Do not rank rust programming 14.0 against python 43.0 as a share-of-search. The 2026-09-09 pull printed python at 45.0 versus 39.0. Store the session pull.

get_time_series for rust programming on Google Search peaked at 100 on 2026-07-18. Adjacent weeks: 66 on 2026-07-11, 87 on 2026-07-25, 73 on 2026-08-01, then 20 on 2026-08-08. The 2025 high in this pull was 36 on 2025-10-04, with 35 on 2025-09-27 and 34 on 2025-12-13. The 2024 high was 28 on 2024-03-02. The 2026-09-05 tip at 14.0 is the fourth Saturday after that July spike closed, not a new peak.

What did YouTube, News, and Wikipedia return?

YouTube get_growth for rust programming tipped 65.0 on 2026-09-05, down 10.96% from 73.0 on 2026-08-29. 14D was 65.0 versus 67.0 (-2.99%). 30D was 65.0 versus 68.0 (-4.41%). 3M was 65.0 versus 67.0 (-2.99%). 12M was 65.0 versus 59.0 (+10.17%). YTD was 65.0 versus 79.0 (-17.72%). YouTube did not crash with Search. A 3M Search drop of 65.85% next to a YouTube 3M drop of 2.99% is two series, not one adoption number.

Google News for rust programming tipped 61.0 on 2026-09-05, up 90.62% from 32.0 on 2026-08-29. 30D was 61.0 versus 100.0 on 2026-08-08 (-39.0%). 14D, 3M, 12M, and YTD baselined at 0.0 and printed growth 999999. The payload included data_quality low and a warning that the underlying signal is over 90% zero values. Report the raw scores. Do not store 999999 as news growth. Keyword News and Google News Top News are different feeds.

Wikipedia is a monthly source. Compare on recent_volume, not on the 0-100 score. Title Rust (programming language) for August 2026 scored 11.0 with 49,857 views, down 13.27% in views from 57,488 in July (score 21.6, growth -49.07%). 3M views were 49,857 versus 60,059 in May (-16.99%). 12M views were 49,857 versus 46,005 in August 2025 (score 11.0 versus 5.6, volume +8.37%). Score +96.43% on that 12M window while views only rose 8.37%. Bare title Rust resolved to a different page: August score 3.7 with 12,758 views versus July 0.3 / 11,951 (score +1133.33%, volume +6.75%). Do not join 49,857 or 12,758 onto Search 14.0. See the Wikipedia source notes.

How does a watchlist store live boards next to weekly scores?

A live board poll uses get_top_trends with no keyword. The same trends_post helper works. On 2026-09-10 the Google Trends board dated 2026-09-10T10:01:40Z put iphone duo at rank 2. Weekly Search for that token was 0.0 for week 2026-09-05, with a low-quality warning. Shopping for the same token was 3.0. That split is the subject of iPhone Duo live rank versus weekly Search.

let board = trends_post(json!({
    "mode": "get_top_trends",
    "type": "Google Trends",
    "limit": 25
}))?;

Docs for the modes live at https://trendsapi.ai/docs. Google Search board strings are not always valid get_growth keywords. Pair get_top_trends rank, rank_change, and get_growth before writing an alert. Source notes for Search sit on Google Trends.

A weekly Rust job that stores five Search tokens plus one board uses 6 successful 200s. At 24 calls per 30-day month the free cap of 100 still has headroom. Daily polling of the same set is about 180 calls and needs Starter (5,000). The Go sibling of this helper is Go Trends API. The R sibling is R Trends API. The Python sibling is Python Trends API.

Envelope checklist

1. POST https://api.trendsapi.ai/api with Authorization: Bearer <api_key>.
2. Modes are get_time_series, get_growth, and get_top_trends only.
3. Parse body twice before reading results or dated points.
4. Google Search uses the exact token typed. rust, rust programming, rust lang, rustlang, and rustc are five series. Wikipedia titles are resolved names; confirm the title before joining volumes.
5. Quota counts successful 200 responses: free 100/month, then 5,000 / 25,000 / 100,000 on paid tiers.

No crates.io SDK is required. A 40-line reqwest helper covers growth, series, and board pulls for jobs that already run under cron or a systemd timer.