# Olympedia Olympic Results Scraper (`maximedupre/olympedia`) Actor

Collect normalized Olympic event placements from public Olympedia result pages. Choose editions and sports, or submit exact event pages, then filter by country or medal status. Rows keep competitor, rank, medal, result, and source-published event context when available.

- **URL**: https://apify.com/maximedupre/olympedia.md
- **Developed by:** [Maxime Dupré](https://apify.com/maximedupre) (community)
- **Categories:** Sports, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.60 / 1,000 event placements

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

### 🏟️ Build Olympic placement datasets from Olympedia

For sports analysts, researchers, data journalists, and developers, Olympedia Olympic Results Scraper follows public Olympedia result pages and saves normalized rows for overall event placements. Each row keeps the published event, competitor, rank, medal, result, and source details together for analysis and data workflows.

- Build a table of placements from one public result page with **[Olympic Event Results](https://apify.com/maximedupre/olympedia/examples/olympic-event-results)**.
- Review placements from the 1988 edition with **[Olympedia 1988](https://apify.com/maximedupre/olympedia/examples/olympedia-1988)**.
- Filter returned placements to a country or NOC with **[Olympic Results By Country](https://apify.com/maximedupre/olympedia/examples/olympic-results-by-country)**.
- Compare placements for one sport across an edition with **[Olympic Results By Sport](https://apify.com/maximedupre/olympedia/examples/olympic-results-by-sport)**.
- Keep only podium placements with **[Olympic Medal Results](https://apify.com/maximedupre/olympedia/examples/olympic-medal-results)**.
- Explore Paris 2024 event placements with **[Olympic Results 2024](https://apify.com/maximedupre/olympedia/examples/olympic-results-2024)**.

#### 🧾 Normalized Olympic placement rows

Each saved row represents one overall placement from a public Olympedia event-result table. The row includes the event and edition context when the source publishes it, the athlete or team, placement details, named round results, qualification labels, and the source page URL. Missing source values are not guessed.

Use edition and optional sport selection to follow linked public pages. You can also submit exact event-result pages when you already know the page you need. Direct event pages may not expose edition or sport context, so those values remain unavailable when the source does not publish a reliable relationship.

#### 🚀 Choose an edition, sport, or event page

1. Choose **Olympic editions and sports** or **Exact event-result pages**.
2. Add edition names such as `Paris 2024`, and optionally add sport names such as `Athletics`.
3. For the direct-page method, add exact public URLs such as `https://www.olympedia.org/results/2008700`.
4. Choose **Selected sources** for the submitted source set, or **Broader linked results** for a wider set of related public result pages.
5. Add country or NOC values, or turn on **Medalists only**, when you need a narrower dataset.
6. Set a placement limit only when you want the run to stop early, then open the default dataset.

Each run uses one coherent source selection and filter set. If `Maximum placements` is empty, the Actor returns all available placements until the source is exhausted.

#### ⚙️ Input

**Input fields**

| Field | Type | What it does |
|---|---|---|
| `discoveryMethod` | string | Chooses linked discovery from Olympic editions and sports, or exact public event-result pages. |
| `editions` | array of strings | Lists one or more Olympic edition names. The Actor follows linked event-result pages in those editions. |
| `sports` | array of strings | Optionally limits edition discovery to the named sports. Leave it empty to include all sports available in the selected editions. |
| `eventPages` | array of objects | Lists exact public event-result pages. Each object has a `url` string pointing to a page with an overall results table. |
| `scope` | string | Chooses the submitted source set or a broader set of related public result pages. |
| `maxItems` | integer | Stops after the chosen number of placement records. Leave it empty to return all available placements until the source is exhausted. |
| `countries` | array of strings | Keeps placements whose published country or NOC matches one of the submitted names or codes. Leave it empty to include every country. |
| `medalistsOnly` | boolean | When true, keeps only placements with a published Gold, Silver, or Bronze medal. |

**Successful default input**

This is the public input from a successful current-beta default run.

```json
{
  "discoveryMethod": "editions",
  "editions": [
    "Paris 2024"
  ],
  "scope": "bounded",
  "maxItems": 25,
  "medalistsOnly": false
}
```

#### 🧾 Output

**Output fields**

| Field | Type | What it does |
|---|---|---|
| `sourceUrl` | string | Public Olympedia event-result page for the placement. |
| `event` | object | Event and source-published competition context. |
| `event.name` | string | Source-published event name. |
| `event.edition` | string | Olympic edition for the event, when published. |
| `event.year` | integer | Year for the Olympic edition, when published. |
| `event.sport` | string | Sport for the event, when published. |
| `event.date` | string | Source-published event date or date text, when available. |
| `event.venue` | string | Source-published event venue, when available. |
| `event.competitionStatus` | string | Source-published competition status, when available. |
| `event.hostCity` | string | Source-published host city, when available. |
| `competitor` | object | Athlete or team named in the placement row. |
| `competitor.name` | string | Source-published athlete or team name. |
| `competitor.type` | string | Identifies the competitor as an `athlete` or `team`. |
| `competitor.country` | object | Source-published country and NOC details, when available. |
| `competitor.country.name` | string | Source-published country name, when available. |
| `competitor.country.noc` | string | Source-published National Olympic Committee code, when available. |
| `competitor.athleteId` | string | Source-published athlete identifier, when available. |
| `placement` | object | Published overall placement and final result. |
| `placement.rank` | integer | Published overall placement rank. |
| `placement.result` | string | Published final result value, when available. |
| `placement.medal` | string | Published `gold`, `silver`, or `bronze` medal, when available. |
| `roundResults` | array of objects | Named round or stage result values published for the placement. |
| `roundResults[].name` | string | Source-published round or stage name. |
| `roundResults[].result` | string | Source-published result value for that round or stage. |
| `qualificationLabels` | array of strings | Source-published qualification labels for the placement, when available. |

**Genuine row from a successful current-beta run**

This row came from a successful current-beta run for an exact public event page. It shows an event, athlete, country code, medal, named rounds, qualification labels, and source URL.

```json
{
  "sourceUrl": "https://www.olympedia.org/results/2008700",
  "event": {
    "name": "Sprint, Men",
    "edition": "2024 Summer Olympics",
    "year": 2024,
    "sport": "Cycling Track",
    "date": "7 – 9 August 2024",
    "venue": "Vélodrome de Saint-Quentin-en-Yvelines, Montigny-le-Bretonneux, France",
    "competitionStatus": "Olympic",
    "hostCity": "Paris, France"
  },
  "competitor": {
    "name": "Harrie Lavreysen",
    "type": "athlete",
    "country": {
      "noc": "NED"
    },
    "athleteId": "145558"
  },
  "placement": {
    "rank": 1,
    "result": "9.578 (1 h1)",
    "medal": "gold"
  },
  "roundResults": [
    {
      "name": "Number",
      "result": "208"
    },
    {
      "name": "Qualifying",
      "result": "9.088 (1)"
    },
    {
      "name": "R1",
      "result": "9.953 (1 h1)"
    },
    {
      "name": "R2",
      "result": "9.902 (1 h1)"
    },
    {
      "name": "R3",
      "result": "9.945 (1 h1)"
    },
    {
      "name": "QF",
      "result": "9.720 (1 h1)"
    },
    {
      "name": "SF",
      "result": "9.537 (1 h1)"
    },
    {
      "name": "Final",
      "result": "9.578 (1 h1)"
    }
  ],
  "qualificationLabels": [
    "Qualified",
    "World Record"
  ]
}
```

#### 💳 Pricing

The Actor uses pay-per-event pricing. Each saved normalized event placement is one billable event. Your Apify account tier sets the rate shown in the Actor configuration.

#### 🔌 Integrations

Open the default dataset after a run to read the structured placement rows. Use Apify's dataset API or export options for JSON, CSV, Excel, and other supported formats.

Watch the Apify workflow video:

https://www.youtube.com/watch?v=bNACk1\_S\_6w\&list=PLObrtcm1Kw6MUrlLNDbK9QRg8VDJg0gOW\&index=4

#### ❓ FAQ

##### Can I submit one exact Olympedia event page?

Yes. Choose **Exact event-result pages** and submit one or more public `https://www.olympedia.org/results/<id>` URLs with an overall results table.

##### Can I select a whole Olympic edition and one sport?

Yes. Choose **Olympic editions and sports**, add an edition name, and add one or more sport names when you want a narrower linked source set.

##### Does each round become a separate row?

No. Each row is one overall event placement. Named round values from the overall table stay in `roundResults`; detailed round tables are not separate output rows.

##### Can I keep only medalists or one country?

Yes. Turn on **Medalists only** for published podium placements, or add country names or NOC codes to filter the returned placements.

##### What happens when a source does not publish a field?

The Actor keeps the source data as published and does not infer missing event, competitor, placement, round, or qualification values.

##### Are country medal totals included?

No. The dataset contains event-level placements. It does not create separate aggregate country or medal-table rows.

##### What does an empty maximum placements field do?

It returns all available placements until the source is exhausted.

### 📝 Changelog

**v0.0** (21-09-2026)

- Initial release.

### 🆘 Support

For issues, questions, or feature requests, [file a ticket](https://console.apify.com/actors/maximedupre~olympedia/issues) and I'll fix or implement it in less than 24h 🫡

### 🔗 Related Actors

- [Sofascore Live Events Scraper](https://apify.com/maximedupre/sofascore-live-events-scraper) for current fixtures, finished results, and tournament context.
- [Bassmaster Tournament Results & Standings Scraper](https://apify.com/maximedupre/bassmaster) for structured tournament standings, ranks, and event details.
- [ESPN MCP Server](https://apify.com/maximedupre/espn-mcp-server) for scores, schedules, standings, athletes, and broader sports research.
- [Olympedia Olympic Results Scraper](https://apify.com/automation-lab/olympic-medal-event-results-tables) for a direct Olympedia alternative focused on event placements and medal-result rows.
- [Flashscore Results: Match Listings & Historical Data](https://apify.com/extractify-labs/flashscore-results) for historical match results by tournament or team.

**Made with ❤️ by Maxime Dupré**

# Actor input Schema

## `discoveryMethod` (type: `string`):

Choose linked discovery from Olympic editions and sports, or submit exact public event-result pages.

## `editions` (type: `array`):

Add one or more Olympic edition names, such as `Paris 2024`. The Actor finds linked event-result pages in these editions.

## `sports` (type: `array`):

Optionally add sport names, such as `Athletics`. Leave this list empty to include all sports available in the selected editions.

## `eventPages` (type: `array`):

Add one or more exact public Olympedia event-result page URLs. Each URL should point to a page with an overall results table.

## `scope` (type: `string`):

Choose the source scope for this run. The Selected sources option uses only the editions, sports, or pages you submit. The Broader linked results option allows a wider set of related public result pages.

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

Optional positive number of placement records at which to stop. Leave empty to collect all available placements until source exhaustion.

## `countries` (type: `array`):

Return placements whose published country or NOC matches one of these values. Use country names or NOC codes as published by Olympedia. Leave this list empty to include every country.

## `medalistsOnly` (type: `boolean`):

Turn this on to return only placements with a published podium medal. Leave it off to return all placements.

## Actor input object example

```json
{
  "discoveryMethod": "editions",
  "editions": [
    "Paris 2024"
  ],
  "scope": "bounded",
  "maxItems": 25,
  "medalistsOnly": false
}
```

# Actor output Schema

## `dataset` (type: `string`):

Open the event placement rows in the default dataset.

# 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 = {
    "discoveryMethod": "editions",
    "editions": [
        "Paris 2024"
    ],
    "maxItems": 25
};

// Run the Actor and wait for it to finish
const run = await client.actor("maximedupre/olympedia").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 = {
    "discoveryMethod": "editions",
    "editions": ["Paris 2024"],
    "maxItems": 25,
}

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/olympedia").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 '{
  "discoveryMethod": "editions",
  "editions": [
    "Paris 2024"
  ],
  "maxItems": 25
}' |
apify call maximedupre/olympedia --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,maximedupre/olympedia"
        }
    }
}
```

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/nCfuBlfzuCwyJ68Km/builds/18UdJVc0evgxkn6eR/openapi.json