# Soccer Live Scores & Results – 200+ Leagues, Fixtures & Odds (`rowfeed/soccer-scores-results-scraper`) Actor

ESPN soccer scores for 200+ leagues: live/scheduled/finished matches, goals with scorers, red cards, and matched Kalshi exchange odds (home/away/draw). No login, no proxy.

- **URL**: https://apify.com/rowfeed/soccer-scores-results-scraper.md
- **Developed by:** [Rowfeed](https://apify.com/rowfeed) (community)
- **Categories:** Sports, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.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

Get live soccer scores, finished results and upcoming fixtures as one clean JSON row per match: goals with scorers, red cards, and Kalshi exchange odds (home/away/draw) joined in. Built for score-tracking bots, sports dashboards and AI agents that need current soccer data without a login, an API key or a headless browser.
Sourced straight from ESPN's own public scoreboard API - the same data that powers espn.com/soccer - across 200+ leagues and cups worldwide, so results and goal times are accurate as soon as ESPN has them.

### What you get

- **One row per match** - kickoff time, live/scheduled/finished status (with the live match clock and a best-effort halftime score), home/away teams with score and winner, venue and attendance.
- **Goals and red cards** - every goal's minute, scoring team and scorer name (plus own-goal/penalty flags), and every red card's minute, team and player - pulled straight from ESPN's match detail feed, no extra requests.
- **Kalshi odds joined in** - for English Premier League, Champions League, La Liga, Serie A, Bundesliga, Ligue 1 and MLS, each upcoming or live match gets Kalshi's home/away/draw YES-ask prices and vig-removed probabilities while the market is trading, matched by team name and kickoff date. No match found, an ambiguous one, or a market Kalshi has already settled (a settled market has no price left) simply means `kalshi: null` - this Actor never guesses a price onto the wrong fixture.
- **200+ leagues** - top domestic leagues, continental cups (Champions League, Europa League) and more, resolved live from ESPN's own league list every run. Filter to a handful of leagues or sweep everything with `"all"`.

### Sample row

One real row from a default run (`includeKalshi: true`):

```json
{
  "match_id": "761830",
  "league": { "slug": "usa.1", "name": "MLS" },
  "season_year": 2026,
  "season_slug": "regular-season",
  "kickoff": "2026-09-26T23:30Z",
  "status": "STATUS_SCHEDULED",
  "status_detail": "Sat, September 26th at 7:30 PM EDT",
  "minute": null,
  "home": { "name": "Atlanta United FC", "abbreviation": "ATL", "score": 0.0, "winner": false },
  "away": { "name": "New York City FC", "abbreviation": "NYC", "score": 0.0, "winner": false },
  "halftime_score": null,
  "goals": [],
  "red_cards": [],
  "venue": "Mercedes-Benz Stadium",
  "attendance": 0,
  "kalshi": {
    "event_ticker": "KXMLSGAME-26SEP26ATLNYC",
    "home_yes_ask": 0.43,
    "away_yes_ask": 0.32,
    "draw_yes_ask": 0.26,
    "probabilities": { "home": 0.4271, "away": 0.3166, "draw": 0.2563 },
    "url": "https://kalshi.com/markets/kxmlsgame"
  },
  "scraped_at": "2026-09-25T08:59:15+00:00",
  "url": "https://www.espn.com/soccer/match/_/gameId/761830/new-york-city-fc-atlanta-united-fc"
}
```

A finished match carries real `goals` entries too, for example: `{"minute": "57'", "team": "Liverpool", "scorer": "Alexander Isak", "own_goal": false, "penalty": false}`.

### Filters

| Input | Default | What it does |
|---|---|---|
| `leagues` | `["eng.1","esp.1","ger.1","ita.1","fra.1","uefa.champions","usa.1"]` | ESPN league slugs (Premier League, La Liga, Bundesliga, Serie A, Ligue 1, Champions League, MLS). Use `"all"` to sweep every league ESPN covers (219 measured 25.09.2026) - slower, and most contribute zero rows on a given day. An unknown slug fails the run with a helpful error listing real examples. |
| `dateFrom` / `dateTo` | `""` / `""` | YYYY-MM-DD. Both empty = today through 2 days ahead (most leagues don't play every day, so a single-day default would often be empty). Set `dateFrom` alone to pin one specific day. Capped at 31 days. |
| `status` | `all` | `all`, `live`, `upcoming` or `finished`. |
| `includeKalshi` | `true` | Join Kalshi 3-way odds for the 7 leagues Kalshi lists (see above). Off skips those requests entirely. |
| `maxMatches` | `500` | Cap on rows (1-2000). Each row is one charged `match` event. |

Leagues or date ranges with nothing scheduled simply contribute zero rows - not an error.

### Pricing

Pay per event, no subscription: **$1 per 1,000 matches** and **$1 per 1,000 run starts**. A run that finds nothing for your filters (e.g. an off day for that league) still succeeds with zero charged rows - you only pay for matches actually returned.

### Details

- **Source**: ESPN's public site API (`site.api.espn.com`) and core API (`sports.core.api.espn.com`) for the league list. No authentication, no proxies, no browser. **Not affiliated with ESPN or Kalshi.**
- **Kalshi join**: matched by normalised team name (either side, diacritics-insensitive) and kickoff date within a 30-hour window via Kalshi's public trade API (`api.elections.kalshi.com`). Only markets still trading are used. Zero or more than one candidate match means `kalshi: null` - never a guess. `kalshi.url` is a link to Kalshi's market page for people in a browser; Kalshi's website turns away scripts, so fetch prices through this Actor rather than that page.
- **Halftime score**: derived from the goal timeline (ESPN's scoreboard has no halftime field of its own), so it is `null` until a match reaches the second half and whenever it can't be derived with confidence.
- **Reliability**: 429 and 5xx responses retry with exponential backoff (5 tries), a 200 without the expected data counts as a failure, and one league's outage never stops the run - it becomes an uncharged error row and the rest continues. A run fails only when it returned zero rows *and* a request genuinely failed; a quiet day with no matches is a successful run with zero charged rows.
- **Run stats**: the `STATS` record in the run's key-value store holds matches, Kalshi-matched count, error rows, leagues swept, request and error counts per category.
- **Output**: one dataset row per match. Export as JSON, CSV or Excel, fetch through the Apify API, or schedule runs and pipe them into Google Sheets, Make, Zapier, n8n or your own code. Eligible for agentic use via Apify's MCP server.

# Actor input Schema

## `leagues` (type: `array`):

ESPN league slugs to scrape, one row per match, e.g. eng.1 (Premier League), esp.1 (La Liga), ger.1 (Bundesliga), ita.1 (Serie A), fra.1 (Ligue 1), uefa.champions (Champions League), usa.1 (MLS). Use "all" to sweep every league ESPN covers (219 on 25.09.2026) - slow, and most have no matches on a given day. An unknown slug fails the run with a helpful error listing examples.

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

Start date as YYYY-MM-DD. Empty = today (UTC).

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

End date as YYYY-MM-DD. Empty = same as "Date from" - except when Date from is ALSO empty, where it means today+2 days: most leagues don't play every day, so a single-day default would often return zero matches. Set Date from to pin a single specific day. Ranges are capped at 31 days.

## `status` (type: `string`):

Which matches to return: all, live (in progress), upcoming (not started yet) or finished.

## `includeKalshi` (type: `boolean`):

Join Kalshi exchange 3-way prices (home/away/draw) onto each match for EPL, Champions League, La Liga, Serie A, Bundesliga, Ligue 1 and MLS, matched by team names and kickoff date. Unmatched or ambiguous matches simply get kalshi: null - never guessed.

## `maxMatches` (type: `integer`):

Keep at most this many match rows. Each row is one charged `match` event.

## Actor input object example

```json
{
  "leagues": [
    "eng.1",
    "esp.1"
  ],
  "dateFrom": "",
  "dateTo": "",
  "status": "all",
  "includeKalshi": true,
  "maxMatches": 500
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("rowfeed/soccer-scores-results-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("rowfeed/soccer-scores-results-scraper").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 '{}' |
apify call rowfeed/soccer-scores-results-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,rowfeed/soccer-scores-results-scraper"
        }
    }
}
```

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/QBEYeEnqPNoq4H8wB/builds/BekkiNe1TNuxzQ1WF/openapi.json