Call Trends API from Odin with core:http

An Odin job talks to Trends API with one POST to https://api.trendsapi.ai/api, a Bearer key, and a JSON body that names a mode. There is no official Odin library. core:http sends the request. core:encoding/json reads the envelope, then parses the body string a second time. Pulled on 2026-10-19, Google Search for odin programming scored 19.0 for the week of 2026-10-17, up 5.56% from 18.0. odin language scored 18.0, up 5.88% from 17.0. Those two tokens closed 1 point apart. YouTube for odin programming scored 39.0, up 11.43% from 35.0. Do not copy bare odin Search 67.0 onto a language-adoption alert that only watches the phrase token at 19.0. The same helper that stores those rows also pulls a live Google Trends board. A rank-2 film token that weekly Search printed at 34.0 versus 6.0 is documented in You Can See Everything live rank versus weekly Search.

How does an Odin client call Trends API?

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

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

package main

import "core:encoding/json"
import "core:fmt"
import "core:http"
import "core:os"

import openssl_http "vendor:openssl/http"

Envelope :: struct {
    statusCode: int,
    body:       string,
}

trends_post :: proc(payload: string) -> (inner: string, ok: bool) {
    when #defined(http.native_ssl_implementation) {
        http.set_ssl_client(http.native_ssl_implementation())
    } else {
        http.set_ssl_client(openssl_http.client_implementation())
    }

    c: http.Client
    http.client_init(&c)
    defer http.client_destroy_and_wait(&c)

    api_key := os.get_env("TRENDSAPI_API_KEY")
    req: http.Outgoing_Request
    req.method = .Post
    http.headers_set(&req.headers, "Authorization", fmt.tprintf("Bearer %s", api_key))
    http.headers_set(&req.headers, "Content-Type", "application/json")
    req.body = transmute([]u8)payload

    res, err := http.request_and_wait(&c, "https://api.trendsapi.ai/api", req)
    if err != nil {
        fmt.eprintf("request failed: %v\n", err)
        return "", false
    }
    defer http.incoming_response_destroy(res)

    envelope: Envelope
    if json_err := json.unmarshal(res.body[:], &envelope); json_err != nil {
        fmt.eprintf("unmarshal envelope: %v\n", json_err)
        return "", false
    }
    // body is a JSON string; parse it a second time
    return envelope.body, true
}

main :: proc() {
    payload := "{\"mode\":\"get_growth\",\"source\":\"google search\",\"keyword\":\"odin programming\",\"percent_growth\":[\"7D\",\"30D\",\"3M\",\"12M\"]}"
    inner, ok := trends_post(payload)
    if !ok {
        return
    }
    fmt.println(inner)
}

http.request_and_wait and json.unmarshal are in the Odin core collection. Docs live at:

https://pkg.odin-lang.org/core/encoding/json/
https://github.com/odin-lang/examples

The response envelope is {"statusCode": int, "body": string}. body is a JSON string and must be parsed a second time before reading recent_value. A V client that does the same double parse with net.http is on V Trends API. A Zig client is on Zig Trends API.

What did get_growth return for Odin language tokens?

get_growth for odin programming on google search tips on 2026-10-17. Store the exact strings. odin language is a different series. The compact phrase and the language phrase moved on the same 7D sign and different percents.

get_time_series for odin programming on Google Search closed at 19 on 2026-10-17, matching get_growth 19.0. Adjacent weeks: 18 on 2026-10-10, 22 on 2026-10-03, 28 on 2026-09-26, 25 on 2026-09-19. Peak in this pull is 100 on 2026-06-06, with 89 on 2026-06-13 and 87 on 2026-07-11. Tip 19 is not that June high. 12M versus 32.0 is the week of 2025-10-18, the same Saturday a year earlier. 7D printed +5.56% versus 18.0, the opposite sign from 14D -13.64% and 3M -77.65%. A job that alerts on 7D +5.56% while 3M sits at -77.65% versus 85.0 is reading a one-week bounce, not a new peak.

odin language closed at 18.0, up 5.88% from 17.0. Same 7D sign as odin programming, 1 point apart, phrase sat lower. 14D was 18.0 versus 31.0 (-41.94%). 3M was 18.0 versus 79.0 (-77.22%). Do not copy 19.0 onto odin language 18.0.

odin-lang closed at 6.0, up 20.0% from 5.0. The payload marked data_quality low with a warning that the underlying signal is over 90% zeros. 14D, 30D, 3M, 12M, and YTD baselined at 0.0 and printed growth 999999. Report 6.0 versus 0.0. That hyphenated string is not package-download volume.

Bare odin closed at 67.0, up 6.35% from 63.0, with estimated Search volume 528,000. 3M was 67.0 versus 70.0 (-4.29%). YTD was 67.0 versus 75.0 (-10.67%). That four-letter string mixes the Norse name, other products, and the language. Do not treat Search 67.0 as Odin language adoption. There is no Odin package registry source on this API.

