# Olympic Medal & Event Results Tables (`trovevault/olympic-medal-event-results-tables`) Actor

Returns Olympic medal tables, event podiums, sport medal tables, and country event medal breakdowns.

- **URL**: https://apify.com/trovevault/olympic-medal-event-results-tables.md
- **Developed by:** [Trove Vault](https://apify.com/trovevault) (community)
- **Categories:** News, Other, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.85 / 1,000 medals

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Olympic Medal & Event Results Tables

Get Olympic medal tables and event-level medal results in clean, analysis-ready datasets.

This Actor is built for sports data workflows that need more than the final medal table. It returns podium rows by event, country medal tables, sport-by-country medal tables, and country/event medal breakdowns. Optional detail mode can also return full event standings and team-member rows for team events.

### What It Returns

- **Event medals**: one row per medal won in each Olympic event.
- **Country medal table**: ranked gold/silver/bronze/total medals by country.
- **Sport medal table**: ranked medal totals by sport and country.
- **Country event breakdown**: country results split by sport and event.
- **Team members**: optional athlete rows for team medals.
- **Event standings**: optional full standings for selected events.

### Input

```json
{
  "games": "Paris 2024",
  "sport": "Athletics",
  "country": "USA",
  "medals": ["gold", "silver", "bronze"],
  "maxEvents": 100,
  "includeTeamMembers": false,
  "includeFullEventStandings": false,
  "maxEventDetails": 25
}
````

#### Main Options

- `games`: Olympic Games edition selected from the dropdown, for example `Paris 2024`, `Tokyo 2020`, or `Beijing 2022`.
- `sport`: optional sport or discipline selected from the dropdown. Use `All sports` for the full edition.
- `country`: optional NOC or country filter, for example `USA`, `Portugal`, or `France`.
- `medals`: choose any of `gold`, `silver`, and `bronze`.
- `maxEvents`: maximum number of events to include.
- `includeTeamMembers`: fetch team-member rows for team event medals.
- `includeFullEventStandings`: fetch standings tables for event detail pages.
- `maxEventDetails`: limits detail page fetches when optional detail modes are enabled.

### Output Datasets

The default dataset contains event medal rows. Additional named datasets are available from the Actor output:

- `countryMedalTable`
- `sportMedalTable`
- `countryEventBreakdown`
- `teamMembers`
- `eventStandings`

### API Example

```bash
curl "https://api.apify.com/v2/acts/TroveVault~olympic-medal-event-results-tables/runs" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "games": "Paris 2024",
    "country": "USA",
    "maxEvents": 50
  }'
