GenRank API v2

This document is the whole reference for the GenRank API. It is written for people and for agents alike: hand over this URL and a key, nothing else. Plain text: https://www.genrank.com/api/v2/docs.md. The same text as a page: https://www.genrank.com/en-us/data/api. OpenAPI 3.1: https://www.genrank.com/api/v2/docs.

Quick start

1. Get a key. Apply at https://www.genrank.com/en-us/data. A key is a string starting with grk_, shown once. Keep it on a server; never put it in a browser.

2. Send Authorization: Bearer <key> and a language query with every request. language=ko is the Korean index, language=en the English one. The two never mix.

3. First call:

   curl -H "Authorization: Bearer $GENRANK_API_KEY" \
     "https://www.genrank.com/api/v2/categories?language=ko&q=dental"
   

4. To look at one brand, find its id with /entities/search?q=<brand>&language=ko, then call /entities/{id}/overview?language=ko. One answer carries its category ranks, top questions, the brands named alongside it, the sources cited, its regional ranks, a four-week trend and the run status.

5. Read again weekly. A Korean week starts Sunday 00:00 KST; a week's numbers are final once /runs?language=ko reports that run as completed.

6. Quote the edition (week_start) and the methodology_version with every number. A ranking without them is not a GenRank ranking.

7. Matching. To start from a website instead of a name, call /entities/resolve?url=<site>&language=ko, adding &name=<the site's own name> when you know it. To place a brand GenRank does not have, POST its name and what it sells to /classify, then POST it to /categories/{key}/competitors. To check your own AI answers the way GenRank reads its own, POST them to /extract: the response says which of your brands each answer named, where, and what kind of source each citation is.

Response shapes are defined by the reference below and by the OpenAPI document. Errors are always { "error": "...", "code": "..." }.

Endpoints

Base URL: https://www.genrank.com/api/v2. Index routes are GET; the matching routes that compute from what you send are POST with a JSON body. Columns: the parameter, where it goes, whether it is required, what it means.

Categories

GET /categories

The category tree as a flat list with question and brand counts and the top three of each; with q, the categories matching a name, key or question texts

Response CategoriesResponse:

• meta: object
• total: integer
• categories: array of object
  • key: string
  • name_ko: string
  • name_en: string
  • level: integer
  • geo_mode: city | metro | country
  • parent_key: string
  • questions: integer (Active national questions in the subtree)
  • regional_questions: integer
  • brands: integer (Entities ranked in this category)
  • leaders: array of object (Top three of the current ranking)
    • id: string
    • slug: string
    • name: string
    • score: number
  • match: object
    • kind: exact | name | question (What matched q: the key or a name exactly, a name partially, or question texts)
    • score: number

Statuses: 200, 304, 400, 401, 403, 429, 503.

curl -H "Authorization: Bearer $GENRANK_API_KEY" "https://www.genrank.com/api/v2/categories?language=ko"

POST /categories/{key}/competitors

The category's ranked entities by relevance to one brand: nearest by meaning first, then a judge model's probability that the brand's customers compare the two

Body CompetitorsRequest:

• language: ko | en
• entity_id: string
• name: string
• homepage: string
• offering: string (What the brand sells and to whom, one or two sentences)
• limit: integer

Response CompetitorsResponse:

• meta: object
• relevance_version: string
• judged_by: model | vector
• window: object (The 4-week window of mentions and trials)
  • from_week: string (Sunday (KST) that starts a GenRank week, YYYY-MM-DD)
  • to_week: string (Sunday (KST) that starts a GenRank week, YYYY-MM-DD)
