# Sofascore Scraper - Teams, Players, Matches, No Login (`gio21/sofascore-scraper`) Actor

Search Sofascore by team, player or league keyword and get back the entity plus fixtures with scores. Flat $0.003 per result, no extra fees, no login needed.

- **URL**: https://apify.com/gio21/sofascore-scraper.md
- **Developed by:** [Gio](https://apify.com/gio21) (community)
- **Categories:** News
- **Features:** Limited permissions
- **Stats:** 65 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$3.00 / 1,000 result scrapeds

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

## Sofascore Scraper - Teams, Players, Matches, No Login

### Why use this scraper

Sofascore is the fastest-updating sports data site on the web for football,
basketball, tennis and dozens of other sports, but it has no public API and
its pages are rendered from a heavily obfuscated internal JSON feed that
changes often. Anyone who wants Sofascore data in a spreadsheet, a betting
model, a fan app or a content pipeline either reverse-engineers that feed
themselves or pays someone who already did. This actor does that work for
you: give it a single search keyword and it resolves the entity (team,
player or tournament), returns clean structured JSON, and, for teams, also
pulls the recent and upcoming fixtures with live or final scores. No login,
no cookies, no browser automation to maintain.

### Overview

Input is one search term per call (run it with an array of terms via
Apify's input list, or fan out multiple runs for a full roster). Output is
one JSON item per match for the top entity that the search resolves to,
plus one item per fixture when the entity is a team and fixtures are
requested. A typical single-team search with fixtures completes in a few
seconds and returns between 1 and ~20 items depending on how many recent
and upcoming matches the team has. You are billed per result item, not per
page load or per minute of run time, so a search that resolves to one
player costs a fraction of a cent.

### Supported inputs

- **Team name** (e.g. `"Manchester City"`, `"Real Madrid"`) - returns the
  team entity and, when `includeMatches` is on, its recent and upcoming
  fixtures with scores.
- **Player name** (e.g. `"Erling Haaland"`, `"Djokovic"`) - returns the
  player entity: Sofascore id, slug, country, and follower count
  (`userCount`).
- **Tournament or league name** (e.g. `"Premier League"`, `"Champions
  League"`) - returns the tournament entity with its Sofascore id and URL.
- **maxItems** caps the total items returned per run, useful for keeping a
  single call cheap while testing.

### Use cases

- **Betting and prediction models:** pull a team's last and next fixtures
  with final or live scores as one of your model's structured inputs.
- **Sports stats dashboards:** track form across a season for any team by
  re-running the same keyword on a schedule.
- **Fan and content apps:** resolve a player or team name typed by a user
  straight to a Sofascore id, slug and canonical URL for deep linking.
- **Scouting and research:** look up a tournament or player and get back
  the exact entity Sofascore tracks, disambiguated from similarly named
  teams in other sports or countries.
- **Sports journalism automation:** feed match results into recap or
  preview generation without manually checking scores.

### How it works

The actor queries Sofascore's own public search endpoint for the keyword,
takes the best-matching entity (team, player or tournament), and normalizes
it into one flat JSON record with a consistent set of fields across all
three entity types. When the top match is a team and `includeMatches` is
`true`, it makes a second call for that team's event list and emits one
record per fixture, with home and away team names, score and match status
already parsed out instead of left as nested Sofascore internals. This
means you get the same field names (`name`, `score`, `startTime`, `url`...)
no matter whether you searched for a team, a player or a league, so
downstream code does not need a different parser per entity type.

### Input configuration

Team search with fixtures:

```json
{
  "searchTerm": "Manchester City",
  "includeMatches": true,
  "maxItems": 50
}
```

Player search (fixtures are skipped automatically for non-team entities):

```json
{
  "searchTerm": "Erling Haaland",
  "includeMatches": true,
  "maxItems": 10
}
```

Team entity only, no fixtures, for a lighter and cheaper run:

```json
{
  "searchTerm": "Real Madrid",
  "includeMatches": false,
  "maxItems": 1
}
```

Tournament lookup:

```json
{
  "searchTerm": "Premier League",
  "includeMatches": false,
  "maxItems": 5
}
```

### Output sample

Real items from a production run (October 2026), searching `"Manchester
City"`:

```json
[
  {
    "type": "team",
    "name": "Manchester City",
    "sport": "Football",
    "country": "England",
    "team": null,
    "homeTeam": null,
    "awayTeam": null,
    "score": null,
    "startTime": null,
    "userCount": 4417170,
    "sofascoreId": 17,
    "slug": "manchester-city",
    "url": "https://www.sofascore.com/team/manchester-city/17",
    "searchTerm": "Manchester City",
    "scrapedAt": "2026-10-02T09:25:25.847Z"
  },
  {
    "type": "player",
    "name": "Erling Haaland",
    "sport": null,
    "country": "Norway",
    "team": "Manchester City",
    "homeTeam": null,
    "awayTeam": null,
    "score": null,
    "startTime": null,
    "userCount": 1136426,
    "sofascoreId": 839956,
    "slug": "erling-haaland",
    "url": "https://www.sofascore.com/player/erling-haaland/839956",
    "searchTerm": "Manchester City",
    "scrapedAt": "2026-10-02T09:25:25.847Z"
  },
  {
    "type": "player",
    "name": "Enzo Fernández",
    "sport": null,
    "country": "Argentina",
    "team": "Manchester City",
    "homeTeam": null,
    "awayTeam": null,
    "score": null,
    "startTime": null,
    "userCount": 168150,
    "sofascoreId": 974505,
    "slug": "enzo-fernandez",
    "url": "https://www.sofascore.com/player/enzo-fernandez/974505",
    "searchTerm": "Manchester City",
    "scrapedAt": "2026-10-02T09:25:25.847Z"
  }
]
```

When `includeMatches` resolves fixtures for a team, each fixture item adds
`tournament`, `homeTeam`, `awayTeam`, `score` (e.g. `"2-1"` or `null` for a
match not yet played), `statusType` and `statusDescription` on top of the
same base shape.

### Key output fields

| Field | Type | Description |
|---|---|---|
| `type` | string | `team`, `player`, `tournament` or `match`. |
| `name` | string | Display name of the entity, or `"Home vs Away"` for a match. |
| `sport` | string/null | Sport name, when available for the entity. |
| `country` | string/null | Country associated with the entity. |
| `team` | string/null | Club name, for player entities. |
| `tournament` | string/null | League or competition name, for match items. |
| `homeTeam` / `awayTeam` | string/null | Set only on match items. |
| `score` | string/null | `"home-away"` goals/points, `null` if not played yet. |
| `statusType` / `statusDescription` | string/null | Match state (e.g. finished, not started) and its label. |
| `startTime` | string/null | ISO timestamp of kickoff, for match items. |
| `userCount` | integer/null | Sofascore follower count for the entity. |
| `sofascoreId` | integer | Sofascore's internal id for the entity or event. |
| `slug` | string/null | URL slug used by Sofascore. |
| `url` | string | Canonical Sofascore URL for the entity or match. |
| `searchTerm` | string | The keyword you searched, echoed back for traceability. |
| `scrapedAt` | string | ISO timestamp of when the item was scraped. |

### Pricing

| Event | Price |
|---|---|
| Result scraped (each team, player, tournament or match item) | $0.003 |

Pay per result only. No charge for a search that returns 0 results, and no
separate charge for fetching a team's fixtures beyond the fixture items
themselves.

### What makes this richer than the competition

Two other Sofascore scrapers on the Apify Store, by users in the last 30
days: `abotapi/sofascore-scraper` (72) and `scrapesmith/sofascore-scraper`
(23). Both expose a much wider field set (odds, lineups, standings) aimed
at users who already know the exact match or team URL they want. This
actor is built for the opposite entry point: one plain-text keyword in,
with automatic resolution to the right team, player or tournament and,
for a team, its fixtures in the same call, no URL hunting required.
On price, `abotapi/sofascore-scraper` charges a per-result base of $0.002
to $0.001 (tiered by plan) plus a separate fee per "detail enrichment"
page, and `scrapesmith/sofascore-scraper` adds a flat $0.005 actor-start
fee on top of its per-result price. This actor charges one flat $0.003 per
result and nothing else, so the final bill is predictable before you run
it.

### Notes & limitations

- The actor returns the single best-matching entity for your keyword, not
  a full search results list. A precise `searchTerm` (full team or player
  name) gives the most reliable match.
- Fixtures (`includeMatches`) only populate when the resolved entity is a
  team; player and tournament searches return the entity record only.
- `score` is `null` for fixtures that have not been played yet and for all
  non-match items.
- Sofascore runs bot protection on its search endpoint. A run can
  occasionally come back with a `warning` item and 0 real results if a
  request gets blocked; simply re-running the same search normally
  succeeds. This actor does not retry automatically within a single run.
- Only the top-level entity is scraped: full player career stats, team
  rosters beyond what the search endpoint returns, or odds are not part of
  this actor's output.

### FAQ

**Does this need a Sofascore account or login?**
No. Every field comes from Sofascore's public search, which is open
without authentication.

**Can I search for a league or cup instead of a team?**
Yes, `searchTerm` accepts tournament and competition names and returns a
`tournament` type item with its Sofascore id and URL.

**Why did my run return a `warning` and no data?**
Sofascore's bot protection blocked that specific request. Re-run the same
search; it typically succeeds on a retry.

**Can I get a full season schedule for a team?**
`includeMatches` returns the team's recent and upcoming fixtures as
Sofascore currently lists them, not a full historical season archive.

**Does `maxItems` limit fixtures separately from the team entity?**
No, `maxItems` caps the total item count for the run, team or player entity
included.

**Is the score live or only final?**
Both. `statusType` and `statusDescription` tell you whether a match is
finished, in progress or not started yet, and `score` reflects the current
state.

### For AI Agents & LLM Apps

This actor is callable directly from an MCP-compatible client at
`mcp.apify.com`, or via the standard Apify API. Example with the
run-sync-get-dataset-items endpoint, which runs the actor and returns the
dataset items in one call:

```bash
curl "https://api.apify.com/v2/acts/gio21~sofascore-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searchTerm": "Manchester City", "includeMatches": true, "maxItems": 10}'
```

### Disclaimer

This Actor is an independent tool and is not affiliated with, endorsed by,
or sponsored by Sofascore or any of its subsidiaries. All trademarks
mentioned are the property of their respective owners.

### SEO Keywords

sofascore scraper, sofascore api, football scores scraper, live sports
scores api, team fixtures scraper, sports data scraper

# Actor input Schema

## `searchTerm` (type: `string`):

Team, player, tournament or league to search (e.g. "Real Madrid", "Djokovic", "Premier League").

## `includeMatches` (type: `boolean`):

When the top match is a team, also fetch its recent and upcoming matches with scores.

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

Maximum number of items to return.

## Actor input object example

```json
{
  "searchTerm": "Real Madrid",
  "includeMatches": true,
  "maxItems": 10
}
```

# Actor output Schema

## `results` (type: `string`):

All scraped items.

# 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 = {
    "searchTerm": "Real Madrid",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("gio21/sofascore-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 = {
    "searchTerm": "Real Madrid",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("gio21/sofascore-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 '{
  "searchTerm": "Real Madrid",
  "maxItems": 10
}' |
apify call gio21/sofascore-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,gio21/sofascore-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/zjIec1OLlElW7BPsL/builds/oaPoUzRZBapg1ezVp/openapi.json