```

Example event medal row:

```json
{
  "games": "Paris 2024",
  "editionYear": 2024,
  "season": "summer",
  "sport": "Athletics",
  "eventName": "100 metres, Men",
  "eventGender": "men",
  "medal": "gold",
  "medalRank": 1,
  "countryCode": "USA",
  "countryName": "United States",
  "medalistName": "Noah Lyles",
  "teamEvent": false
}
```

### Notes

The Actor is intended for completed Olympic Games and official historical results workflows. Optional event detail modes intentionally fetch fewer pages by default because they are slower and more granular than the medal-table workflow.

# Actor input Schema

## `games` (type: `string`):

Olympic Games edition to collect.

## `country` (type: `string`):

Optional country name or NOC code such as USA, Portugal, Brazil, France, or Japan. Leave empty for all countries.

## `sport` (type: `string`):

Sport or discipline to include.

## `medals` (type: `array`):

Medal types to include.

## `maxEvents` (type: `integer`):

Maximum medal events to process after filters. Increase for full-Games exports.

## `includeTeamMembers` (type: `boolean`):

Open event pages to extract members for medal-winning team events. This is slower because event pages are fetched politely.

## `includeFullEventStandings` (type: `boolean`):

Open event pages to return full event standings, not only medal rows. This is slower and should be used with sport or country filters.

## `maxEventDetails` (type: `integer`):

Maximum event pages to open when team members or full standings are enabled.

## `datasetId` (type: `string`):

Optional existing Apify dataset ID where all output rows are also appended with an entityType field.

## `runId` (type: `string`):

Optional workflow identifier copied into output rows.

## Actor input object example

```json
{
  "games": "Paris 2024",
  "sport": "",
  "medals": [
    "gold",
    "silver",
    "bronze"
  ],
  "maxEvents": 400,
  "includeTeamMembers": false,
  "includeFullEventStandings": false,
  "maxEventDetails": 25
}
```

# Actor output Schema

## `eventMedals` (type: `string`):

No description

## `countryMedalTable` (type: `string`):

No description

## `sportMedalTable` (type: `string`):

No description

## `countryEventBreakdown` (type: `string`):

No description

## `teamMembers` (type: `string`):

No description

## `eventStandings` (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 = {
    "games": "Paris 2024",
    "sport": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("trovevault/olympic-medal-event-results-tables").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 = {
    "games": "Paris 2024",
    "sport": "",
}

# Run the Actor and wait for it to finish
run = client.actor("trovevault/olympic-medal-event-results-tables").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "games": "Paris 2024",
  "sport": ""
}' |
apify call trovevault/olympic-medal-event-results-tables --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=trovevault/olympic-medal-event-results-tables",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Olympic Medal & Event Results Tables",
        "description": "Returns Olympic medal tables, event podiums, sport medal tables, and country event medal breakdowns.",
        "version": "0.1",
        "x-build-id": "unmfGgqpUGeyenheb"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/trovevault~olympic-medal-event-results-tables/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-trovevault-olympic-medal-event-results-tables",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/trovevault~olympic-medal-event-results-tables/runs": {
            "post": {
                "operationId": "runs-sync-trovevault-olympic-medal-event-results-tables",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/trovevault~olympic-medal-event-results-tables/run-sync": {
            "post": {
                "operationId": "run-sync-trovevault-olympic-medal-event-results-tables",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "games"
                ],
                "properties": {
                    "games": {
                        "title": "Games",
                        "enum": [
                            "Milano Cortina 2026",
                            "Paris 2024",
                            "Beijing 2022",
                            "Tokyo 2020",
                            "PyeongChang 2018",
                            "Rio de Janeiro 2016",
                            "Sochi 2014",
                            "London 2012",
                            "Vancouver 2010",
                            "Beijing 2008",
                            "Torino 2006",
                            "Athens 2004",
                            "Salt Lake City 2002",
                            "Sydney 2000",
                            "Nagano 1998",
                            "Atlanta 1996",
                            "Lillehammer 1994",
                            "Barcelona 1992",
                            "Albertville 1992",
                            "Seoul 1988",
                            "Calgary 1988",
                            "Los Angeles 1984",
                            "Sarajevo 1984",
                            "Moscow 1980",
                            "Lake Placid 1980",
                            "Montreal 1976",
                            "Innsbruck 1976",
                            "Munich 1972",
                            "Sapporo 1972",
                            "Mexico City 1968",
                            "Grenoble 1968",
                            "Tokyo 1964",
                            "Innsbruck 1964",
                            "Rome 1960",
                            "Squaw Valley 1960",
                            "Melbourne 1956",
                            "Stockholm 1956",
                            "Cortina d'Ampezzo 1956",
                            "Helsinki 1952",
                            "Oslo 1952",
                            "London 1948",
                            "St. Moritz 1948",
                            "Berlin 1936",
                            "Garmisch-Partenkirchen 1936",
                            "Los Angeles 1932",
                            "Lake Placid 1932",
                            "Amsterdam 1928",
                            "St. Moritz 1928",
                            "Paris 1924",
                            "Chamonix 1924",
                            "Antwerp 1920",
                            "Stockholm 1912",
                            "London 1908",
                            "St. Louis 1904",
                            "Paris 1900",
                            "Athens 1896"
                        ],
                        "type": "string",
                        "description": "Olympic Games edition to collect.",
                        "default": "Paris 2024"
                    },
                    "country": {
                        "title": "Country",
                        "type": "string",
                        "description": "Optional country name or NOC code such as USA, Portugal, Brazil, France, or Japan. Leave empty for all countries."
                    },
                    "sport": {
                        "title": "Sport",
                        "enum": [
                            "",
                            "3x3 Basketball",
                            "Aeronautics",
                            "Alpine Skiing",
                            "Alpinism",
                            "Archery",
                            "Architecture",
                            "Artistic Gymnastics",
                            "Artistic Swimming",
                            "Athletics",
                            "Badminton",
                            "Baseball",
                            "Basketball",
                            "Basque pelota",
                            "Beach Volleyball",
                            "Biathlon",
                            "Bobsleigh",
                            "Boxing",
                            "Breaking",
                            "Canoe Slalom",
                            "Canoe Sprint",
                            "Cricket",
                            "Croquet",
                            "Cross Country Skiing",
                            "Curling",
                            "Cycling BMX Freestyle",
                            "Cycling BMX Racing",
                            "Cycling Mountain Bike",
                            "Cycling Road",
                            "Cycling Track",
                            "Diving",
                            "Equestrian Dressage",
                            "Equestrian Driving",
                            "Equestrian Eventing",
                            "Equestrian Jumping",
                            "Equestrian Vaulting",
                            "Fencing",
                            "Field Handball",
                            "Figure Skating",
                            "Football",
                            "Freestyle Skiing",
                            "Golf",
                            "Handball",
                            "Hockey",
                            "Ice Hockey",
                            "Jeu de Paume",
                            "Judo",
                            "Karate",
                            "Lacrosse",
                            "Literature",
                            "Luge",
                            "Marathon Swimming",
                            "Modern Pentathlon",
                            "Motorboating",
                            "Music",
                            "Nordic Combined",
                            "Painting",
                            "Polo",
                            "Racquets",
                            "Rhythmic Gymnastics",
                            "Roque",
                            "Rowing",
                            "Rugby",
                            "Rugby Sevens",
                            "Sailing",
                            "Sculpture",
                            "Shooting",
                            "Short Track Speed Skating",
                            "Skateboarding",
                            "Skeleton",
                            "Ski Jumping",
                            "Snowboarding",
                            "Softball",
                            "Speed Skating",
                            "Sport Climbing",
                            "Surfing",
                            "Swimming",
                            "Table Tennis",
                            "Taekwondo",
                            "Tennis",
                            "Trampoline Gymnastics",
                            "Triathlon",
                            "Tug-Of-War",
                            "Volleyball",
                            "Water Polo",
                            "Weightlifting",
                            "Wrestling"
                        ],
                        "type": "string",
                        "description": "Sport or discipline to include.",
                        "default": ""
                    },
                    "medals": {
                        "title": "Medals",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Medal types to include.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "gold",
                                "silver",
                                "bronze"
                            ],
                            "enumTitles": [
                                "Gold",
                                "Silver",
                                "Bronze"
                            ]
                        },
                        "default": [
                            "gold",
                            "silver",
                            "bronze"
                        ]
                    },
                    "maxEvents": {
                        "title": "Max Events",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum medal events to process after filters. Increase for full-Games exports.",
                        "default": 400
                    },
                    "includeTeamMembers": {
                        "title": "Include Team Members",
                        "type": "boolean",
                        "description": "Open event pages to extract members for medal-winning team events. This is slower because event pages are fetched politely.",
                        "default": false
                    },
                    "includeFullEventStandings": {
                        "title": "Include Full Event Standings",
                        "type": "boolean",
                        "description": "Open event pages to return full event standings, not only medal rows. This is slower and should be used with sport or country filters.",
                        "default": false
                    },
                    "maxEventDetails": {
                        "title": "Max Event Details",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum event pages to open when team members or full standings are enabled.",
                        "default": 25
                    },
                    "datasetId": {
                        "title": "Append To Dataset ID",
                        "type": "string",
                        "description": "Optional existing Apify dataset ID where all output rows are also appended with an entityType field."
                    },
                    "runId": {
                        "title": "Run ID",
                        "type": "string",
                        "description": "Optional workflow identifier copied into output rows."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
