# USA Cycling Sport80 Events Scraper (`jungle_synthesizer/usacycling-sport80-events-finder-scraper`) Actor

Scrapes USA Cycling's Sport80 event locator for cycling race and event listings. Extracts organizer contact details (name, email, phone), event dates, location coordinates, pricing, entry windows, and capacity — ideal for B2B lead generation targeting race-service suppliers.

- **URL**: https://apify.com/jungle\_synthesizer/usacycling-sport80-events-finder-scraper.md
- **Developed by:** [BowTiedRaccoon](https://apify.com/jungle_synthesizer) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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.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

## USA Cycling Sport80 Events Scraper

Scrape cycling event listings from [USA Cycling's Sport80 event locator](https://usacycling.sport80.com/pub/e_locator/events/find). Returns organizer contact details, event dates, location coordinates, pricing, entry windows, and capacity flags for every active race on USA Cycling's calendar — around 300+ events at any given time.

### USA Cycling Sport80 Events Scraper Features

- **Extracts full organizer contact info** — name, email, and phone number for every event. That's the core lead-gen payload right there.
- **Returns complete event metadata** — dates, start time, location, lat/lng coordinates, what3words reference, and the Sport80 detail page URL.
- **Captures entry logistics** — open/close timestamps, is_open/is_closed/is_selling_fast flags, capacity, and entry list URL.
- **Includes pricing and event requirements** — useful for qualifying which events accept day-of entries or require pre-registration.
- **Paginates the full catalog automatically** — 300+ events across 20+ pages. You set maxItems, it does the rest.
- **No proxies required** — the Sport80 public event locator answers direct HTTP requests without challenge pages.
- **Pure HTTP scraping, no browser** — the page embeds the full JSON dataset in the HTML before JavaScript runs. Fast and cheap.

### What Can You Do With USA Cycling Event Data?

- **Race-service vendors** — timer companies, photography crews, event insurance brokers. Every listing carries an organizer email and phone. Cold outreach at scale.
- **Bike retailers running event-day demo programs** — filter by location and date, contact organizers directly before the calendar fills up.
- **Sponsors seeking regional exposure** — identify promoted events, check entry counts, reach the right organizer before budgets close.
- **Event-discovery apps** — build a searchable calendar with lat/lng, dates, pricing, and entry status already structured.
- **Racing teams** — track open events, entry deadlines, and capacity status across the national calendar without clicking through 20 pages.

### How It Works

1. The scraper fetches the Sport80 event locator (`?from_date=today&page=1`) and parses the Inertia.js JSON payload embedded in the page HTML.
2. It reads the total page count from the payload and chains through each page, collecting all events.
3. Each event object is normalized — nested date fields flattened, timestamps cast to numbers, empty arrays converted to null — and pushed to the dataset.
4. Run stops when `maxItems` is reached or the full catalog is exhausted.

### USA Cycling Sport80 Events Scraper Input

```json
{
  "maxItems": 100
}
````

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `maxItems` | integer | 10 | Maximum number of event records to collect. Set higher to capture the full catalog. |

### USA Cycling Sport80 Events Scraper Output Fields

```json
{
  "event_id": "15447",
  "name": "2026 USA Cycling Criterium National Championships",
  "date_start": "2026-06-14",
  "date_end": "2026-06-21",
  "start_time": "08:00 MDT",
  "entry_open_date": "Mar 1, 2026",
  "entry_close_date": "Jun 7, 2026",
  "entry_open_timestamp": 1772524800,
  "entry_close_timestamp": 1780012800,
  "is_open": true,
  "is_closed": false,
  "is_selling_fast": false,
  "is_promoted": true,
  "capacity": 500,
  "distance": "50km",
  "location": "Knoxville, Tennessee, 37902",
  "latitude": 35.9606,
  "longitude": -83.9207,
  "what3words": "///filled.count.soap",
  "organiser_name": "USA Cycling",
  "organiser_email": "events@usacycling.org",
  "organiser_phone": "+1-719-434-4200",
  "organiser_img_url": null,
  "price": 60.00,
  "event_requirements": "USA Cycling Annual License",
  "entry_requirements_description": "Must hold a valid USA Cycling license.",
  "logo": "https://usacycling.sport80.com/uploads/crits-logo.png",
  "image": "https://usacycling.sport80.com/uploads/crits-banner.jpg",
  "website_url": "https://usacycling.org/nationals",
  "full_details_url": "https://usacycling.sport80.com/pub/e_locator/events/view/15447",
  "entry_list_url": "https://usacycling.sport80.com/pub/e_locator/events/view/15447/entry_list",
  "language": null
}
```

| Field | Type | Description |
|-------|------|-------------|
| `event_id` | string | Sport80 internal event ID |
| `name` | string | Full event name |
| `date_start` | string | Event start date (YYYY-MM-DD) |
| `date_end` | string | Event end date (YYYY-MM-DD) |
| `start_time` | string | Start time with timezone (e.g., "08:00 MDT") |
| `entry_open_date` | string | Human-readable entry open date |
| `entry_close_date` | string | Human-readable entry close date |
| `entry_open_timestamp` | number | Entry open time as Unix timestamp |
| `entry_close_timestamp` | number | Entry close time as Unix timestamp |
| `is_open` | boolean | Whether entry is currently open |
| `is_closed` | boolean | Whether entry is closed |
| `is_selling_fast` | boolean | Low-capacity warning flag |
| `is_promoted` | boolean | Whether the event is promoted/featured |
| `capacity` | number | Maximum entrant capacity (null if unlimited) |
| `distance` | string | Race distance or category description |
| `location` | string | Full address string |
| `latitude` | number | Latitude coordinate |
| `longitude` | number | Longitude coordinate |
| `what3words` | string | What3Words address (when available) |
| `organiser_name` | string | Event organizer name |
| `organiser_email` | string | Organizer contact email |
| `organiser_phone` | string | Organizer contact phone |
| `organiser_img_url` | string | Organizer profile image URL |
| `price` | number | Entry price in USD (null if free or not set) |
| `event_requirements` | string | Comma-separated entry requirements |
| `entry_requirements_description` | string | Full requirements description |
| `logo` | string | Event logo image URL |
| `image` | string | Event banner image URL |
| `website_url` | string | External organizer website URL |
| `full_details_url` | string | Sport80 event detail page URL |
| `entry_list_url` | string | URL to view current registrants |
| `language` | string | Language code (usually null for US events) |

### 🔍 FAQ

**How do I scrape USA Cycling events?**
USA Cycling Sport80 Events Scraper fetches directly from the public Sport80 event locator. Set `maxItems` to however many events you want, run it, and pick up the JSON dataset. No login required.

**How much does this actor cost to run?**
USA Cycling Sport80 Events Scraper charges per record via Apify's Pay Per Event pricing. Scraping the full catalog of ~300 events costs a fraction of a dollar. Check the actor's pricing page for the current per-record rate.

**Does this actor need proxies?**
No. The Sport80 event locator answers direct HTTP requests without CAPTCHAs or IP blocks. It's a genuinely public endpoint.

**What data can I get from Sport80 USA Cycling events?**
Every event record includes organizer contact info (name, email, phone), event dates, lat/lng coordinates, entry status flags, pricing, capacity, and links to the detail page and entry list. That's 32 fields per event.

**Can I filter events by location or date?**
The scraper collects all active events from the default `?from_date=today` view. Filtering by region or discipline is best done post-collection on the `location`, `latitude`, `longitude`, or `date_start` fields.

### Why Use USA Cycling Sport80 Events Scraper?

- **Clean lead-gen data** — organizer email and phone on every record, ready to pipe into a CRM or outreach tool without cleanup.
- **No browser overhead** — HTTP-only extraction against a public endpoint means fast runs and low compute costs.
- **Structured JSON** — consistent field names, typed values, and null for missing data. Not whatever a naive DOM scraper would hand you.

### Need More Features?

Need custom filters, additional event fields, or integration with another platform? [File an issue](https://console.apify.com/actors/issues) or get in touch.

# Actor input Schema

## `sp_intended_usage` (type: `string`):

Please describe how you plan to use the data extracted by this crawler.

## `sp_improvement_suggestions` (type: `string`):

Provide any feedback or suggestions for improvements.

## `sp_contact` (type: `string`):

Provide your email address so we can get in touch with you.

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

Maximum number of records to scrape

## Actor input object example

```json
{
  "sp_intended_usage": "Describe your intended use...",
  "sp_improvement_suggestions": "Share your suggestions here...",
  "sp_contact": "Share your email here...",
  "maxItems": 10
}
```

# 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 = {
    "sp_intended_usage": "Describe your intended use...",
    "sp_improvement_suggestions": "Share your suggestions here...",
    "sp_contact": "Share your email here...",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("jungle_synthesizer/usacycling-sport80-events-finder-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 = {
    "sp_intended_usage": "Describe your intended use...",
    "sp_improvement_suggestions": "Share your suggestions here...",
    "sp_contact": "Share your email here...",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("jungle_synthesizer/usacycling-sport80-events-finder-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 '{
  "sp_intended_usage": "Describe your intended use...",
  "sp_improvement_suggestions": "Share your suggestions here...",
  "sp_contact": "Share your email here...",
  "maxItems": 10
}' |
apify call jungle_synthesizer/usacycling-sport80-events-finder-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=jungle_synthesizer/usacycling-sport80-events-finder-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "USA Cycling Sport80 Events Scraper",
        "description": "Scrapes USA Cycling's Sport80 event locator for cycling race and event listings. Extracts organizer contact details (name, email, phone), event dates, location coordinates, pricing, entry windows, and capacity — ideal for B2B lead generation targeting race-service suppliers.",
        "version": "0.1",
        "x-build-id": "lHoH351K3Mi8zXL35"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/jungle_synthesizer~usacycling-sport80-events-finder-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-jungle_synthesizer-usacycling-sport80-events-finder-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/jungle_synthesizer~usacycling-sport80-events-finder-scraper/runs": {
            "post": {
                "operationId": "runs-sync-jungle_synthesizer-usacycling-sport80-events-finder-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/jungle_synthesizer~usacycling-sport80-events-finder-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-jungle_synthesizer-usacycling-sport80-events-finder-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": [
                    "maxItems"
                ],
                "properties": {
                    "sp_intended_usage": {
                        "title": "What is the intended usage of this data?",
                        "minLength": 1,
                        "type": "string",
                        "description": "Please describe how you plan to use the data extracted by this crawler."
                    },
                    "sp_improvement_suggestions": {
                        "title": "How can we improve this crawler for you?",
                        "minLength": 1,
                        "type": "string",
                        "description": "Provide any feedback or suggestions for improvements."
                    },
                    "sp_contact": {
                        "title": "Contact Email",
                        "minLength": 1,
                        "type": "string",
                        "description": "Provide your email address so we can get in touch with you."
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "type": "integer",
                        "description": "Maximum number of records to scrape",
                        "default": 10
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
