# Rugby Data — Fixtures, Results & Scores (`foxlabs/rugby-union-data`) Actor

Rugby matches as clean rows across the major competitions (World Cup, United Rugby Championship, Super Rugby, Six Nations, Premiership, Top 14 and more): teams, scores, winner, venue and status over a date range. No API key, no login.

- **URL**: https://apify.com/foxlabs/rugby-union-data.md
- **Developed by:** [Berkan Kaplan](https://apify.com/foxlabs) (community)
- **Categories:** Sports, News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$4.00 / 1,000 matches

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

## What's an Apify Actor?

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

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

## How to integrate an Actor?

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

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

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

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

# README

## Rugby Data Scraper — Fixtures, Results, Lineups & Player Stats 🏉

**foXLabs sports data:** Rugby · [UFC/MMA](https://apify.com/foxlabs/ufc-mma-data) · [Golf](https://apify.com/foxlabs/golf-pga-data) · [Formula 1](https://apify.com/foxlabs/formula1-data) · [Cricket](https://apify.com/foxlabs/cricket-data)

🎉 Rugby as clean, structured data: matches across the major competitions (World Cup, United Rugby Championship, Super Rugby, Six Nations, Premiership, Top 14 and more) with teams, scores, winner, venue and status, and — on request — **per-player box scores** (lineup and match statistics) for completed matches. No API key, no login. Built for sports-stats products, betting and fantasy modellers, and AI agents.

### 🔍 What is the Rugby Data Scraper — and when should you use it?

Give a date range (and optionally specific leagues) and get one row per match: the two teams with scores, winner, venue, status and competition. Turn on `includePlayerStats` to add every player's lineup and match statistics for completed matches.

**Use it when you need:** fixtures and results across many competitions; a betting or fantasy model that wants player-level box scores; or a stats widget. **Use something else when** you want another sport — see the rest of the foXLabs sports family.

### 🤖 Use with AI agents

**Already on the Apify MCP server?** Ask for it by name: `foxlabs/rugby-union-data`.

**Your agent can pay for its own runs** — pay-per-event with agentic payments over **x402 (USDC on Base)** or **Skyfire**, with no Apify account of its own. Billing is per delivered match, never for errors or empty results.

Paste into Claude, ChatGPT, Cursor or any MCP assistant:

```
Use the Apify Actor `foxlabs/rugby-union-data`.
Input: `dateFrom`/`dateTo` (YYYY-MM-DD); `leagueIds` (optional); `includePlayerStats` adds per-player box scores; `maxResults` caps rows.
Start with: { "dateFrom": "2023-09-01", "dateTo": "2023-11-01", "includePlayerStats": true }
```

**Things you can ask your agent:**

- "Give me every Rugby World Cup match with the final score and winner."
- "Add the player box scores for each match."
- "Which fly-halves kicked the most points last weekend?"

### 📋 Overview

The Rugby Data Scraper reads ESPN's public, keyless rugby API live on every run and returns deduplicated, camelCase rows. There is nothing to configure: no key, no login, no proxy to buy (Apify's free datacenter proxy is used by default).

**Why teams pick this actor:**

- 🧱 **Many competitions, one actor** — World Cup, URC, Super Rugby, Six Nations, Premiership, Top 14 and more.
- 🧬 **Player box scores generic scrapers skip** — full lineup and per-player match stats, on request.
- 🔑 **Zero setup** — no API key, no login, no browser.
- ♻️ **Fresh every run** — reads the source live.
- 🤝 **Agent-ready** — MCP + x402, billed per delivered match.

### ✨ Features

- 🏉 **Fixtures & results** — teams, scores, winner, venue, status and competition.
- 👥 **Lineups** — starting XV, replacements, captain, and who was subbed in/out (with `includePlayerStats`).
- 📊 **Player match stats** — points, tries, conversions, kicks, clean breaks, defenders beaten, tackles and more, per player.
- 🌍 **Many leagues** — pass `leagueIds`, or sweep the major competitions automatically.
- 📦 **Clean export** — deduplicated camelCase rows, ready for CSV/Excel/JSON.

### 🎬 Quick Start

```bash
curl -X POST "https://api.apify.com/v2/acts/foxlabs~rugby-union-data/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"dateFrom": "2023-09-01", "dateTo": "2023-11-01", "includePlayerStats": true}'
```

### 🚀 Getting Started (3 steps)

1. **Set the dates** — `dateFrom`/`dateTo` (defaults: last 14 / next 21 days).
2. **Pick scope** — optionally pass `leagueIds`; turn on `includePlayerStats` for box scores.
3. **Run and export** — download the dataset as JSON, CSV or Excel, or pull it from the API.

### 📥 Input

```json
{
  "dateFrom": "2023-09-01",
  "dateTo": "2023-11-01",
  "leagueIds": [],
  "includePlayerStats": true,
  "maxResults": 0
}
```

| Field | Type | Description |
|---|---|---|
| `dateFrom` / `dateTo` | string | Match date range (YYYY-MM-DD). Defaults: last 14 / next 21 days. |
| `leagueIds` | array | ESPN rugby league IDs. Empty = sweep the major leagues. |
| `includePlayerStats` | boolean | Add per-player box scores for completed matches (default off). |
| `maxPlayerStatMatches` | integer | Cap on how many matches get the player box-score lookup in one run (default 50). |
| `maxResults` | integer | Cap on delivered matches (0 = default). |
| `proxyConfiguration` | object | Apify datacenter by default — no setup needed. |

### 📤 Output

**Match** (with `includePlayerStats`, each match gains a `players` array):

```json
{
  "league": "Rugby World Cup", "leagueId": "164205", "eventId": "596154",
  "name": "France vs New Zealand", "date": "2023-09-08T19:15Z", "venue": "Stade de France", "status": "Full Time",
  "teams": [
    { "name": "France", "abbreviation": "FRA", "score": 27, "homeAway": "home", "winner": true },
    { "name": "New Zealand", "abbreviation": "NZL", "score": 13, "homeAway": "away" }
  ],
  "players": [
    { "team": "France", "name": "Thomas Ramos", "position": "FB", "jersey": "15", "starter": true,
      "stats": { "points": 17, "conversionGoals": 3, "penaltyGoals": 2, "cleanBreaks": 0 } }
  ],
  "source": "ESPN", "scrapedAt": "2026-11-02T12:00:00.000Z"
}
```

| Field | Description |
|---|---|
| `league` / `leagueId` | Competition and ESPN league id. |
| `name` / `date` / `venue` / `status` | Match identity, kick-off, venue and status. |
| `teams` | Both teams: `name`, `abbreviation`, `score`, `homeAway`, `winner`. |
| `players` | With `includePlayerStats`: per player `team`, `name`, `position`, `jersey`, `starter`, `captain`, `subbedIn`/`subbedOut`, and a `stats` object. |

### 💼 Use cases

- **Betting / fantasy model**
  - *Input:* `{ "includePlayerStats": true, "leagueIds": ["164205"] }`
  - *Output:* matches with full player box scores.
  - *Use:* model player form, kicking accuracy and scoring.
- **Results feed / widget**
  - *Input:* `{ "dateFrom": "2024-02-01", "dateTo": "2024-03-20" }`
  - *Output:* the Six Nations round by round.
- **Historical analysis**
  - *Input:* `{ "leagueIds": ["164205"], "dateFrom": "2023-09-01", "dateTo": "2023-10-29" }`
  - *Output:* a whole Rugby World Cup.

### 🔗 Integration

**JavaScript (Apify client):**

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('foxlabs/rugby-union-data').call({ dateFrom: '2023-09-01', dateTo: '2023-11-01', includePlayerStats: true });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

**Python (Apify client):**

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_TOKEN")
run = client.actor("foxlabs/rugby-union-data").call(run_input={"dateFrom": "2023-09-01", "dateTo": "2023-11-01", "includePlayerStats": True})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

**n8n / Zapier / Make:** use the Apify connector, pick this actor, map the dates and `includePlayerStats`, then route the dataset into your sheet, database or webhook.

### 📊 Pricing

**Pay per result (PPE).** You are billed only for delivered matches, never for errors or empty runs. Player box scores are included with the match when `includePlayerStats` is on. Current prices are on the Pricing tab.

### ❓ FAQ

#### Do I need an API key or a login to scrape rugby data?

No. You supply only a date range and optionally a list of leagues. There is no API key, login or browser to configure; the Actor reads a public, keyless rugby source for you through Apify's free datacenter proxy.

#### What does each match row contain?

The competition and match, the two teams with their scores, home/away and the winner, the venue, the status and the date. With `includePlayerStats`, the match also carries a `players` array.

#### What is in the player box score?

For each player: team, name, position, shirt number, whether they started, the captain flag, whether they were subbed in or out, and a `stats` object with points, tries, conversions, penalty and drop goals, kicks, clean breaks, defenders beaten, tackles and more, as published.

#### Which competitions are covered?

The major rugby union competitions — World Cup, United Rugby Championship, Super Rugby, Six Nations, Premiership, Top 14 and others. Leave `leagueIds` empty to sweep them, or pass specific ESPN league IDs.

#### How do I get player stats for only completed matches?

Turn on `includePlayerStats`. Box scores are fetched only for matches that have finished; upcoming fixtures return the match row without a `players` array.

#### How current is the data?

Every run reads ESPN live, so fixtures, scores and box scores reflect what ESPN shows at run time. Schedule it to keep a rolling feed of a competition.

#### How do I pull a whole season or tournament?

Give a date range that covers it (for example the Rugby World Cup window), optionally with that competition's `leagueId`. The Actor fetches the covering season and returns the matches in range.

#### How is billing calculated?

Pay per result: you are charged only for matches actually returned, never for an empty run or an error. Player box scores come with the match, not as a separate charge.

#### Can I export to CSV, Excel or JSON?

Yes. Download the dataset as JSON, CSV or Excel from the Apify console, or pull it from the Apify API or the dataset's `.json` endpoint for a model, a spreadsheet or an AI agent.

#### How is this different from a generic scores scraper?

A generic scraper gives the final score. This actor adds the lineup and per-player match statistics across many competitions — the player-level depth that fantasy and betting models need, not just who won.

### 🐛 Troubleshooting

- **No matches found** — widen `dateFrom`/`dateTo`; a competition may be between rounds or off-season.
- **No `players` on a match** — box scores appear only with `includePlayerStats`, and only for matches that have finished.
- **Fewer rows than `maxResults`** — `maxResults` is a cap, not a target.

### ⚠️ Trademark

Independent, third-party tool. Not affiliated with, endorsed by or connected to World Rugby, any league or ESPN. All marks belong to their owners and are used for identification only.

### ⚖️ Is it legal to scrape this data?

This actor reads publicly available, non-personal sports data (match scores, lineups and statistics) already published for public viewing. It collects no private personal data and requires no login. Use the output in line with applicable laws and the terms of the sources. When in doubt, consult a lawyer.

### 🤝 Support & contact

- 🌐 **Website:** [data.foxlabs.com.tr](https://data.foxlabs.com.tr)
- 📧 **Email:** info@foxlabs.com.tr
- 🧰 **More clean data actors:** [Fox Labs on Apify](https://apify.com/foxlabs)

### Changelog

#### 0.2 — 2026-11-02

- New `includePlayerStats` option adds per-player box scores (lineup and match statistics) for completed matches.
- Added output schema (dataset + run-report key-value live view).

#### 0.1 — 2026-11-02

- Initial release: fixtures and results across the major competitions from ESPN's keyless API.

# Changelog

This Actor's version history is a separate document: https://apify.com/foxlabs/rugby-union-data/changelog.md

# Actor input Schema

## `leagueIds` (type: `array`):

ESPN rugby league IDs to pull. Leave empty to sweep all major leagues.

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

Earliest match date. Defaults to 14 days ago.

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

Latest match date. Defaults to 21 days ahead.

## `includePlayerStats` (type: `boolean`):

For each completed match, add the per-player lineup and match statistics (one extra lookup per match). Off by default.

## `maxPlayerStatMatches` (type: `integer`):

Upper bound on how many completed matches get the heavy per-player lookup in one run (default 50). Beyond it, matches are returned without player box scores.

## `maxResults` (type: `integer`):

Cap on delivered matches (0 = default).

## `proxyConfiguration` (type: `object`):

Leave it on. Reaches ESPN through Apify's free datacenter proxy; no setup needed.

## Actor input object example

```json
{
  "leagueIds": [],
  "includePlayerStats": false,
  "maxPlayerStatMatches": 50,
  "maxResults": 100,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

No description

## `report` (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 = {
    "leagueIds": [],
    "maxResults": 100,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("foxlabs/rugby-union-data").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 = {
    "leagueIds": [],
    "maxResults": 100,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("foxlabs/rugby-union-data").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "leagueIds": [],
  "maxResults": 100,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call foxlabs/rugby-union-data --silent --output-dataset

```

## MCP server setup

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

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

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/VvZ3bzTzjh53nVVTe/builds/ll4fSqZaAWqAZyJaO/openapi.json