• competitors: array of object
  • entity: object
    • id: string
    • slug: string
    • name: string
  • rank: integer (Current rank in the category)
  • relevance: number (Probability that this brand's customers compare the two)
  • similarity: number
  • co_mentions: integer (Answers in window that named both this brand and the entity_id brand, over the category's own questions (2.6.0: the same four weeks as mentions and trials). null without entity_id (no brand to count with) and in a category above the leaves (co-mentions are kept per leaf): show no number then)
  • mentions: integer (Answers in this category that named it, over the window, on the current panel: the total.mentions of its /categories/{key}/matrix row)
  • trials: integer (Answers measured for this category over the same window and panel: the total.trials of its matrix row)

Statuses: 200, 400, 401, 403, 404, 413, 429, 503.

curl -H "Authorization: Bearer $GENRANK_API_KEY" -H "Content-Type: application/json" -d '{"language":"ko","name":"Lemonbase","offering":"Performance reviews, 1:1s and OKRs for HR teams","limit":12}' "https://www.genrank.com/api/v2/categories/software-hr-hris/competitors"

GET /categories/{key}

One category: node, ancestors, children, and how many weekly editions it has

Response CategoryDetailResponse:

• meta: object
• category: object
  • key: string
  • name_ko: string
  • name_en: string
  • level: integer
  • geo_mode: city | metro | country
  • parent_key: string
  • questions: integer (Active national questions in the subtree)
  • regional_questions: integer
  • brands: integer (Entities ranked in this category)
  • leaders: array of object (Top three of the current ranking)
    • id: string
    • slug: string
    • name: string
    • score: number
  • match: object
    • kind: exact | name | question (What matched q: the key or a name exactly, a name partially, or question texts)
    • score: number
• ancestors: array of object (Root first)
  • key: string
  • name_ko: string
  • name_en: string
  • level: integer
  • geo_mode: city | metro | country
• children: array of object
  • key: string
  • name_ko: string
  • name_en: string
  • level: integer
  • geo_mode: city | metro | country
  • parent_key: string
  • questions: integer (Active national questions in the subtree)
  • regional_questions: integer
  • brands: integer (Entities ranked in this category)
  • leaders: array of object (Top three of the current ranking)
    • id: string
    • slug: string
    • name: string
    • score: number
  • match: object
    • kind: exact | name | question (What matched q: the key or a name exactly, a name partially, or question texts)
    • score: number
• rollup: object
  • weeks_measured: integer
  • latest_week: string (Sunday (KST) that starts a GenRank week, YYYY-MM-DD)
  • methodology_version: string

Statuses: 200, 304, 400, 401, 403, 404, 429, 503.

curl -H "Authorization: Bearer $GENRANK_API_KEY" "https://www.genrank.com/api/v2/categories/services-health-dental?language=ko"

GET /categories/{key}/rankings

The ranking of a category in one kept week (default: the latest), with each entity's previous rank. National only.

Response CategoryRankingsResponse:

• meta: object
• category: object
  • key: string
  • name_ko: string
  • name_en: string
  • level: integer
  • geo_mode: city | metro | country
• week_start: string (Sunday (KST) that starts a GenRank week, YYYY-MM-DD)
• previous_week: string (Sunday (KST) that starts a GenRank week, YYYY-MM-DD)
• methodology_version: string
• total: integer
• offset: integer
• rankings: array of object
  • id: string
  • slug: string
  • name: string
  • rank: integer
  • score: number (GenRank score: the unbounded weighted sum behind the rank)
  • previous_rank: integer (Rank in the previous kept week; NULL when new or not comparable)

Statuses: 200, 304, 400, 401, 403, 404, 429, 503.

curl -H "Authorization: Bearer $GENRANK_API_KEY" "https://www.genrank.com/api/v2/categories/services-health-dental/rankings?language=ko"

GET /categories/{key}/history

Top N of a category per kept week with the methodology version of each week; one entity's rows added with entity. National only.

Response CategoryHistoryResponse:

• meta: object
• category: object
  • key: string
  • name_ko: string
  • name_en: string
  • level: integer
  • geo_mode: city | metro | country
• weeks: array of object (Kept weeks, oldest first; a change of major methodology version is a break)
  • week_start: string (Sunday (KST) that starts a GenRank week, YYYY-MM-DD)
  • methodology_version: string
• entities: array of object
  • id: string
  • slug: string
  • name: string
  • current_rank: integer
• points: array of object
  • week_start: string (Sunday (KST) that starts a GenRank week, YYYY-MM-DD)
  • entity_id: string
  • rank: integer
  • score: number

Statuses: 200, 304, 400, 401, 403, 404, 429, 503.

curl -H "Authorization: Bearer $GENRANK_API_KEY" "https://www.genrank.com/api/v2/categories/services-health-dental/history?language=ko"

GET /categories/{key}/graph

Co-mention graph of the top entities and the domain-to-entity source flow over the last four weeks. National only.

Response CategoryGraphResponse:

• meta: object
• category: object
  • key: string
  • name_ko: string
  • name_en: string
  • level: integer
  • geo_mode: city | metro | country
• window: object
  • from_week: string (Sunday (KST) that starts a GenRank week, YYYY-MM-DD)
  • to_week: string (Sunday (KST) that starts a GenRank week, YYYY-MM-DD)
  • weeks: 4
• nodes: array of object
  • id: string
  • slug: string
  • name: string
  • rank: integer
  • answers: integer (Answers naming the entity in the window)
• edges: array of object
  • a: string
  • b: string
  • answers: integer (Answers naming both)
  • questions: integer
  • surfaces: integer
• sources: object
  • domains: array of object
    • domain: string
    • type: string
    • answers: integer
  • entities: array of object
    • id: string
    • slug: string
    • name: string
    • rank: integer
  • links: array of object
    • domain: string
    • entity_id: string
    • answers: integer

Statuses: 200, 304, 400, 401, 403, 404, 429, 503.

curl -H "Authorization: Bearer $GENRANK_API_KEY" "https://www.genrank.com/api/v2/categories/services-health-dental/graph?language=ko"

GET /categories/{key}/matrix

Mentions and trials per surface for the top entities of a category over the 4-week window; counts only. National only.

Response CategoryMatrixResponse:

• meta: object
• category: object
  • key: string
  • name_ko: string
  • name_en: string
  • level: integer
  • geo_mode: city | metro | country
• window: object
  • from_week: string (Sunday (KST) that starts a GenRank week, YYYY-MM-DD)
  • to_week: string (Sunday (KST) that starts a GenRank week, YYYY-MM-DD)
• surfaces: array of object
  • model_id: string
  • name: string
  • role: scored | observed
  • weight: number
• rows: array of object
  • id: string
  • slug: string
  • name: string
  • rank: integer (Rank in the category; null for a pinned entity not ranked in it (2.6.0))
  • pinned: boolean (Asked for with pin= (2.6.0); a pinned entity ranked within limit is not repeated)
  • cells: array of object (One cell per surface, in surfaces order. trials is the category's answers measured on the surface, the same for every row)
    • model_id: string
    • trials: integer
    • mentions: integer
  • total: object
    • trials: integer
    • mentions: integer

Statuses: 200, 304, 400, 401, 403, 404, 429, 503.

curl -H "Authorization: Bearer $GENRANK_API_KEY" "https://www.genrank.com/api/v2/categories/services-health-dental/matrix?language=ko"

GET /categories/{key}/questions

Questions of a category and its descendants; with region_id, that region's questions and their publish gates

Response CategoryQuestionsResponse:

• meta: object
• category: object
  • key: string
  • name_ko: string
  • name_en: string
  • level: integer
  • geo_mode: city | metro | country
  • priority: string
  • t: string
• questions: array of object
  • id: string
  • slug: string
  • text: string
  • intent: best | compare | choose | transactional
  • topic: string
  • region_id: string
  • status: active | retired
  • retired_at: string
  • replaced_by: string (Slug of the follow-up question when retired)
  • rank: object
    • score: number
    • search_component: number
    • estimate_component: number
    • basis: none | search_only | estimate_only | combined
    • computed_at: string
  • signals: object
    • naver_pc: integer
    • naver_mobile: integer
    • google: integer
    • fetched_at: string
  • estimates: array of object
    • model_id: string
    • rank: integer
  • first_measured_week: string (Sunday (KST) that starts a GenRank week, YYYY-MM-DD)
  • weeks_measured: integer
  • gate: object
    • published: boolean
    • entities: integer
    • models_agreeing: integer
    • weeks: integer
• total: integer

Statuses: 200, 304, 400, 401, 403, 404, 429, 503.

curl -H "Authorization: Bearer $GENRANK_API_KEY" "https://www.genrank.com/api/v2/categories/services-health-dental/questions?language=ko"

GET /categories/{key}/citations

Sources the answers of a category (and its descendants) cited in one week: domains with distinct answer, question and model counts, and each domain's most cited pages

Response CategoryCitationsResponse:

• meta: object
• category: object
  • key: string
  • name_ko: string
  • name_en: string
  • level: integer
  • geo_mode: city | metro | country
• week_start: string (The week shown; NULL when the category has no citations yet)
• weeks: array of string (Weeks with citation data for this category, newest first)
• answers: array of object (Per surface of the panel, by weight as in /models, then any other surface measured that week (2.6.0). Empty for weeks kept before 18 October 2026)
  • model_id: string
  • asked: integer (Cells measured: every question asked on this surface, including those where the surface showed no AI answer or the call failed (the denominator of the public sources page))
  • answers: integer (Cells with an AI answer)
  • cited_answers: integer (Answers citing at least one source)
• types: array of object (Every domain of the week folded by type, not cut by limit: all nine types, each with every surface (2.6.0))
  • type: portal | social | community | directory | shopping | media | reference | public | other
  • by_model: array of object (One entry per surface, zeros included. responses counts an answer once however many sites of the type it cites, so it can be less than the sum of the type's domains)
    • model_id: string
    • responses: integer (Distinct answers of this surface that cited it in the week)
    • questions: integer (Questions those answers belong to)
    • answers: integer (Answers this surface gave in the week (an AI answer was there): the denominator of the share)
• domains: array of object
  • domain: string
  • type: portal | social | community | directory | shopping | media | reference | public | other
  • responses: integer (Distinct answers that cited this domain)
  • questions: integer
  • models: integer
  • by_model: array of object (One entry per surface, in answers order, zeros included (2.6.0))
    • model_id: string
    • responses: integer (Distinct answers of this surface that cited it in the week)
    • questions: integer (Questions those answers belong to)
    • answers: integer (Answers this surface gave in the week (an AI answer was there): the denominator of the share)
  • urls: array of object (The most cited pages of this domain)
    • url: string
    • title: string
    • responses: integer (Distinct answers that cited this URL)

Statuses: 200, 304, 400, 401, 403, 404, 429, 503.

curl -H "Authorization: Bearer $GENRANK_API_KEY" "https://www.genrank.com/api/v2/categories/services-health-dental/citations?language=ko"

Entities

GET /entities/search

Find entities by name or alias (q) or website domain; with region_id, that region's entities join the national ones

Response EntitySearchResponse:

• meta: object
• entities: array of object
  • id: string
  • slug: string
  • name: string
  • type: string
  • aliases: array of string
  • website: string
  • region_id: string
  • parent_entity_id: string
  • categories: array of object
    • key: string
    • name_ko: string
    • name_en: string
    • level: integer
    • geo_mode: city | metro | country
  • score_summary: object
    • inclusion_rate_4w: number
    • trials_4w: integer
    • mentions_4w: integer
    • questions: integer
  • match: object (How the entity was found (2.2.0): sound is the same Hangul/Latin sound skeleton, semantic is vector similarity)
    • kind: exact | name | alias | sound | semantic | website | domain
    • score: number

Statuses: 200, 304, 400, 401, 403, 429, 503.

curl -H "Authorization: Bearer $GENRANK_API_KEY" "https://www.genrank.com/api/v2/entities/search?language=ko"

GET /entities/resolve

Which entity a website belongs to: a stored website, else entities named in answers that cited the site, ranked with how much the site name sounds like theirs

Response EntityResolveResponse:

• meta: object
• site: object
  • host: string
  • label: string (The registrable name, e.g. "lemonbase" for www.lemonbase.com)
  • platform: string (Citation type when the host is a portal, store, map, social or media site; its citations say nothing about ownership)
  • account: string (Account or place id on a platform URL)
  • title: string (The page title as AI answers cited it; for a place, its own name (2.2.1))
• match: website | likely | candidates | none | platform
• candidates: array of object
  • entity: object
    • id: string
    • slug: string
    • name: string
    • type: string
    • region_id: string
  • match: website | cited | sound (website: the stored website is this host; cited: answers that named the entity cited the site or page; sound: no answer cited it, but the name sounds like the site name (2.2.1), or one of the names sent is its name or alias (name_match true, name_similarity 1; 2.7.0))
  • cited_answers: integer (Answers in the latest measured week that named the entity and cited the site)
  • name_similarity: number (How much the site name sounds like the entity name (Hangul and Latin compared by sound); 1 for a cited entity whose name or alias is one of the names sent (2.5.0), and for an entity found by one of them in the whole index (2.7.0))
  • confidence: number
  • name_match: boolean (One of the names sent (name=) is the entity's name or alias, compared without case, spaces or punctuation; false when no name was sent (2.5.0))

Statuses: 200, 304, 400, 401, 403, 429, 503.

curl -H "Authorization: Bearer $GENRANK_API_KEY" "https://www.genrank.com/api/v2/entities/resolve?url=…&language=ko"

POST /entities/suggest

Record a brand GenRank does not have. It never adds the brand to a ranking: GenRank asks questions, and an entity appears only when AI answers name it

Body SuggestRequest:

• language: ko | en
• name: string
• homepage: string
• offering: string (What the brand sells and to whom, one or two sentences)
• category_key: string
• source: string

Response SuggestResponse:

• status: recorded | exists
• suggestion_id: string
• times: integer (How many times this site or name has been suggested)
• entity: object (The entity this site already belongs to, when status is exists)
  • id: string
  • slug: string
  • name: string

Statuses: 200, 202, 400, 401, 403, 413, 429, 503.

• 200: Suggested before (status: recorded, times counts up), or the site already belongs to a GenRank entity (status: exists with entity)
• 202: First suggestion of this site or name: status: recorded, times: 1

curl -H "Authorization: Bearer $GENRANK_API_KEY" -H "Content-Type: application/json" -d '{"language":"ko","name":"…","homepage":"https://…","offering":"…"}' "https://www.genrank.com/api/v2/entities/suggest"

GET /entities/{id}

Entity detail: categories, per-question and per-model 4-week numbers, peers, region and parent when regional

Response EntityDetailResponse:

• meta: object
• entity: object
  • id: string
  • slug: string
  • name: string
  • type: string
  • aliases: array of string
  • website: string
  • region_id: string
  • parent_entity_id: string
  • categories: array of object
    • key: string
    • name_ko: string
    • name_en: string
    • level: integer
    • geo_mode: city | metro | country
  • description: string
  • region: object (The region of a regional entity; NULL for the national index (widened from null in 2.1.0))
    • id: string
    • slug: string
    • level: sido | sigungu | district
    • parent_id: string
    • name_ko: string
    • name_en: string
  • parent: object (The national entity a regional one belongs to, when known (widened from null in 2.1.0))
    • id: string
    • slug: string
    • name: string
  • score_summary: object
    • inclusion_rate_4w: number
    • trials_4w: integer
    • mentions_4w: integer
    • questions: integer
• questions: array of object
  • slug: string
  • text: string
  • status: active | retired
  • from_week: string (Sunday (KST) that starts a GenRank week, YYYY-MM-DD)
  • to_week: string (Sunday (KST) that starts a GenRank week, YYYY-MM-DD)
  • inclusion_rate_4w: number
  • mean_rank: number
  • models: array of object
    • model_id: string
    • trials: integer
    • mentions: integer
    • mean_rank: number
    • cited: integer (Trials in which the entity's own site was cited. NULL until citations are linked to entities.)
• peers: array of object
  • id: string
  • slug: string
  • name: string
  • category_key: string
  • rank: integer
  • inclusion_rate_4w: number

Statuses: 200, 301, 304, 400, 401, 403, 404, 410, 429, 503.

curl -H "Authorization: Bearer $GENRANK_API_KEY" "https://www.genrank.com/api/v2/entities/dental-a?language=ko"

GET /entities/{id}/history

Category rank per kept week, best current rank first

Response EntityHistoryResponse:

• meta: object
• entity: object
  • id: string
  • slug: string
  • name: string
• categories: array of object (Best current rank first)
  • category: object
    • key: string
    • name_ko: string
    • name_en: string
    • level: integer
    • geo_mode: city | metro | country
  • points: array of object
    • week_start: string (Sunday (KST) that starts a GenRank week, YYYY-MM-DD)
    • methodology_version: string
    • rank: integer
    • total: integer

Statuses: 200, 304, 400, 401, 403, 404, 429, 503.

curl -H "Authorization: Bearer $GENRANK_API_KEY" "https://www.genrank.com/api/v2/entities/dental-a/history?language=ko"

GET /entities/{id}/graph

Entities named alongside this one and the sources those answers cite, over the last four weeks

Response EntityGraphResponse:

• meta: object
• entity: object
  • id: string
  • slug: string
  • name: string
• scope: national | regional
• window: object
  • to_week: string (Sunday (KST) that starts a GenRank week, YYYY-MM-DD)
  • weeks: 4
• co_mentions: array of object (Entities named in the same answers, most often first)
  • id: string
  • slug: string
  • name: string
  • answers: integer
  • questions: integer
  • surfaces: integer
• sources: array of object (Domains cited by answers naming the entity)
  • domain: string
  • type: string
  • answers: integer
  • questions: integer
  • surfaces: integer

Statuses: 200, 304, 400, 401, 403, 404, 429, 503.

curl -H "Authorization: Bearer $GENRANK_API_KEY" "https://www.genrank.com/api/v2/entities/dental-a/graph?language=ko"

GET /entities/{id}/overview

One call for an onboarding screen: detail, category ranks, top questions, co-mentions, sources, regions, 4-week trend, run status. Parts that fail are named in partial.

Response EntityOverviewResponse:

• meta: object
• entity: object
  • id: string
  • slug: string
  • name: string
  • type: string
  • aliases: array of string
  • website: string
  • region_id: string
  • parent_entity_id: string
  • categories: array of object
    • key: string
    • name_ko: string
    • name_en: string
    • level: integer
    • geo_mode: city | metro | country
  • description: string
  • region: object (The region of a regional entity; NULL for the national index (widened from null in 2.1.0))
    • id: string
    • slug: string
    • level: sido | sigungu | district
    • parent_id: string
    • name_ko: string
    • name_en: string
  • parent: object (The national entity a regional one belongs to, when known (widened from null in 2.1.0))
    • id: string
    • slug: string
    • name: string
  • score_summary: object
    • inclusion_rate_4w: number
    • trials_4w: integer
    • mentions_4w: integer
    • questions: integer
• categories: array of object
  • key: string
  • name_ko: string
  • name_en: string
  • level: integer
  • geo_mode: city | metro | country
  • rank: integer
  • total: integer
  • score: number
• questions: array of object (Top ten by 4-week inclusion)
  • slug: string
  • text: string
  • status: active | retired
  • from_week: string (Sunday (KST) that starts a GenRank week, YYYY-MM-DD)
  • to_week: string (Sunday (KST) that starts a GenRank week, YYYY-MM-DD)
  • inclusion_rate_4w: number
  • mean_rank: number
  • models: array of object
    • model_id: string
    • trials: integer
    • mentions: integer
    • mean_rank: number
    • cited: integer (Trials in which the entity's own site was cited. NULL until citations are linked to entities.)
• co_mentions: array of object
  • id: string
  • slug: string
  • name: string
  • answers: integer
  • questions: integer
  • surfaces: integer
• sources: array of object
  • domain: string
  • type: string
  • answers: integer
  • questions: integer
  • surfaces: integer
• regions: array of object
  • region_id: string
  • region_slug: string
  • category_key: string
  • question_id: string
  • rank: integer
  • score: number
  • week_start: string (Sunday (KST) that starts a GenRank week, YYYY-MM-DD)
• trend: array of object (Last four kept weeks in up to three categories)
  • category: object
    • key: string
    • name_ko: string
    • name_en: string
    • level: integer
    • geo_mode: city | metro | country
  • points: array of object
    • week_start: string (Sunday (KST) that starts a GenRank week, YYYY-MM-DD)
    • methodology_version: string
    • rank: integer
    • total: integer
• runs: array of object
  • id: string
  • week_start: string (Sunday (KST) that starts a GenRank week, YYYY-MM-DD)
  • scope: national | regional
  • language: ko | en (NULL for runs that covered every language (all runs before v4.0))
  • trigger_type: string
  • status: running | completed | failed
  • questions_total: integer
  • questions_completed: integer
  • started_at: string
  • completed_at: string
  • routes: object
    • batch: integer
    • direct: integer
    • openrouter: integer
• partial: array of string (Parts that could not be read this time; they are empty, not absent)

Statuses: 200, 301, 304, 400, 401, 403, 404, 410, 429, 503.

curl -H "Authorization: Bearer $GENRANK_API_KEY" "https://www.genrank.com/api/v2/entities/dental-a/overview?language=ko"

Questions

GET /questions/{slug}/results

One question: raw answers per model, entities, citations, 4-week cells. A regional slug carries its region; region_id, when given, must match.

Response QuestionResultsResponse:

• question: object
  • id: string
  • slug: string
  • text: string
  • status: active | retired
  • replaced_by: string
  • region_id: string
  • intent: string
  • topic: string
  • categories: array of string
• week_start: string (Sunday (KST) that starts a GenRank week, YYYY-MM-DD)
• methodology_version: string
• models: array of object
  • model_id: string
  • name: string
  • provider: string
  • weight: number
  • web_search: boolean
  • collection: api | serp
• responses: array of object
  • model_id: string
  • measured_at: string
  • week_start: string (Sunday (KST) that starts a GenRank week, YYYY-MM-DD)
  • route: direct | openrouter | batch
  • search_location: null
  • response_text: string
  • entities: array of object
    • id: string
    • slug: string
    • name: string
    • rank: integer
    • role: answer
  • citations: array of object
    • url: string
    • domain: string
    • title: string
    • type: string (Source type. NULL until classification ships (REVAMP 6.3).)
  • status: ok | empty | failed
• cells_4w: object
  • from_week: string (Sunday (KST) that starts a GenRank week, YYYY-MM-DD)
  • to_week: string (Sunday (KST) that starts a GenRank week, YYYY-MM-DD)
  • cells: array of object
    • model_id: string
    • trials: integer
    • mentions: integer
    • mean_rank: number
    • cited: integer (Trials in which the entity's own site was cited. NULL until citations are linked to entities.)
    • entity_id: string
• entities: array of object
  • id: string
  • slug: string
  • name: string
• meta: object

Statuses: 200, 304, 400, 401, 403, 404, 429, 503.

curl -H "Authorization: Bearer $GENRANK_API_KEY" "https://www.genrank.com/api/v2/questions/dental-network-brands-affordable/results?language=ko"

GET /questions/{slug}/history

Weekly history of a question for one entity or its top 10

Response QuestionHistoryResponse:

• meta: object
• question: object
  • slug: string
  • status: active | retired
• entities: array of object
  • id: string
  • slug: string
  • name: string
• points: array of object
  • week_start: string (Sunday (KST) that starts a GenRank week, YYYY-MM-DD)
  • entity_id: string
  • model_id: string (NULL when the point is the cross-model rank (runs before per-model cells were stored))
  • mentioned: boolean
  • rank: integer

Statuses: 200, 304, 400, 401, 403, 404, 429, 503.

curl -H "Authorization: Bearer $GENRANK_API_KEY" "https://www.genrank.com/api/v2/questions/dental-network-brands-affordable/history?language=ko"

GET /questions/results

Latest results for up to 50 questions

Response BulkResultsResponse:

• meta: object
• results: array of object
  • question: object
    • id: string
    • slug: string
    • text: string
    • status: active | retired
    • replaced_by: string
    • region_id: string
    • intent: string
    • topic: string
    • categories: array of string
  • week_start: string (Sunday (KST) that starts a GenRank week, YYYY-MM-DD)
  • methodology_version: string
  • models: array of object
    • model_id: string
    • name: string
    • provider: string
    • weight: number
    • web_search: boolean
    • collection: api | serp
  • responses: array of object
    • model_id: string
    • measured_at: string
    • week_start: string (Sunday (KST) that starts a GenRank week, YYYY-MM-DD)
    • route: direct | openrouter | batch
    • search_location: null
    • response_text: string
    • entities: array of object
    • citations: array of object
    • status: ok | empty | failed
  • cells_4w: object
    • from_week: string (Sunday (KST) that starts a GenRank week, YYYY-MM-DD)
    • to_week: string (Sunday (KST) that starts a GenRank week, YYYY-MM-DD)
    • cells: array of object
  • entities: array of object
    • id: string
    • slug: string
    • name: string
• missing: array of string
• unchanged: array of string (Slugs skipped because nothing was measured after updated_since)

Statuses: 200, 304, 400, 401, 403, 429, 503.

curl -H "Authorization: Bearer $GENRANK_API_KEY" "https://www.genrank.com/api/v2/questions/results?slugs=a,b&language=ko"

Matching

POST /classify

Which GenRank categories a brand competes in: nearest categories by meaning and categories named by its words, then a judge model chooses among them, with the probability that none fits

Body ClassifyRequest:

• language: ko | en
• name: string
• homepage: string
• offering: string (What the brand sells and to whom, one or two sentences)
• site_text: string (Text of the brand site; the first 1,500 characters are used)
• limit: integer

Response ClassifyResponse:

• meta: object
• classifier_version: string
• judged_by: model | vector (vector when the judge model did not answer and the order is by similarity only)
• none_probability: number (Probability that no GenRank category fits; null when judged_by is vector)
• categories: array of object
  • key: string
  • name_ko: string
  • name_en: string
  • level: integer
  • geo_mode: city | metro | country
  • path: array of string
  • probability: number
  • similarity: number (Cosine similarity of the brand and category vectors)
  • source: vector | name (How the category reached the judge: among the nearest by meaning, or because its name holds a word of offering or site_text)

Statuses: 200, 400, 401, 403, 413, 429, 503.

curl -H "Authorization: Bearer $GENRANK_API_KEY" -H "Content-Type: application/json" -d '{"language":"ko","name":"Lemonbase","homepage":"https://lemonbase.com","offering":"Performance reviews, 1:1s and OKRs for HR teams"}' "https://www.genrank.com/api/v2/classify"

POST /extract

Check AI answers for mentions of your brands with GenRank's own extractor, and type each citation, in the request. 503 when any answer could not be read: nothing is judged then, retry after Retry-After

Body ExtractRequest, one of:

1. Up to 20 answers in items:

   • language: ko | en
   • items: array of object
     • question: string
     • answer: string
     • citations: array of object
       • url: string
       • title: string
     • tracked: array of object
       • entity_id: string
       • name: string
       • aliases: array of string
       • homepage: string (The brand's site or platform page; cited pages on it count as the brand's own)

2. One answer:

   • question: string
   • answer: string
   • citations: array of object
     • url: string
     • title: string
   • tracked: array of object
     • entity_id: string
     • name: string
     • aliases: array of string
     • homepage: string (The brand's site or platform page; cited pages on it count as the brand's own)
   • language: ko | en

Response ExtractResponse:

• meta: object
• extractor_version: string
• results: array of object
  • index: integer
  • entities: array of object (What the answer recommends, in its order; sources and generic terms are left out)
    • entity_id: string
    • name: string
    • rank: number
    • tracked_index: integer
  • tracked: array of object
    • index: integer
    • mentioned: boolean
    • rank: number
  • citations: array of object (One per citation sent, in order)
    • index: integer (Position in the citations you sent)
    • domain: string (Host of the page cited, without www. Google's redirects (google.com/goto, Gemini grounding links) are opened and translated pages (translate.google.com, translate.goog) count as the page; Google Maps and Shopping pages on google.com count as maps.google.com and shopping.google.com. NULL when the URL is not one, or a Google redirect could not be opened)
    • type: portal | social | community | directory | shopping | media | reference | public | other
    • tracked_index: integer (The tracked brand whose own site or platform page this is)

Statuses: 200, 400, 401, 403, 413, 429, 503.

curl -H "Authorization: Bearer $GENRANK_API_KEY" -H "Content-Type: application/json" -d '{"language":"ko","question":"Recommend a performance review tool","answer":"1. flex 2. Lemonbase 3. Others","citations":[{"url":"https://lemonbase.com/blog","title":"Lemonbase blog"}],"tracked":[{"name":"Lemonbase","homepage":"https://lemonbase.com"}]}' "https://www.genrank.com/api/v2/extract"

Index

GET /sources

Sources across the whole index in one week, the figures of the public sources page: per surface the cells asked, answers and citing answers, every source type with the answers citing it per surface, and the most cited domains per surface (2.6.0)

Response SourcesResponse:

• meta: object
• scope: national | regional | all
• week_start: string (The week shown; NULL before the first week with per-surface counts)
• weeks: array of string (Weeks available, newest first)
• surfaces: array of object (Per surface of the panel, by weight as in /models, then any other surface measured that week)
  • model_id: string
  • asked: integer (Cells measured: every question asked on this surface, including those where the surface showed no AI answer or the call failed (the denominator of the public sources page))
  • answers: integer (Cells with an AI answer)
  • cited_answers: integer (Answers citing at least one source)
• types: array of object (Every domain of the week folded by type: all nine types, each with every surface)
  • type: portal | social | community | directory | shopping | media | reference | public | other
  • by_model: array of object (One entry per surface, zeros included. responses counts an answer once however many sites of the type it cites, so it can be less than the sum of the type's domains)
    • model_id: string
    • responses: integer (Distinct answers of this surface that cited it in the week)
    • questions: integer (Questions those answers belong to)
    • answers: integer (Answers this surface gave in the week (an AI answer was there): the denominator of the share)
• domains: array of object (Most cited first, limit of them)
  • domain: string
  • type: portal | social | community | directory | shopping | media | reference | public | other
  • responses: integer (Distinct answers that cited this domain)
  • questions: integer
  • by_model: array of object (One entry per surface, in surfaces order, zeros included)
    • model_id: string
    • responses: integer (Distinct answers of this surface that cited it in the week)
    • questions: integer (Questions those answers belong to)
    • answers: integer (Answers this surface gave in the week (an AI answer was there): the denominator of the share)

Statuses: 200, 304, 400, 401, 403, 429, 503.

curl -H "Authorization: Bearer $GENRANK_API_KEY" "https://www.genrank.com/api/v2/sources?language=ko"

GET /models

The panel in effect for an index: each surface's weight (0 to 1) and since when it has held it, then the surfaces that left

Response ModelsResponse:

• meta: object
• models: array of object
  • model_id: string
  • name: string
  • provider: string
  • weight: number
  • effective_from: string
  • web_search: boolean
  • collection: api | serp
• retired: array of object
  • model_id: string
  • name: string
  • provider: string
  • retired_at: string

Statuses: 200, 304, 400, 401, 403, 429, 503.

curl -H "Authorization: Bearer $GENRANK_API_KEY" "https://www.genrank.com/api/v2/models?language=ko"

GET /methodology

Current and next methodology version

Response MethodologyResponse:

• meta: object
• current: object
  • version: string
  • effective_from: string
• next: object
  • version: string
  • effective_from: string
  • announced: string
• changelog: array of object
  • version: string
  • date: string
  • summary: string
• question_rank_formula: string
• publish_gate: string
• url: string

Statuses: 200, 304, 400, 401, 403, 429, 503.

curl -H "Authorization: Bearer $GENRANK_API_KEY" "https://www.genrank.com/api/v2/methodology?language=ko"

GET /regions

Regions and the (leaf, region) pairs measured in each, with the publish gate of each pair

Response RegionsResponse:

• meta: object
• regions: array of object
  • id: string
  • slug: string
  • level: sido | sigungu | district
  • parent_id: string
  • name_ko: string
  • name_en: string
  • aliases: array of string
  • leaves: array of object
    • key: string
    • published: boolean
    • weeks_measured: integer

Statuses: 200, 304, 400, 401, 403, 429, 503.

curl -H "Authorization: Bearer $GENRANK_API_KEY" "https://www.genrank.com/api/v2/regions?language=ko"

GET /runs

Run status per week

Response RunsResponse:

• meta: object
• runs: array of object
  • id: string
  • week_start: string (Sunday (KST) that starts a GenRank week, YYYY-MM-DD)
  • scope: national | regional
  • language: ko | en (NULL for runs that covered every language (all runs before v4.0))
  • trigger_type: string
  • status: running | completed | failed
  • questions_total: integer
  • questions_completed: integer
  • started_at: string
  • completed_at: string
  • routes: object
    • batch: integer
    • direct: integer
    • openrouter: integer

Statuses: 200, 304, 400, 401, 403, 429, 503.

curl -H "Authorization: Bearer $GENRANK_API_KEY" "https://www.genrank.com/api/v2/runs?language=ko"

Authentication

Every route needs Authorization: Bearer grk_…. Keys are issued by GenRank staff on application (https://www.genrank.com/en-us/data) and shown once. A key may carry an expiry date and an allowlist of addresses; a revoked, expired or disallowed key answers 401 or 403 within 60 seconds on every server. Keys are rotated from the admin side: the new key inherits every setting and the old one keeps working for 7 days.

Call the API from a server. There are no CORS headers, so a browser cannot call it directly, and a key placed in a page would be public.

Limits and quotas

Each key has a per-minute limit and, optionally, a daily quota (the day is the KST calendar day). Every response carries:

The counters are shared across servers. Requests refused with 429 count towards the minute; refusals by a server's own first-stage limiter may not count towards the daily quota. A burst above the limit returns 429 RATE_LIMITED; an exhausted quota returns 429 QUOTA_EXCEEDED with Retry-After counting down to midnight KST.

Caching and freshness

Responses are Cache-Control: private, max-age=60 with Vary: Authorization and a strong ETag. Send If-None-Match with the last ETag to receive 304 when nothing changed; the ETag ignores meta.generated_at, so it is stable between runs.

The server caches each answer for 5 minutes (/runs: 60 seconds) and drops its cache when a run completes. To follow the index: poll /runs?language=ko and refetch what you show when a week flips to completed. The Korean index is measured weekly (national and regional runs), the English index monthly.

Errors

The body is always { "error": "<message>", "code": "<CODE>" }.

A 301 on an entity route means the entity was merged: the body carries redirected_to: { id, slug } and Location points at the keeper. Store the new id.

Conventions

• One language per index. language is required on every data route (/methodology defaults to ko). Entities, questions and rankings never mix across languages.
• Weeks. A GenRank week starts Sunday 00:00 KST. week parameters and week_start fields are that Sunday as YYYY-MM-DD.
• Methodology version. Every ranking row and every meta carries methodology_version. Rows of different major versions (3.x and 4.x) are not comparable; minor versions are. History responses give the version per week so a chart can break the line where the major version changes.
• Scores and ranks. rank is the integer position. score is the unbounded weighted sum behind it; compare it within one category and one week only. The API publishes counts (answers, mentions, trials), never derived shares.
• Identifiers. Entities and questions have a stable slug and an id; categories have a key. model_id is the provider's model identifier (for example openai/gpt-5.6-luna), listed by /models. Merged entity ids answer 301, removed ones 410; a retired question keeps answering with status: retired and replaced_by.
• Regional index (Korean). /regions lists regions and the (leaf, region) pairs measured in each, with their publish gate. Regional questions have their own slugs ({leaf}--{region}) and regional entities their own ids with region_id and, when known, parent_entity_id (the national brand). Pass region_id to scope a question or entity route to that region; category rankings, history, graph and matrix are national and refuse it.
• Windows. cells_4w, the matrix, the graph and co-mentions cover the last four kept weeks; window in the response says which.
• Pagination. List routes take limit and offset and return total. Bounds are in the parameter tables below.

Licence and attribution

GenRank Data (published rankings, scores and API responses) is free for lookup, research, journalism, education and internal business analysis under the Terms of Service, section 3 (https://www.genrank.com/en-us/terms#data-license): cite "GenRank (www.genrank.com)" with the edition date and methodology version; do not present altered, re-weighted, partial or out-of-date data as GenRank's findings, and do not imply that GenRank endorses a brand; wholesale copying, resale or embedding in a paid product needs a written licence. Attribution line: "Source: GenRank, {category} AI Visibility Index, edition {date}" with a link to the page.

Matching endpoints

• How they decide. /classify and /categories/{key}/competitors narrow by meaning first (vectors of GenRank's categories and ranked entities), then a judge model chooses among the few left and gives probabilities. /classify also gives the judge up to ten categories whose name holds a word of offering or site_text (the closest of them by meaning, leaving out parents and children of the nearest), so a business that sells to another industry, such as marketing for clinics, still meets its own category; categories[].source says which way each one came. If the judge does not answer in time the order is by similarity only and judged_by is vector. classifier_version and relevance_version name the models; store them with what you keep. The same input gives the same answer for 24 hours.
• Website lookup. Most entities have no stored website. /entities/resolve then ranks the entities named in answers that cited the site by how much the site name sounds like theirs (match: likely when one clearly fits). A platform page (a Naver Place, a Kakao Map place, an Instagram account, a Naver blog) is matched as a page: the entities named in answers that cited that page, ranked by how well the page title matches them (for a place the title is its own name, so most places resolve). The platform's own address, or a page no answer cited, answers match: platform; short links are not followed. A site no answer cited falls back to names that sound like it (match: sound, never likely unless the names are nearly identical). Send the names the site gives itself as name (repeatable, up to 5): a site name that sounds like nothing (amc.seoul.kr) still resolves when one entity cited with it carries one of those names (name_match: true), and a name two such entities share leaves match: candidates. When no cited entity carries one, brands and businesses with one of those names are looked up in the whole index (match: sound, name_similarity: 1); one is likely when the address is written in its names (starbucks.co.kr and Starbucks) or a judge model reads the site as its official site, since two businesses can share a name. Sites that are looked up are judged daily, and a confirmed website is stored, after which the lookup answers match: website.
• Mention checks. POST /extract takes one answer (question, answer, citations, tracked) or up to 20 in items, all read at once, and answers in the request: one answer usually takes 2 to 4 seconds, and a call that cannot be judged within 20 seconds answers 503. Each answer is read by the extractor GenRank uses on its own answers (extractor_version); the result gives, per answer, the recommended names in order, per tracked brand whether and where it was named, and per citation its source type and the tracked brand it belongs to, if any. A brand named only as a source or in a refusal does not count. rank is the position in the answer as GenRank's weekly data records it: an integer from 1; items the answer puts at the same position share it, and an item left out (a source, a generic term) leaves its gap. A cited page is a tracked brand's when it is on the homepage you send, on the website GenRank stored for its entity_id, or when the website lookup gives the page to that entity (a Naver blog of the brand is type: portal with its tracked_index). A call identical to one the same key sent before (language, question, answer, citations and tracked brands) gets the stored result back, for as long as the record is kept; the same answer with other tracked brands is not read again. A new extractor_version is announced in this changelog; judge stored answers again when it changes. If any answer of a call cannot be read the whole call answers 503 with Retry-After and nothing is judged; never store a guess in its place. Keys are capped at 2,000 answers per KST day unless issued without a cap (429 QUOTA_EXCEEDED beyond).
• Competitors. For each ranked entity of the category, the judge model asks whether customers in the index's market (Korea for language=ko) compare it with the brand when buying: the same buyers and use, including a broader product that covers the use; a product not sold in that market or not offered in its language does not count. mentions and trials are the totals of the entity's /categories/{key}/matrix row over window. co_mentions counts the answers over the same window that named both the entity and the entity_id brand; it is null without entity_id and in a category above the leaves (co-mentions are kept per leaf), and there is no number to show then.
• Sources per surface. /categories/{key}/citations and /sources give counts per surface: answers (the surface's answers that week) beside the answers citing each domain and each source type, so a share is responses / answers. A type counts an answer once however many of its sites the answer cites. asked also counts the cells where the surface showed no AI answer or the call failed; the public sources page divides by it. /sources adds national and regional questions together unless scope says otherwise.
• Suggestions. POST /entities/suggest records a brand GenRank lacks and answers exists with the entity when the site already belongs to one. A suggestion never adds a brand to a ranking: GenRank asks questions, and an entity appears only when AI answers name it.
• Nothing you send changes the index. Results go back to you; no score, ranking or entity is changed by what an API user sends.

Request records

Every request made with a key is recorded: the path, the query parameters and the JSON body, with the key, the time and a daily-salted hash of the address. GenRank uses the records to run and improve the API and to find categories and questions the index does not cover; they never enter a score or a ranking, are not passed to anyone, and are deleted after 12 months, together with suggestions and the answers sent to /extract with their judgments (https://www.genrank.com/en-us/governance#operator, https://www.genrank.com/en-us/privacy).

Changelog

• 2026-11-10, 2.7.0. GET /entities/resolve looks a name up in the whole index. When name is sent, no entity named in answers that cited the site has one of the names, and the site alone gives no likely owner, the brands and businesses with one of the names as their name or alias (compared as in 2.5.0) join the candidates with match sound, name_similarity 1 and confidence 0.8. Products, people, works, places, kinds of thing and branches are not looked up. One of them is likely when the site address is written in its names: the registrable name is a Latin name of the entity (starbucks.co.kr and Starbucks) or the host is one of its aliases (wtable.co.kr). Failing that, a judge model reads whether the site is the official site of each one found (from the address and the entity, not the names sent), and one it accepts is likely. Two businesses can share a name (a meat processor and a Bible app share one Korean name), so a name with neither tie stays a candidate, as it does when the judge is unavailable; one national entity still wins over regional ones of the same name. Large brands are named in answers that cite news and shops, rarely their own site, so they used to answer none or a sub-brand. Nothing changes without name, on a platform's address, or when the site already resolves; a name sent never stores a website.
• 2026-11-08, 2.6.0. Sources per surface. GET /categories/{key}/citations adds answers (per surface: cells asked, answers, answers citing a source), types (all nine source types folded over every domain of the week, not cut by limit, each with every surface) and by_model on each domain (answers and questions per surface, zeros included); type is now one of the nine types. New GET /sources gives the same for the whole index, the figures of the public sources page, with scope all (default), national or regional. A share is responses / answers; a type counts an answer once however many of its sites the answer cites. Weeks kept before 18 October 2026 have no per-surface counts. GET /categories/{key}/matrix takes pin (repeatable, up to 5): those entities are rows whatever their rank, marked pinned, with rank null when not ranked in the category. Competitors: co_mentions counts the same four weeks as mentions and trials; it is null without entity_id and in a category above the leaves, where it used to read 0.
• 2026-11-07, 2.5.0. GET /entities/resolve takes name: the name the site gives itself, repeatable up to 5 times, 100 characters each, the main one first. When exactly one entity named in answers that cited the site has one of them as its name or alias (compared without case, spaces or punctuation), match is likely and that entity comes first with name_similarity 1; when several do, match is candidates. One national entity wins over regional entities of the same name, since a website belongs to no region. On a platform's own address the candidates stay the entities named like the platform, and name only picks among them (musinsa.com with the name of the store, not of its own label). Without name the answer is unchanged. A site name that sounds like no entity (amc.seoul.kr for Asan Medical Center) used to answer candidates with an unrelated entity first. Each candidate adds name_match. A stored website now stays the first candidate when another entity also reaches confidence 1.
• 2026-11-05, 2.4.0. From 15 November 2026 00:00 KST, POST /extract reads answers with the extractor of methodology 4.3: GPT-6 Luna at reasoning effort low instead of Gemini 2.5 Flash, which Google retires on 1 December 2026. extractor_version becomes genrank-extract/openai/gpt-6-luna/2026-11-15.1; results stored under 2026-10-28.3 are read again, not reused. Names come back as the answer writes them (a Korean answer gives Korean names; translations go to aliases), and generic phrases the old extractor returned as recommendations (a type of clinic, a kind of photo) now come back with role generic or not at all. A reading takes about 3 seconds for one answer (median of 20, slowest 9). The judge behind the GenRank index changes the same day (GPT-6.1 Sol); /classify, /competitors and /entities/resolve keep their models.
• 2026-11-02, 2.3.2. POST /classify also gives the judge up to ten categories whose name holds a word of offering or site_text, besides the twelve nearest by meaning (not a parent or child of one of them). A business that sells to another industry (marketing for clinics, tax services for academies) had its meaning pulled toward its customers' industry, so its own category was never among the choices and none_probability came out high. Each of categories[] adds source: vector or name. classifier_version is 2026-11-02.1; answers stored under 2026-10-28.2 may differ.
• 2026-10-28, 2.3.1. Cited links are read as the pages they stand for. Google AI Mode writes the links in its answers as google.com/goto redirects, and Google cites English pages through Google Translate; both were counted as google.com. Redirects are now opened before an answer is stored, translated pages count as the page, Google Maps and Shopping pages on google.com count as maps.google.com (directory) and shopping.google.com (shopping), and Google place cards, which list the businesses an answer names, are not counted as citations under any address. The stored answers of the weeks of 18 and 25 October and their source statistics were corrected. POST /extract does the same with the citations you send (citations[].domain is the page cited; a redirect it cannot open gives domain null and type other); extractor_version is genrank-extract/google/gemini-2.5-flash/2026-10-28.3, so results stored under 2026-10-28.2 are judged again.
• 2026-10-28, 2.3.0. POST /extract answers in the request: 200 with the judgment of every answer, or 503 with Retry-After when any answer could not be read within 20 seconds (nothing is judged then). Up to 20 answers per call, read at once. The 202 response, job_id and GET /extract/{id} are removed. extractor_version is genrank-extract/google/gemini-2.5-flash/2026-10-28.2. Each result adds citations[]: per citation sent, its GenRank source type and, when the page is a tracked brand's own site or platform page, tracked_index; tracked[] takes an optional homepage. A call identical to an earlier one from the same key gets the stored result. /categories/{key}/competitors judges whether customers in the index's market compare the two (for ko, Korean buyers; a product not sold there is not a competitor), and each competitor adds mentions and trials, the totals of its /categories/{key}/matrix row, with window. /entities/search no longer times out on common names (a query of two characters matches names and aliases that start with it), and a slow meaning lookup is skipped instead of failing the search.
• 2026-10-28, 2.2.1. /entities/resolve reads platform pages: a Naver Place (map.naver.com and m.place.naver.com forms alike), a Kakao Map place, an Instagram account, a Naver blog or a smartstore resolves to the entities named in answers that cited that page, ranked by how well the page title (for a place, its own name) matches them; site.title carries that title. A site no answer cited falls back to names that sound like it (match: sound). Short links (naver.me, bit.ly ...) answer platform. candidates[].match adds sound.
• 2026-10-28, 2.2.0. Matching endpoints that compute from what you send: GET /entities/resolve (which entity a website belongs to), POST /classify (which categories a brand competes in), POST /categories/{key}/competitors (a category ranked by relevance to one brand), POST /extract and GET /extract/{id} (mention checks with GenRank's extractor, judged in batches), POST /entities/suggest (record a brand GenRank lacks). /entities/search adds sound matches across Hangul and Latin spellings and meaning matches, and each result carries match { kind, score }; alias matches work again (the alias filter used a column that was never filled), and domain search no longer times out. Every keyed request is now recorded with its parameters and body for 12 months (see Request records).
• 2026-10-28, 2.1.2. citations[].type is classified with the current source rules for every week (it was the reading stored at collection time). Review, listing and booking platforms such as place.naver.com, hwahae.co.kr and glowpick.com are now directory instead of other, and the most specific host wins (play.google.com is directory, not portal). The set of values is unchanged.
• 2026-10-28, 2.1.1. /models reads the panel each index is scored with: language=ko lists the eight Korean surfaces with their weights (it listed the English panel's weights and 0 for the Korean surfaces); effective_from is when the surface took its current weight; collection is serp for search-page surfaces; scope=regional lists the Korean regional panel; retired lists the surfaces the index stopped measuring.
• 2026-10-28, 2.1.0. Category endpoints (/categories, /categories/{key}, rankings, history, graph, matrix); entity history, graph and overview; /regions and /runs?scope=regional populated; region_id honoured on question and entity routes, with 400 UNKNOWN_REGION for an unknown id; entity.region and entity.parent widened from null to objects; daily quotas, X-Quota-* headers and 503 UNAVAILABLE; keys with expiry, rotation and IP allowlists. The v1 routes under /api answer 410.
• 2026-10-20, 2.0.0. First release of the read API v2.

Contact

hello@genrank.com. Corrections are free and published (https://www.genrank.com/en-us/governance#corrections).

API version 2.7.0.