---
id: api-menu
title: menu Method — Sports Line Menu
description: Reference for the MENU method, which returns the available hierarchy of sports, countries, and tournaments.
version: v1
language: en
---

# `menu` Method — Sports Line Menu

## Purpose

The `menu` method returns the hierarchy of the available sports line:

```text
sport → country → tournament
```

Each level also includes the number of available matches. Use this method to build a
website menu and obtain the identifiers required to request match lists.

The `menu` response does not contain matches or odds. Use the `events` method to
retrieve them.

## Request

```http
GET https://YOUR_API_DOMAIN/v1/menu/{type}/{lang}
```

Send the API key in the HTTP header:

```http
Package: YOUR_API_KEY
```

### Path Parameters

| Parameter | Type | Required | Description |
|---|---|---:|---|
| `type` | string | yes | Sports line type: `live` or `line` |
| `lang` | string | yes | Language of names. It must be supported by the API and included in the client's subscription |

Values of `type`:

| Value | Data returned |
|---|---|
| `live` | Menu of matches available in Live |
| `line` | Menu of upcoming Prematch matches |

### Optional Query Parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `cybersport` | boolean | `false` | Switches the method to the esports menu |

Query parameters are added after `?`. For example:

```http
GET https://YOUR_API_DOMAIN/v1/menu/live/en?cybersport=true
```

The full responses stored with this documentation were retrieved without query
parameters, which means `cybersport=false`.

## Live Request Example

```bash
curl --request GET \
  --url 'https://YOUR_API_DOMAIN/v1/menu/live/en' \
  --header 'Package: YOUR_API_KEY'
```

For Prematch, replace `live` with `line`:

```bash
curl --request GET \
  --url 'https://YOUR_API_DOMAIN/v1/menu/line/en' \
  --header 'Package: YOUR_API_KEY'
```

## Shortened Live Response Example

The following is an excerpt from a real English response. The values are unchanged,
but the arrays have been shortened to one sport, one country, and one tournament.

```json
{
  "status": 1,
  "page": "/v1/menu",
  "body": [
    {
      "id": 1,
      "name": "Football",
      "counter": 56,
      "sub": [
        {
          "id": 208,
          "name": "Sri Lanka",
          "counter": 1,
          "sport_id": 1,
          "sub": [
            {
              "id": 2217395,
              "name": "Sri Lanka. Super League",
              "counter": 1,
              "sport_id": 1,
              "countryId": 208
            }
          ]
        }
      ]
    }
  ]
}
```

## Shortened Prematch Response Example

This excerpt also comes from a real English response. The arrays have been shortened.

```json
{
  "status": 1,
  "page": "/v1/menu",
  "body": [
    {
      "id": 1,
      "name": "Football",
      "counter": 2573,
      "sub": [
        {
          "id": 4,
          "name": "Australia",
          "counter": 104,
          "sport_id": 1,
          "sub": [
            {
              "id": 149213,
              "name": "Australia Cup",
              "counter": 2,
              "sport_id": 1,
              "countryId": 4
            }
          ]
        }
      ]
    }
  ]
}
```

Match counts change continuously. The `counter` values above represent the sports line
only at the time the responses were retrieved.

## Top-level Response Fields

| Field | Type | Description |
|---|---|---|
| `status` | number | Request status. A successful response returns `1` |
| `page` | string | Method name. `menu` returns `/v1/menu` |
| `body` | array | Array of available sports |

## Sport Fields

Each top-level object in the `body` array describes one sport.

| Field | Type | Description |
|---|---|---|
| `id` | number | Sport ID. Used as `sportId` in other method URLs |
| `name` | string | Sport name in the language specified by `lang` |
| `counter` | number | Total number of available matches for this sport |
| `sub` | array | Countries with available matches for this sport |

## Country Fields

Each object in `body[].sub` describes one country.

| Field | Type | Description |
|---|---|---|
| `id` | number | Country ID. Used as `countryId` in other method URLs |
| `name` | string | Country name in the language specified by `lang` |
| `counter` | number | Number of available matches across all tournaments in this country |
| `sport_id` | number | ID of the sport associated with the country |
| `sub` | array | Available tournaments in this country |

## Tournament Fields

Each object in `body[].sub[].sub` describes one tournament.

| Field | Type | Description |
|---|---|---|
| `id` | number | Tournament ID. Used as `tournamentId` in other method URLs |
| `name` | string | Tournament name in the language specified by `lang`. The API may occasionally return an empty string |
| `counter` | number | Number of available matches in this tournament |
| `sport_id` | number | ID of the sport associated with the tournament |
| `countryId` | number | ID of the country associated with the tournament |