Neighbor languages on the same pull, same source, same 7D window:

odin programming and zig programming closed at the same 7D score of 19.0 and different 7D baselines (18.0 versus 17.0). Do not copy zig 19.0 onto odin 19.0. nim programming YTD printed growth 999999 versus 0.0. Report 17.0 versus 0.0. A Zig Trends API helper stores the systems-language neighbor on the same 7D window. A prior calendar-day pull on the same Saturday tip printed odin programming at 18.0 versus 22.0. Store the session pull. Same-tip reprints are not a new week.

What did YouTube, News, and Wikipedia return?

YouTube for odin programming closed higher than Search on the 0-100 score. Keyword Google News for odin programming returned 502 twice. Wikipedia titles resolve on their own. Compare Wikipedia on volume.

YouTube for odin programming tipped 39.0 on 2026-10-17, up 11.43% from 35.0, while Search rose 5.56% to 19.0. The payload marked data_quality low. 14D, 30D, 12M, and YTD baselined at 0.0. Report 39.0 versus 0.0 for those. 3M was 39.0 versus 55.0 (-29.09%). get_time_series closed at 39, matching get_growth. Adjacent weeks: 35 on 2026-10-10, then 0, 0, 0. Peak in this pull is 100 on 2026-06-13, with 82 on 2025-12-20, 78 on 2026-08-01, and 77 on 2026-02-14. Tip 39 is not that June peak. On 2026-06-06 Search printed 100 while YouTube printed 74. On 2026-06-13 YouTube printed 100 while Search printed 89. YouTube 39.0 is not Search 19.0. Do not treat the YouTube floor as language adoption while Search sits at 19.0 after a 100 close four months earlier.

Keyword Google News for odin programming returned 502 source_unavailable on two calls. Store the miss. Keyword Google News for odin language printed 0.0 versus 0.0 on every window, also data_quality low. Do not fill News from Search 19.0. Keyword News and the Google News Top News board are different feeds. Mode docs sit at https://trendsapi.ai/docs.

Wikipedia for Odin (programming language) collapsed 7D and 14D (collapsed_range: recent and baseline resolved to the same monthly point). September 2026 scored 0.1 with 3 pageviews versus August 0.0 with 1 (volume +200.0%). 3M was 0.1 / 3 versus June 0.0 / 0. 12M returned date_out_of_range. YTD was 0.1 / 3 versus February 55.1 / 1,927 (volume -99.84%). The sparse series peaks at 100.0 / 3,497 in March 2026, then drops to 3, 4, 0, 2, 1, and 3 views from April through September. Compare Wikipedia on volume. Do not join 3 views onto Search 19.0. Bare Odin resolved to a different page (September 9.9 / 58,485 views versus August 11.1 / 60,883). Short title has more September views than the language title (58,485 versus 3). Store both titles. Wikipedia source docs sit at https://trendsapi.ai/trends/wikipedia-trends.

There is no Odin package registry source on this API. npm covers npmjs. python covers PyPI. An Odin watchlist that wants package downloads has no third source to join onto Search 19.0.

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

get_top_trends has no keyword. Pair the live Google Trends board with get_growth on the exact board string. Live rank, 1-day rank_change, and 7-day rank_change are three feeds. The rank snapshot can stamp two hours earlier than the mover snapshot.

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

{"mode":"get_top_trends","type":"Google Trends","limit":25}

On 2026-10-19T08:01:37Z the live Google Trends board ranked you can see everything at 2. The 1-day rank_change sort stamped 2026-10-19T10:01:33Z, returned 22 rows (baseline 2026-10-18T02:01:38Z), and listed that token at +2 from previous rank 4. The 7-day sort returned 1 row (baseline 2026-10-12T02:01:36Z) and omitted it. Weekly Search for that exact string scored 34.0 versus 6.0, up 466.67%. The helper that stores those rows is the blog in this batch: You Can See Everything live rank versus weekly Search. Board-shape notes for Google Trends live feeds sit at https://trendsapi.ai/trends/google-trends.

Free tier is 100 successful 200s per month. Only 200 responses count against quota. Five language tokens plus one live board is 6 calls. A Monday run that also pulls YouTube and Wikipedia for the programming phrase is 8 calls. Four weeks is 32 calls and still fits the free cap. Starter is 5,000, Pro 25,000, Business 100,000.

Envelope checklist

1. POST https://api.trendsapi.ai/api with Authorization: Bearer <api_key>.
2. Parse the transport JSON, then parse the body string a second time.
3. Store odin, odin programming, odin language, and odin-lang as separate series.
4. Compare Wikipedia Odin (programming language) on volume (3 September views), not on 0.1.
5. Pair get_top_trends rank with both rank_change windows and get_growth on the exact board string.

A Nim client that uses std/httpclient for the same envelope is on Nim Trends API.