Games

Use the request without metrics for storefront listings. Request metrics separately only when you need analytics. Use the single-game query for a game page.

Load published games

Execution context: platform server. Send Content-Type, X-Game-Platform-Api-Key, and X-Game-Platform-ID. The API key must remain on the server. This query supports a maximum limit of 25.

query PublishedGames($input: FetchGamesOnGamePlatformInput!, $lang: Lang) {
    result: FetchGamesOnGamePlatform(input: $input) {
        __typename
        ... on Problem {
            message
        }
        ... on GameViewsList {
            count
            items {
                id
                name(lang: $lang)
                icon(lang: $lang)
                platformUrl(lang: $lang)
                rating
            }
        }
    }
}

Variables:

{
    "lang": "EN",
    "input": {
        "gamePlatformId": 42,
        "isPublished": true,
        "withMetrics": false,
        "limit": 25,
        "offset": 0
    }
}

Successful response:

{
    "data": {
        "result": {
            "__typename": "GameViewsList",
            "count": 1,
            "items": [
                {
                    "id": 101,
                    "name": "Example Game",
                    "icon": "https://cdn.example.com/game.webp",
                    "platformUrl": "https://games.example.com/game/example-game",
                    "rating": 8.4
                }
            ]
        }
    }
}

Increase offset by limit for the next page. In GameViewsList, count is the number of items in the current response, not the total number of matching games. Stop when items.length is less than limit.

To search the catalogue, add filter.searchFilter:

{
    "lang": "EN",
    "input": {
        "gamePlatformId": 42,
        "isPublished": true,
        "withMetrics": false,
        "limit": 25,
        "offset": 0,
        "filter": {
            "searchFilter": {
                "search": "racing",
                "withDescriptions": true,
                "withTags": true,
                "withCategories": true,
                "withKeyWords": true,
                "lang": "EN"
            }
        }
    }
}

You can also pass orientation, targetOS, sort, and project-information filters defined by your site requirements.

Load games with metrics

Execution context: platform server. Send Content-Type, X-Game-Platform-Api-Key, and X-Game-Platform-ID. The API key must remain on the server. This query supports a maximum limit of 25.

Resource-intensive operation

withMetrics: true adds retrieval and aggregation of precomputed statistics for every game. This operation is resource-intensive and is intended primarily for analytics rather than real-time storefront rendering. Use the request without metrics to display games. If metrics are needed in the interface, request them from your server and cache the result; do not run this query on every page load.

Statistics and game-feature filters can also require additional metrics processing. Use them only when necessary and cache the result.

query GamesWithMetrics($input: FetchGamesOnGamePlatformInput!, $lang: Lang) {
    result: FetchGamesOnGamePlatform(input: $input) {
        __typename
        ... on Problem {
            message
        }
        ... on GameViewsWithMetricsList {
            count
            items {
                game {
                    id
                    name(lang: $lang)
                    icon(lang: $lang)
                    platformUrl(lang: $lang)
                    rating
                }
                platformMetrics {
                    mau
                    dau
                    wau
                    averageOnline
                    playtime
                    retention1d
                    retention7d
                    retention30d
                    arppu
                    payingPlayersPercent
                }
                totalMetrics {
                    mau
                    dau
                    wau
                }
            }
        }
    }
}

Variables:

{
    "lang": "EN",
    "input": {
        "gamePlatformId": 42,
        "isPublished": true,
        "withMetrics": true,
        "limit": 25,
        "offset": 0
    }
}

Successful response:

{
    "data": {
        "result": {
            "__typename": "GameViewsWithMetricsList",
            "count": 1,
            "items": [
                {
                    "game": {
                        "id": 101,
                        "name": "Example Game",
                        "icon": "https://cdn.example.com/game.webp",
                        "platformUrl": "https://games.example.com/game/example-game",
                        "rating": 8.4
                    },
                    "platformMetrics": {
                        "mau": 12000,
                        "dau": 1800,
                        "wau": 5400,
                        "averageOnline": 130.5,
                        "playtime": 18.2,
                        "retention1d": 0.314,
                        "retention7d": 0.128,
                        "retention30d": 0.041,
                        "arppu": 6.2,
                        "payingPlayersPercent": 1.7
                    },
                    "totalMetrics": {
                        "mau": 48000,
                        "dau": 7100,
                        "wau": 22000
                    }
                }
            ]
        }
    }
}

platformMetrics contains the game's metrics on the current white-label platform. totalMetrics contains the source project's combined metrics across all of its platforms.

Field	Meaning
dau, wau, mau	Active players for the daily, weekly, and monthly periods.
averageOnline	Average concurrent players.
playtime	Average in-game time per player, in seconds.
retention1d, retention7d, retention30d	Player retention after 1, 7, and 30 days as a ratio from 0 to 1.
arppu	Average revenue per paying player, in RUB.
payingPlayersPercent	Percentage of platform players who made a purchase, from 0 to 100.

The API returns precomputed statistics rather than real-time counters. Do not recompute them from catalogue data. Convert ratios or seconds only in the presentation layer when your interface needs percentages or human-readable durations.

Load a game page

Execution context: browser or platform server. In the browser send Content-Type, X-Game-Platform-ID, matching Origin, and credentials: 'include'; no API key is required or allowed in public code.

query GamePage($input: FetchGameOnGamePlatformInput!, $lang: Lang) {
    result: FetchGameOnGamePlatform(input: $input) {
        __typename
        ... on Problem {
            message
        }
        ... on GameView {
            id
            projectId
            provider
            name(lang: $lang)
            description(lang: $lang)
            fullDescription(lang: $lang)
            aboutDescription(lang: $lang)
            howToPlayDescription(lang: $lang)
            developerName(lang: $lang)
            icon(lang: $lang)
            cover(lang: $lang)
            albumScreenshots(lang: $lang)
            platformUrl(lang: $lang)
            url
            categories
            tags
            ageRestrictions
            targetOS
            rating
            playersCount
            seoSettings {
                ogTitle(lang: $lang)
                ogDescription(lang: $lang)
                ogImage(lang: $lang)
            }
        }
    }
}

Variables:

{
    "lang": "EN",
    "input": {
        "gamePlatformId": 42,
        "gameId": 101
    }
}

Successful response shape:

{
    "data": {
        "result": {
            "__typename": "GameView",
            "id": 101,
            "projectId": 501,
            "provider": "GAMEPUSH",
            "name": "Example Game",
            "categories": ["arcade"],
            "tags": ["popular"],
            "targetOS": ["Desktop", "Android"],
            "rating": 8.4,
            "playersCount": 3200
        }
    }
}

Use url as the game iframe source and platformUrl as the public site route. Render only content returned for the requested language, and handle Problem as a not-found or unavailable game state.