Pay attention to the exact JSON field names:

- the sport ID in a country object is named `sport_id`;
- the country ID in a tournament object is named `countryId`, with an uppercase `I`.

Do not replace `countryId` with `country_id` when parsing the response.

## Ready-to-use Icons

You can use standard SportAPI icons for sports, countries, and tournaments. Take the
required ID from the `menu` response and insert it into the corresponding URL.

### Sport Icon

Use the sport `id` from `body[].id`:

```text
https://cdn.sportapi.net/sports/v1/color/{sportId}.webp
```

Example for a sport with `id: 1`:

[https://cdn.sportapi.net/sports/v1/color/1.webp](https://cdn.sportapi.net/sports/v1/color/1.webp)

### Country Icon

Use the country `id` from `body[].sub[].id`:

```text
https://cdn.sportapi.net/flags/v1/color/{countryId}.webp
```

Example for a country with `id: 218`:

[https://cdn.sportapi.net/flags/v1/color/218.webp](https://cdn.sportapi.net/flags/v1/color/218.webp)

### Tournament Icon

Use the tournament `id` from `body[].sub[].sub[].id`:

```text
https://cdn.sportapi.net/tournaments/v1/color/{tournamentId}.webp
```

Example for a tournament with `id: 118737`:

[https://cdn.sportapi.net/tournaments/v1/color/118737.webp](https://cdn.sportapi.net/tournaments/v1/color/118737.webp)

## Understanding `counter`

The `counter` field represents the number of matches available for the selected line
type at the time of the response:

- for a tournament — the number of matches in that tournament;
- for a country — the number of matches across all its tournaments;
- for a sport — the number of matches across all its countries and tournaments.

In the saved responses, the sum of child `counter` values matches the parent object's
`counter`. This value is dynamic and may change with the next request.

## Important Considerations

### Request Live and Prematch Separately

Both line types use the same response structure but contain different sets of sports,
countries, and tournaments. Use `type=live` for the Live menu and `type=line` for
Prematch.

### Empty Tournament Names

The tournament `name` field may contain an empty string. The saved English Live response
contained four such tournaments; the saved English Prematch response contained none.

The client interface must handle these entries correctly. For example, it can
temporarily display the tournament ID or omit the tournament until a name becomes
available. Do not invent a tournament name from other fields.

### Menu Contents Depend on Access

The API returns only data available to the supplied key. The available sports and
languages depend on the client's subscription.

## Snapshot of the English Responses

| Line type | Sports | Countries | Tournaments |
|---|---:|---:|---:|
| Live | 31 | 93 | 197 |
| Prematch (`line`) | 34 | 269 | 784 |

These figures describe specific responses retrieved on August 21, 2026. They are not a
permanent description of the API.

Full unabridged responses:

- [Live, Russian](../examples/json-responses/menu.live.ru.json)
- [Prematch, Russian](../examples/json-responses/menu.line.ru.json)
- [Live, English](../examples/json-responses/menu.live.en.json)
- [Prematch, English](../examples/json-responses/menu.line.en.json)

The files contain only API response bodies. No API key is stored in them.

## Using the Method

Typical workflow:

1. Request `menu` for the required line type and language.
2. Show the available sports from the `body` array.
3. After the user selects a sport, open the countries from its `sub` array.
4. After the user selects a country, open the tournaments from its `sub` array.
5. Pass the selected `sportId` and `tournamentId` to `events` to retrieve matches.
6. On the next menu update, account for sections and `counter` values having changed.

### Use Only Current IDs from the Menu

`menu` returns only sports, countries, and tournaments that currently have matches for
the selected line type. Do not store their IDs as a permanent list of available
sections.

If a tournament's only match ends or disappears, the tournament will no longer be
returned in the next response. If no other matches remain for the sport, the sport
itself will also disappear from the menu.

Before requesting `events`, verify that the selected `sportId` and `tournamentId` are
present in the current `menu` for the same `live` or `line` type.

## Update Frequency

Recommended request frequency for `menu`:

- Live — no more than once every 20 seconds;
- Prematch (`line`) — no more than once every 60 seconds.

See [Data Update Guidelines](../getting-started/update-guidelines.md) for more details.

Key, subscription, and parameter errors are documented in
[Error Handling](../getting-started/error-handling.md).
