# EuroLeague & EuroCup Games, Box Scores, Players (`scrapermaster/euroleague-games-boxscores-players`) Actor

EuroLeague and EuroCup basketball data: schedules and scores, standings, player box scores per game, season player statistics and club info. Export to JSON, CSV or Excel.

- **URL**: https://apify.com/scrapermaster/euroleague-games-boxscores-players.md
- **Developed by:** [Scraper Master](https://apify.com/scrapermaster) (community)
- **Categories:** Sports, Automation
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.36 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## EuroLeague & EuroCup games, box scores and players

Pull structured basketball data for the EuroLeague and the EuroCup from the public Euroleague Basketball JSON API: fixtures and results, league tables, player-by-player box scores, rosters with season statistics, and club details. No login or API key is involved and only publicly available data is read.

### Modes

Choose one with the `mode` input. Every mode honors `maxItems`. If a request fails or an input does not match anything, the Actor writes a row with `"error": true` and a `message`, and carries on; those rows are not billed.

#### `schedule`

One row per game: round, date, teams, scores, quarter scores, venue, referees and status.

```json
{ "mode": "schedule", "competition": "E", "season": "2025", "round": 1, "status": "finished", "maxItems": 20 }
```

Optional filters: `round`, `teamCode`, `status` (`all` / `finished` / `scheduled`), `dateFrom`, `dateTo`.

#### `standings`

League table rows (one per club). Without `round` the latest round that has a published table is used.

```json
{ "mode": "standings", "competition": "E", "season": "2025", "round": 20 }
```

#### `boxscore`

One row per player per game, with team and game context. Pick games by `gameCodes`, or leave it empty and use `round`, `teamCode`, `dateFrom`, `dateTo` (finished games only, oldest first). Players with zero minutes are skipped unless `includeDidNotPlay` is true.

```json
{ "mode": "boxscore", "competition": "E", "season": "2025", "gameCodes": [1, 2], "maxItems": 100 }
```

#### `players`

Every rostered player of the season (optionally for one `teamCode`) with bio data and season statistics. `statsMode` is `accumulated` (season totals) or `perGame` (averages derived from the totals).

```json
{ "mode": "players", "competition": "U", "season": "2025", "teamCode": "BAS", "statsMode": "perGame" }
```

#### `teams`

One row per club taking part in the season: names, country, city, arena code, president, website, social handle, crest image.

```json
{ "mode": "teams", "competition": "E", "season": "2025" }
```

### Common inputs

| Field | Meaning |
|---|---|
| `competition` | `E` = EuroLeague, `U` = EuroCup |
| `season` | Start year, `2025` means 2025-26 (`E2025` also accepted) |
| `maxItems` | Cap on result rows (default 50) |
| `maxConcurrency` | 1 to 3 parallel box score requests (default 2) |

### Output fields

Every row carries `competition` and `season`.

| Mode | Fields |
|---|---|
| schedule | gameCode, gameId, round, roundName, phase, group, status, dateLocal, dateUtc, homeTeamCode, homeTeam, awayTeamCode, awayTeam, homeScore, awayScore, winnerCode, homeQuarters, awayQuarters, overtimePeriods, venue, venueCapacity, neutralVenue, attendance, referees |
| standings | round, group, phaseCode, position, teamCode, team, country, gamesPlayed, wins, losses, winPct, pointsFor, pointsAgainst, pointDifference, qualified |
| boxscore | gameCode, round, phase, dateLocal, homeTeam, awayTeam, homeScore, awayScore, teamCode, team, opponentCode, opponent, isHome, playerCode, playerName, jersey, position, starter, played, minutes, minutesText, points, fieldGoalsMade/Attempted/Pct, twoPointsMade/Attempted, threePointsMade/Attempted/Pct, freeThrowsMade/Attempted/Pct, offensiveRebounds, defensiveRebounds, totalRebounds, assists, steals, blocks, blocksAgainst, turnovers, foulsCommitted, foulsDrawn, plusMinus, valuation |
| players | playerCode, name, teamCode, team, jersey, position, heightCm, weightKg, birthDate, age, country, active, photoUrl, statsMode, gamesPlayed, gamesStarted, minutes, points, two/three-point and free-throw made/attempted/pct, rebounds, assists, steals, blocks, turnovers, foulsCommitted, foulsDrawn, valuation |
| teams | teamCode, name, shortName, editorialName, tvCode, country, city, address, venueCode, president, phone, website, ticketsUrl, twitter, crestUrl |
| error rows | error (true), mode, message, plus gameCode or round when relevant |

`valuation` is the official performance index rating (PIR). Field-goal figures in box scores are totals (twos plus threes); `blocks` are shots the player blocked, `blocksAgainst` shots of his that were blocked.

### Notes and limitations

- Round numbers run through the whole season (regular season, playoffs, Final Four), so playoff games have rounds above the regular-season count.
- Box scores exist only for games that have been played. Early-season or very recent games may be missing until the league publishes them.
- Season statistics in `players` mode come from the league's season totals; players who changed clubs may show the combined line on their listed club.
- Standings tables are published per round; an unplayed round returns an error row.
- Requests are throttled (at most 3 at once, small random pauses, retries with backoff on rate limits and server errors). Data belongs to its publisher and is provided as found.

# Actor input Schema

## `mode` (type: `string`):

What to extract: game schedule/results, standings table, per-player box scores, player directory with season stats, or club info.

## `competition` (type: `string`):

EuroLeague (E) or EuroCup (U).

## `season` (type: `string`):

Year in which the season starts, e.g. 2025 for 2025-26. A full code such as E2025 also works.

## `round` (type: `integer`):

Optional. Schedule/boxscore: only games of this round. Standings: table after this round (default: latest round with a published table). Round numbers run continuously through the season, playoffs and Final Four included.

## `teamCode` (type: `string`):

Optional three-letter club code (e.g. OLY, MAD, BAR, PAN). Filters schedule games, boxscore games and players. Run the Teams mode to list codes.

## `status` (type: `string`):

Schedule mode only: show all games, only finished ones, or only upcoming ones.

## `dateFrom` (type: `string`):

Optional, YYYY-MM-DD. Only games on or after this local date (schedule and boxscore modes).

## `dateTo` (type: `string`):

Optional, YYYY-MM-DD. Only games on or before this local date (schedule and boxscore modes).

## `gameCodes` (type: `array`):

Boxscore mode: specific game numbers within the season (see gameCode in Schedule results). If empty, the round / team / date filters pick the finished games.

## `includeDidNotPlay` (type: `boolean`):

Boxscore mode: also output roster players with zero minutes.

## `statsMode` (type: `string`):

Players mode: season totals or per-game averages.

## `maxItems` (type: `integer`):

Maximum number of result rows to output.

## `maxConcurrency` (type: `integer`):

Parallel box score requests (1-3). Kept low on purpose to be polite to the public API.

## Actor input object example

```json
{
  "mode": "schedule",
  "competition": "E",
  "season": "2025",
  "status": "all",
  "includeDidNotPlay": false,
  "statsMode": "accumulated",
  "maxItems": 50,
  "maxConcurrency": 2
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "season": "2025",
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapermaster/euroleague-games-boxscores-players").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "season": "2025",
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("scrapermaster/euroleague-games-boxscores-players").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "season": "2025",
  "maxItems": 50
}' |
apify call scrapermaster/euroleague-games-boxscores-players --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapermaster/euroleague-games-boxscores-players"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/hUZ5zS00QBedSZtw9/builds/86HM8lpHKLCkiTGnP/openapi.json