# Procyclingstats.com Scraper (`lexis-solutions/procyclingstats-com-scraper`) Actor

Scrape race results, rider statistics, team info, and historical cycling data from ProCyclingStats.com. Ideal for analysts, journalists, team managers, and enthusiasts needing structured race standings, performance metrics, and career records. Fast, structured, and customizable extraction.

- **URL**: https://apify.com/lexis-solutions/procyclingstats-com-scraper.md
- **Developed by:** [Lexis Solutions](https://apify.com/lexis-solutions) (community)
- **Categories:** Lead generation, News, Social media
- **Stats:** 16 total users, 1 monthly users, 100.0% runs succeeded, 2 bookmarks
- **User rating**: No ratings yet

## Pricing

$29.00/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#rental-actors

## 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.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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

## ProCyclingStats Scraper

![banner](https://i.ibb.co/Hf6xG4wP/procyling.png)

Extract comprehensive cycling statistics and race data from ProCyclingStats.com, the world's leading cycling statistics database. This powerful scraper collects detailed race results, rider statistics, team information, and historical cycling data across all major cycling disciplines. Perfect for cycling analysts, sports journalists, team managers, and cycling enthusiasts who need structured data for research, analysis, and reporting.

👋 Welcome to the ProCyclingStats Scraper, an actor designed to help you gather comprehensive cycling data from procyclingstats.com! With this actor, you can easily extract race results, rider statistics, and historical cycling information.

### Introduction

The ProCyclingStats Scraper is a web scraping tool designed to extract cycling statistics and race data from procyclingstats.com. It was created to make it easier for cycling professionals, analysts, and enthusiasts to access structured data from the world's most comprehensive cycling statistics database.

### Use Cases

Here are some typical scenarios in which the ProCyclingStats Scraper can be useful:

- **Cycling Analysts** can use the scraper to extract race results and performance data for statistical analysis
- **Sports Journalists** can use the scraper to gather historical data for articles and race reports
- **Team Managers** can use the scraper to analyze competitor performance and track rider statistics
- **Cycling Enthusiasts** can use the scraper to research historical race data and rider achievements
- **Data Scientists** can use the scraper to build cycling databases for machine learning and predictive modeling

### Input 📥

To use this actor, you need to provide the following input:

- Field: **startUrls**
  - Type: array
  - Required: Yes
  - Description: URLs to scrape from ProCyclingStats.com

```json
{
  "startUrls": [
    {
      "url": "https://www.procyclingstats.com/race/world-championship/results/most-starts-finishes"
    }
  ]
}
````

### How to get `startUrls`?

1. **Race Results Pages**

   - Navigate to any race results page on ProCyclingStats.com
   - Copy the URL from your browser's address bar
   - Add it to the `startUrls` array

2. **Statistics Pages**

   - Visit any statistics page (e.g., most starts/finishes, rider rankings)
   - Copy the URL and add it to the `startUrls` array

3. **Team or Rider Pages**
   - Go to specific team or rider profile pages
   - Copy the URL for data extraction

#### Examples

Race results page:

```
https://www.procyclingstats.com/race/world-championship/results/most-starts-finishes
```

Tour de France results:

```
https://www.procyclingstats.com/race/tour-de-france/2024/gc
```

Rider statistics:

```
https://www.procyclingstats.com/rider/eddy-merckx/statistics
```

### Output 📤

An example output looks like this:

```json
{
  "url": "https://www.procyclingstats.com/race/world-championship/results/most-starts-finishes",
  "title": "Most starts and finishes in World Championships ME - Road Race history",
  "extractedAt": "2025-09-23T21:56:30.993Z",
  "results": [
    {
      "Pos.": "1",
      "Rider": "POULIDOR Raymond",
      "Starts": "18",
      "Finishes": "17",
      "First": "1960",
      "Last": "1977"
    },
    {
      "Pos.": "2",
      "Rider": "ZOETEMELK Joop",
      "Starts": "17",
      "Finishes": "16",
      "First": "1970",
      "Last": "1987"
    }
  ],
  "total": 100
}
```

### What data can the ProCyclingStats Scraper extract?

The ProCyclingStats Scraper can extract various types of cycling data including:

- **Race Results** - Complete race standings and classifications
- **Rider Statistics** - Performance metrics, career statistics, and achievements
- **Team Data** - Team rosters, performance history, and statistics
- **Historical Records** - All-time records, most starts/finishes, and career milestones
- **Race Classifications** - General Classification, Points, Mountains, and other classifications
- **Stage Results** - Individual stage results and time gaps

### Why use the ProCyclingStats Scraper?

- ⚡️ **Comprehensive** - Access to the world's largest cycling statistics database
- 🤙 **Easy to use** - Simply input URLs and let the scraper handle the data extraction
- 📊 **Structured Data** - Get clean, structured JSON data ready for analysis
- 🏆 **Historical Coverage** - Access decades of cycling history and statistics
- ☑️ **Well-Maintained** - The scraper is maintained by the Lexis Solutions team, ensuring reliable performance

### Limitations

- The scraper respects ProCyclingStats.com's rate limiting and terms of service
- Some data may require specific access permissions
- Large datasets may take time to process

### FAQ 💬

- **What is ProCyclingStats.com?**

  ProCyclingStats.com is the world's most comprehensive cycling statistics database, covering professional cycling races, riders, teams, and historical data from around the globe.

- **How can I find specific cycling data on ProCyclingStats.com?**

  You can navigate to specific race pages, rider profiles, or statistics sections on the website. The scraper automates the data extraction process from these pages.

- **Can I use the ProCyclingStats scraper for commercial purposes?**

  Please ensure you comply with ProCyclingStats.com's terms of service and any applicable laws and regulations when using this scraper.

- **What types of cycling data can the scraper find?**

  The scraper can extract data from various sections including:

  - Race results and classifications
  - Rider statistics and career data
  - Team information and rosters
  - Historical records and achievements
  - Stage results and time gaps

- **What if the website changes?**

  Website changes may affect the scraper's functionality. In such cases, our team will update the scraper to maintain compatibility. We regularly monitor and maintain our scrapers to ensure reliable operation.

### Need to scrape other sports data?

Here are some other sports scrapers you might find useful:

- **Betting & Racing** 🏇
  - [Sportsbet Scraper](https://apify.com/lexis-solutions/sportsbet-com-au-scraper) - Extract betting odds and racing schedules from Australia's leading sports betting platform
  - [LeTrot Scraper](https://apify.com/lexis-solutions/letrot-com-scraper) - Extract horse racing data and results from France's premier trotting platform

***

👀 p.s.

Got feedback or need an extension?

Lexis Solutions is a [certified Apify Partner](https://apify.com/partners/find). We can help you with custom solutions or data extraction projects.

Contact us over [Email](mailto:scraping@lexis.solutions) or [LinkedIn](https://www.linkedin.com/company/lexis-solutions)

### Support Our Work 💝

If you're happy with our work and scrapers, you're welcome to leave us a company review [here](https://apify.com/partners/find/lexis-solutions/review) and leave a review for the scrapers you're subscribed to. It will take you less than a minute but it will mean a lot to us!

Image Credit: https://www.procyclingstats.com

# Actor input Schema

## `startUrls` (type: `array`):

URLs to scrape

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.procyclingstats.com/race/world-championship/results/most-starts-finishes"
    }
  ]
}
```

# 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 = {
    "startUrls": [
        {
            "url": "https://www.procyclingstats.com/race/world-championship/results/most-starts-finishes"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("lexis-solutions/procyclingstats-com-scraper").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 = { "startUrls": [{ "url": "https://www.procyclingstats.com/race/world-championship/results/most-starts-finishes" }] }

# Run the Actor and wait for it to finish
run = client.actor("lexis-solutions/procyclingstats-com-scraper").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 '{
  "startUrls": [
    {
      "url": "https://www.procyclingstats.com/race/world-championship/results/most-starts-finishes"
    }
  ]
}' |
apify call lexis-solutions/procyclingstats-com-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=lexis-solutions/procyclingstats-com-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Procyclingstats.com Scraper",
        "description": "Scrape race results, rider statistics, team info, and historical cycling data from ProCyclingStats.com. Ideal for analysts, journalists, team managers, and enthusiasts needing structured race standings, performance metrics, and career records. Fast, structured, and customizable extraction.",
        "version": "0.1",
        "x-build-id": "nu2sfgVtHSgzYd0Kp"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/lexis-solutions~procyclingstats-com-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-lexis-solutions-procyclingstats-com-scraper",
                "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/lexis-solutions~procyclingstats-com-scraper/runs": {
            "post": {
                "operationId": "runs-sync-lexis-solutions-procyclingstats-com-scraper",
                "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/lexis-solutions~procyclingstats-com-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-lexis-solutions-procyclingstats-com-scraper",
                "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": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "URLs to scrape",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```