Get Cheap Games Meta API

openapi: 3.2.0
info:
  title: getcheapgames Meta API
  description: Game key price comparison. All money is integer cents; rankings are on the price each store lists, without the service fee a marketplace adds at checkout.
  version: 0.1.0
tags:
- name: Meta
paths:
  /api/trending:
    get:
      tags:
      - Meta
      summary: Trending
      description: 'The "Trending now" links the home page and the deals page show: the first

        `TRENDING_LINKS` priority games (gcg/services/priority.py), slug and title.

        The same list the crawler shell links, from the same memo.'
      operationId: trending_api_trending_get
      responses:
        '200':
          description: Successful Response
          content:
            application/json:
              schema:
                items:
                  additionalProperties:
                    type: string
                  type: object
                type: array
                title: Response Trending Api Trending Get
  /sitemap-priority.xml:
    get:
      tags:
      - Meta
      summary: Sitemap Priority
      description: 'The games we most want crawled first, in the markets search comes from: at

        most 1,000 URLs, listed first in the index and in robots.txt.


        The product files list ~4M URLs between them, and Google crawls a slice:

        on 15 Oct 2026 the GTA VI page ("gta 6 price", 60.5k searches a month) was

        "unknown to Google", one entry among 25,060 in its tier''s file. This file

        is short enough to be read whole on every visit. Which games, and in what

        order, is gcg/services/priority.py; each is dated by when its prices last

        moved, the date the product files give it too.'
      operationId: sitemap_priority_sitemap_priority_xml_get
      responses:
        '200':
          description: Successful Response
          content:
            application/json:
              schema: {}
  /sitemap-top-{part}.xml:
    get:
      tags:
      - Meta
      summary: Sitemap Top
      description: 'The `TOP_GAMES` most wanted games (gcg/services/priority.py) in every

        market, cut into files of `SITEMAP_CHUNK`, the most wanted first.


        Listed in the index after the priority file, to be submitted in Search

        Console on their own so Google reports how many of these pages, the ones

        that sell, it has indexed. The tier files list the same pages among

        every other product; a URL in two sitemaps is read once.'
      operationId: sitemap_top_sitemap_top__part__xml_get
      parameters:
      - name: part
        in: path
        required: true
        schema:
          type: integer
          title: Part
      responses:
        '200':
          description: Successful Response
          content:
            application/json:
              schema: {}
        '422':
          description: Validation Error
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/HTTPValidationError'
  /sitemap.xml:
    get:
      tags:
      - Meta
      summary: Sitemap Index
      description: 'An INDEX, not a sitemap.


        The catalogue is ~35,000 products served to 40 markets, and every market is

        a real URL with its own price and its own language. As one file that is

        1.4 million entries — Google caps a sitemap at 50,000 URLs and 50 MB — so

        this lists one entry per market per chunk instead.


        A sitemap index may NOT point at another index, so every chunk of every

        market is listed here directly: the hubs (`sitemap-ie-1.xml`, ...), then

        each offered tier of products in its own series (`sitemap-ie-t1-1.xml`,

        ...; see gcg/services/sitemap_tiers.py), so Search Console reports how

        much of each tier is indexed. Tier 1 alone is about 20,000 products, one

        part per market, so 40 markets are 80 entries, nowhere near the 50,000 an

        index may hold.


        Each product part is dated by the newest `lastmod` it lists, read from the

        rows it is written from (`_part_lastmod`); a product''s date is the same in

        every market, so one reading dates all forty copies. A hub part has no

        date to give: its entries carry none (see `sitemap_chunk`).


        Counted from the same lists the parts are cut from (`_SITEMAP_MEMO`), so

        within an hour the index and the files it names agree exactly.'
      operationId: sitemap_index_sitemap_xml_get
      responses:
        '200':
          description: Successful Response
          content:
            application/json:
              schema: {}
  /sitemap-{code}-t{tier}-{part}.xml:
    get:
      tags:
      - Meta
      summary: Sitemap Tier Chunk
      description: 'One slice of one tier of one market''s products (gcg/services/sitemap_tiers.py).


        Declared before `sitemap_chunk`, whose `{code}` would otherwise take

        "ie-t1" for a market and answer 404. A tier not offered now has no file:

        the index does not name it, and the pages in it are not offered.


        Cut from the list built once for every market and part (`_products`), so

        a file is written from memory: the query behind it is the same for all

        forty markets, and it is only the prefix that differs.'
      operationId: sitemap_tier_chunk_sitemap__code__t_tier___part__xml_get
      parameters:
      - name: code
        in: path
        required: true
        schema:
          type: string
          title: Code
      - name: tier
        in: path
        required: true
        schema:
          type: integer
          title: Tier
      - name: part
        in: path
        required: true
        schema:
          type: integer
          title: Part
      responses:
        '200':
          description: Successful Response
          content:
            application/json:
              schema: {}
        '422':
          description: Validation Error
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/HTTPValidationError'
  /sitemap-{code}-{part}.xml:
    get:
      tags:
      - Meta
      summary: Sitemap Chunk
      description: 'One slice of one market''s hub pages: the static routes, every news post,

        publisher and series. `SITEMAP_CHUNK` at a time; the hubs were not chunked

        at all once, and part 1 reached 56.2 MB, past Google''s 50 MB cap, so it

        was rejected for every market.


        The products were the parts after these until 12 October 2026, and are

        each tier''s own series now (`sitemap_tier_chunk`): a number past the hubs

        names no file.'
      operationId: sitemap_chunk_sitemap__code___part__xml_get
      parameters:
      - name: code
        in: path
        required: true
        schema:
          type: string
          title: Code
      - name: part
        in: path
        required: true
        schema:
          type: integer
          title: Part
      responses:
        '200':
          description: Successful Response
          content:
            application/json:
              schema: {}
        '422':
          description: Validation Error
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/HTTPValidationError'
  /sitemap-{code}.xml:
    get:
      tags:
      - Meta
      summary: Sitemap For Country
      description: 'The pre-chunk URL, which Search Console may still have on file.


        A 404 here would be reported as a sitemap that stopped working. It is not

        equivalent to any one chunk, so it points at the index, which lists every

        chunk of every market.'
      operationId: sitemap_for_country_sitemap__code__xml_get
      parameters:
      - name: code
        in: path
        required: true
        schema:
          type: string
          title: Code
      responses:
        '200':
          description: Successful Response
          content:
            application/json:
              schema: {}
        '422':
          description: Validation Error
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/HTTPValidationError'
  /llms.txt:
    get:
      tags:
      - Meta
      summary: Llms Txt
      description: 'https://llmstxt.org — a curated map of the site for language models.


        Carries no prices, deliberately. On a price comparison site a stale number

        quoted back by an answer engine is worse than no number, so this points at

        where to read the live figure instead.


        Small on purpose: the guidance, the core pages and the most-reviewed games,

        then `/llms-full.txt` for every game we track.'
      operationId: llms_txt_llms_txt_get
      responses:
        '200':
          description: Successful Response
          content:
            text/plain:
              schema:
                type: string
  /llms-full.txt:
    get:
      tags:
      - Meta
      summary: Llms Full Txt
      description: llms.txt with every game we track, for a reader that wants the lot.
      operationId: llms_full_txt_llms_full_txt_get
      responses:
        '200':
          description: Successful Response
          content:
            text/plain:
              schema:
                type: string
  /robots.txt:
    get:
      tags:
      - Meta
      summary: Robots Txt
      description: 'The `/*/search` wildcard is load-bearing.


        Every real path is country-prefixed (`/gb/search?q=...`), and a `Disallow`

        is a PREFIX match from the start of the path — so the plain `/search` rule

        this shipped with matched nothing at all, and internal search was fully

        crawlable in all 39 markets. The page''s own `noindex` only exists once a

        crawler has executed the JavaScript, by which point the crawl has been paid

        for. The unprefixed rule is kept below for the bare form.


        The catalogue API is NOT disallowed, and must never be again. Google and

        Bing render the app, and a renderer honours robots.txt for every fetch the

        page makes: with `Disallow: /api/` every call the app renders from was

        refused, so the page they indexed had no title, no description, no

        canonical, no hreflang, no JSON-LD and no content — the shell''s tags are

        removed on boot (main.tsx) and nothing replaced them. Measured by loading

        the shell with /api/ refused: an empty page, against 1,073 words and 47

        links with it allowed. The JSON is kept out of the index by

        `X-Robots-Tag: noindex` instead (main.py), which a renderer still fetches

        past. Only the endpoints that are not reads stay disallowed: the affiliate

        redirect, the social callbacks, and search.


        `/api/games` is the one exception, and only because nothing a crawler

        renders needs it any more: the game page''s shell carries the game, its

        history, its reviews and its editions (`_game_data`), and the app reads

        them from there. Googlebot spent 54% of its 941K requests on that JSON in

        October 2026. Disallowed on 24 Oct 2026, after a Googlebot render of the

        live page was seen making no `/api/games` request at all.


        No `Allow: /` line. Everything is allowed by default, and a parser that

        takes the FIRST matching rule rather than the longest — Python''s own

        `robotparser`, and crawlers built on it — read the `Allow: /` that used to

        head this group as permission for every path, disallowed ones included.

        And no blank line inside the group: the original robots.txt convention

        ends a record at one, so to those parsers every rule after it belonged to

        no user-agent at all.'
      operationId: robots_txt_robots_txt_get
      responses:
        '200':
          description: Successful Response
          content:
            text/plain:
              schema:
                type: string
  /_meta/{full_path}:
    get:
      tags:
      - Meta
      summary: Crawler Shell
      description: 'The SPA shell with real metadata already in it, for clients that do not run

        JavaScript.


        Every tag this site needs is generated correctly — title, description,

        canonical, Open Graph, Twitter card, hreflang, Product JSON-LD — but React

        writes them after hydration, so a crawler that does not execute scripts

        receives 794 bytes of empty document. Google renders and eventually sees

        them; Facebook, WhatsApp, LinkedIn, Discord, Slack and X never do, which is

        why every share of this site is a bare grey card.


        Caddy sends only known crawler user-agents here. Browsers keep the static

        file, so this path cannot slow down or break a real visit — and a crawler

        that slips through unmatched is no worse off than it is today.


        Browsers do ask here for the file''s STATUS, though (`PROBE_HEADER`): since

        07 Nov 2026 Caddy serves them the static file with the status this answers

        a crawler — a 404 for a page that does not exist, a 301 where the address

        is not the page''s own — rather than a 200 for every address. That probe

        counts nothing, builds as little as it can, and when it is slow or fails

        Caddy serves the file at 200 as before, so a visit still cannot break.


        Product pages get their own title, price and cover. Everything else gets

        the site''s own identity, which is still infinitely better than nothing.'
      operationId: crawler_shell__meta__full_path__get
      parameters:
      - name: full_path
        in: path
        required: true
        schema:
          type: string
          title: Full Path
      responses:
        '200':
          description: Successful Response
          content:
            text/html:
              schema:
                type: string
        '422':
          description: Validation Error
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/HTTPValidationError'
  /health:
    get:
      tags:
      - Meta
      summary: Health
      operationId: health_health_get
      responses:
        '200':
          description: Successful Response
          content:
            application/json:
              schema:
                additionalProperties:
                  type: string
                type: object
                title: Response Health Health Get
components:
  schemas:
    HTTPValidationError:
      properties:
        detail:
          items:
            $ref: '#/components/schemas/ValidationError'
          type: array
          title: Detail
      type: object
      title: HTTPValidationError
    ValidationError:
      properties:
        loc:
          items:
            anyOf:
            - type: string
            - type: integer
          type: array
          title: Location
        msg:
          type: string
          title: Message
        type:
          type: string
          title: Error Type
        input:
          title: Input
        ctx:
          type: object
          title: Context
      type: object
      required:
      - loc
      - msg
      - type
      title: ValidationError