# Athlete Intelligence Agent (`filip_cicvarek/athlete-intelligence-agent`) Actor

Give it an athlete's name, get a structured, source-cited profile: identity, career, stats, market value, social reach and news — every field with a source and confidence score. Or call the data tools directly. No AI key needed.

- **URL**: https://apify.com/filip\_cicvarek/athlete-intelligence-agent.md
- **Developed by:** [Filip Cicvárek](https://apify.com/filip_cicvarek) (community)
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.30 / athlete profile

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Athlete Intelligence Agent

**Give it an athlete's name — get back a rich, source-cited profile.** The Athlete Intelligence Agent is an **autonomous AI agent**, not a fixed scraper. Powered by Claude, it decides for itself which sources to consult: it resolves the athlete's identity and sport, then pulls career stats, market value, achievements, social reach, and recent news from free sports APIs, the open web, and specialised Apify scrapers — cross-checking sources and attaching a **confidence score and citation to every field**.

You can steer it with plain English ("focus on transfer rumours", "I'm evaluating social reach for a sponsorship deal"), or just give it a name and let it figure out the rest. Run it on the [Apify platform](https://apify.com) for API access, scheduling, integrations (Make, Zapier, Slack, Google Drive), proxy rotation, and run monitoring.

> **Why not just ask an AI chatbot?** A chatbot gives you unsourced prose from memory and can't reach the data that actually matters — follower counts behind anti-bot walls, Transfermarkt market values, or clean structured stats. This Actor pairs the same reasoning with **proxy-backed scrapers and structured sports APIs**, then returns it as a **schema-stable, batchable, source-cited dataset** you can pull via API or run on a schedule.

### What does Athlete Intelligence Agent do?

- **Resolves identity first** — uses **Wikidata + Wikipedia** to pin down the exact athlete (handling same-name ambiguity), their sport, nationality, date of birth, and official social handles.
- **Gathers sport-specific stats** from free official/structured sources: **ESPN** (NBA/WNBA, NFL, NHL, MLB and US college), the **MLB Stats API** (baseball), and the **Ergast/Jolpica F1 API** (Formula 1).
- **Adds depth where free data falls short** — **Transfermarkt** for football market value & transfers, **Google News** for recent coverage and sentiment, and **Instagram / X / TikTok / YouTube** for follower counts and influence (opt-in).
- **Falls back to open-web search** (Apify RAG Web Browser for search, Web Fetch for reading a specific page) for any sport or fact the structured sources miss — so niche athletes still get a profile.
- **Synthesises one structured profile** with per-field provenance, an overall confidence score, and a completeness percentage.

### Why use Athlete Intelligence Agent?

No single database covers every athlete and every sport. Analysts, journalists, scouts, and marketers normally stitch together Wikipedia, ESPN, Transfermarkt, and social platforms by hand. This agent does that work autonomously and **shows its sources**, so you can trust (or challenge) every value.

Typical buyers:

- **Sports journalists & media** — instant, sourced player backgrounders and comparisons.
- **Scouts, agents & clubs** — career trajectory, market value, and availability at a glance.
- **Sponsorship & brand-marketing agencies** — social reach, engagement, and influence scoring for athlete-brand fit.
- **Fantasy & sports-betting products** — enriched player context and recent news/injury signals.
- **Fan apps & media platforms** — ready-made athlete profiles to drive engagement.

### How to use Athlete Intelligence Agent

1. Open the Actor and enter an **athlete name** (e.g. `Carlos Alcaraz`).
2. *(Optional)* Add **instructions** to emphasise what you care about, and a **sport hint** if the name is ambiguous.
3. *(Optional)* Pick a **depth**: `quick` (free only), `standard` (recommended), or `deep` (adds social media).
4. Click **Start**. When the run finishes, open the **Output** tab to see the profile, or pull it via the API/integrations.

### Input

| Field | Type | Description |
|---|---|---|
| `operation` | enum | `profile` (default) for the full AI-built profile, or a single lookup: `identity`, `stats`, `market`, `news`, `social`, `search`, `crawl`. |
| `athleteName` | string | The athlete to research. |
| `instructions` | string | Free-text steer for emphasis / source priority. |
| `sportHint` | string | Disambiguates same-name athletes (e.g. `tennis`). |
| `depth` | enum | `quick` / `standard` / `deep`. Default `standard`. |
| `enableSocial` | boolean | Scrape social media follower counts. Leave unset to follow the depth preset (ON for `deep`). |
| `costCapUsd` | number | Soft ceiling on combined LLM + scraper spend per run. |
| `maxIterations` | integer | Hard ceiling on agent reasoning steps (≤ 20). |
| `model` | enum | Claude model. Default `claude-opus-4-8`. |
| `query` | string | For the `news` and `search` lookups. Defaults to the athlete name. |
| `url` | string | For the `crawl` lookup. |
| `platform` / `handle` | string | For the `social` lookup. |
| `maxResults` | integer | For the `news` and `search` lookups. |
| `anthropicApiKey` | string (secret) | Optional. Leave empty — no AI account needed (see Pricing). |

```json
{
  "athleteName": "Kylian Mbappé",
  "instructions": "Focus on market value, recent transfers, and social reach.",
  "depth": "standard"
}
```

### Output

**Single lookups** (`operation` other than `profile`) write one raw source envelope:

```json
{ "ok": true, "source": "Wikidata", "layer": 0, "url": "https://www.wikidata.org/wiki/Q85518537",
  "fetchedAt": "2026-09-14T17:41:02Z",
  "data": { "canonicalName": "Carlos Alcaraz", "sport": "tennis", "nationality": "Spain" } }
```

**Full profiles** write one dataset item per athlete. Download as **JSON, CSV, Excel, or HTML**. Simplified example:

```json
{
  "identity": { "canonicalName": "Kylian Mbappé", "sport": "association football", "nationality": "France", "dateOfBirth": "1998-12-20" },
  "team": { "currentTeam": "Real Madrid", "league": "La Liga" },
  "statistics": { "career": { "goals": 320, "appearances": 420 } },
  "market": { "estimatedValueUsd": 180000000, "valueAsOf": "2026-06" },
  "social": { "profiles": [{ "platform": "instagram", "followers": 122000000, "verified": true }], "totalReach": 150000000, "influenceScore": 98 },
  "news": { "overallSentiment": "positive", "recentHeadlines": [{ "title": "...", "source": "...", "sentiment": "positive" }] },
  "meta": { "overallConfidence": 88, "completenessPct": 83, "sources": [{ "field": "market.estimatedValueUsd", "source": "Transfermarkt", "confidence": 80, "url": "..." }] }
}
```

#### Data fields

| Group | Contents |
|---|---|
| `identity` | name, Wikidata QID, DOB, age, nationality, birthplace, sport, status |
| `physical` | height, weight, dominant hand/foot, position(s), playing style |
| `team` | current team, league, shirt number, contract end, coach |
| `careerHistory` | chronological stints: team, dates, appearances, transfer fee/type |
| `statistics` | sport-specific career totals + season breakdown |
| `achievements` | titles, individual awards, records, international caps/goals |
| `market` | estimated value (USD), value timeline, salary estimate |
| `social` | per-platform handles, followers, verification, total reach, influence score |
| `news` | recent headlines with source, date, sentiment, topic |
| `endorsements` | known sponsors & categories (confidence-tagged) |
| `meta` | per-field sources + confidence, overall confidence, completeness, tokens, cost |

The full raw evidence trail (every source call the agent made) is saved to the run's **key-value store** under `evidence` for auditing.

### Pricing & cost

This Actor uses **pay-per-event** pricing. You are charged for what you ask for:

| You run | You're charged |
|---|---|
| A full profile | `profile-emitted`, once — at 1x for `quick`, 2x for `standard`, 3x for `deep` |
| A single lookup (`operation` other than `profile`) | `tool-call`, once |
| Any run | the standard Apify start event |

Deeper research calls more paid sources, which is why it costs proportionally more.

**Everything runs on your Apify account**, so there is a second layer: the platform usage
of this Actor and of every sub-Actor it calls. Measured on real runs:

| Run | Total platform cost |
|---|---|
| `quick`, Haiku, a tennis player | **~$0.20** |
| `deep`, Opus, a footballer | **~$0.49** |
| `deep`, Sonnet, a footballer | **~$0.56** |

On a deep footballer the two big line items are the LLM (~$0.21) and Transfermarkt
(~$0.20); Transfermarkt varies significantly run to run. Single lookups are far cheaper —
typically under $0.01, except `market`, which pays Transfermarkt.

**No AI account needed.** By default the Actor reaches Claude through Apify's first-party
[`apify/openrouter`](https://apify.com/apify/openrouter) proxy, billed to your Apify
account in credits with everything else. Supply `anthropicApiKey` only if you'd rather the
LLM cost went to your own Anthropic account.

The `costCapUsd` input is a **soft ceiling** on combined LLM + sub-Actor spend during one
profile: when reached, the agent stops gathering and emits what it has.

### Tips

- **Cheaper runs**: choose `depth: quick`, lower `costCapUsd`, or `model: claude-haiku-4-5`. For one specific fact, use a single lookup (`operation`) instead of a full profile — it skips the AI entirely.
- **Ambiguous names**: set `sportHint` (e.g. two athletes named "Chris Wood" — add `"soccer"`).
- **Sponsorship analysis**: set `depth: deep` (or `enableSocial: true`) for follower counts and influence scoring.
- **No AI account required**: leave `anthropicApiKey` empty and Claude is reached via Apify's `apify/openrouter` proxy, billed in Apify credits. Set the key only to move that cost to your own Anthropic account.
- **Running with a scoped API token?** Apify doesn't support restricted-access scoped tokens against Standby Actors, and the LLM proxy is one. If the run fails to reach it, use a normal token or supply your own `anthropicApiKey`. Single lookups (`operation` other than `profile`) are unaffected.

### FAQ, disclaimers & support

- **Which sports are supported?** Basketball (NBA/WNBA), NFL, NHL, MLB and US college have first-class structured stats via ESPN; baseball also via the MLB Stats API; Formula 1 via Ergast/Jolpica. **Football/soccer, tennis and everything else** are covered by Wikidata identity plus open-web search and, for footballers, Transfermarkt market data — expect a good profile, but not a full season-by-season stat line.
- **Why is some data missing or marked low-confidence?** Public sources disagree and have gaps. The agent reports honest completeness/confidence rather than inventing data; conflicts are noted in `meta`.
- **Legality**: This Actor aggregates publicly available information and attributes its sources. You are responsible for using the output in compliance with the source sites' Terms of Service and applicable data-protection laws. Inferred endorsements are flagged as low confidence.
- **Feedback / bugs**: please open an issue from the Actor's **Issues** tab.

### Use it as a tool server (Standby)

The Actor also runs in [Apify Standby](https://docs.apify.com/actors/running/standby) mode as an HTTP tool server. **Every tool endpoint runs with no AI key at all** — point your own agent at them and let it do the reasoning:

| Endpoint | Returns |
|---|---|
| `GET /identity?name=` | Wikidata identity: QID, DOB, nationality, sport, social handles, same-name candidates |
| `GET /stats?name=&sport=` | Career stats (ESPN / MLB Stats API / Ergast-Jolpica F1) |
| `GET /market?name=` | Transfermarkt market value & transfers (football). Priced separately — Transfermarkt is the one expensive source. |
| `GET /news?query=` | Recent news |
| `GET /social?platform=&handle=` | Follower count & verification |
| `GET /search?query=` | Web search as Markdown |
| `GET /crawl?url=` | Read one page (via Apify Web Fetch) |
| `GET /profile?athleteName=` | The full agent-built profile |

Browse and try them on the Actor's **Standby** tab, or reach them from any AI agent through [Apify's MCP server](https://mcp.apify.com).

> Note for operators: configure the `profile-emitted`, `tool-call` and `market-lookup` pay-per-event meters in the Apify Console before publishing. Keep the synthetic `apify-actor-start` event, and **delete** the synthetic `apify-default-dataset-item` event — it would double-charge alongside `profile-emitted`.

# Actor input Schema

## `operation` (type: `string`):

**Full profile** runs the AI agent across every source and returns one complete, source-cited athlete profile. The other options are single lookups — no AI involved, much cheaper, and they return raw structured data for your own app or agent. The same options are available as HTTP endpoints in Standby mode.

## `athleteName` (type: `string`):

The athlete to research. A name alone works; the agent disambiguates and figures out the sport.

## `instructions` (type: `string`):

Free-text guidance on what to emphasise, e.g. 'focus on transfer rumours and market value' or 'I'm evaluating social reach for a sponsorship deal'. Steers emphasis and source priority; the output structure stays fixed.

## `sportHint` (type: `string`):

Helps disambiguate athletes who share a name. e.g. 'tennis', 'soccer', 'basketball'. Leave empty to let the agent infer it.

## `depth` (type: `string`):

How hard the agent works on a full profile. **quick** uses free structured sources plus web search. **standard** adds Transfermarkt market value (football) and recent news. **deep** adds social-media follower scraping. Deeper research calls more paid sources, so it costs proportionally more per profile (quick 1x, standard 2x, deep 5x) and takes longer. Only applies when 'What do you want?' is set to Full profile.

## `enableSocial` (type: `boolean`):

Fetch Instagram/X/TikTok/YouTube follower counts for handles found during research. Leave unset to follow the depth preset (on for 'deep', off otherwise). Adds pass-through scraping cost.

## `costCapUsd` (type: `number`):

Safety ceiling on what the agent spends on LLM calls and paid sub-Actors while building one profile. When reached, it stops gathering and emits what it has. Leave empty to use the depth default (quick $0.50, standard $1.50, deep $5).

## `maxIterations` (type: `integer`):

Hard ceiling on agent reasoning steps (tool-call rounds). Backstop against runaway loops. Leave empty to use the depth default (quick 8, standard 12, deep 18).

## `model` (type: `string`):

LLM that orchestrates the research and writes the final profile. Opus is the default and, on measured runs, is not more expensive overall — cheaper models tend to compensate with extra searches. Haiku is genuinely cheapest and fine for well-covered athletes.

## `anthropicApiKey` (type: `string`):

**Leave this empty for the normal case.** By default the Actor reaches Claude through Apify's own `apify/openrouter` proxy, so you need no AI provider account at all and the LLM usage is billed to your Apify account in credits. Supply your own Anthropic key only if you would rather the LLM cost went to your Anthropic account instead.

## `query` (type: `string`):

For the 'Recent news' and 'Web search' lookups. Defaults to the athlete name.

## `url` (type: `string`):

For the 'Read one page' lookup.

## `platform` (type: `string`):

For the 'Social followers' lookup.

## `handle` (type: `string`):

For the 'Social followers' lookup. Without the @.

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

For the news and web-search lookups.

## Actor input object example

```json
{
  "operation": "profile",
  "athleteName": "Carlos Alcaraz",
  "depth": "standard",
  "model": "claude-opus-4-8"
}
```

# Actor output Schema

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

Athlete profiles, or raw source envelopes for single lookups.

## `evidence` (type: `string`):

Every source call the agent made during a profile run, for auditing.

# 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 = {
    "athleteName": "Lionel Messi",
    "instructions": "",
    "sportHint": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("filip_cicvarek/athlete-intelligence-agent").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 = {
    "athleteName": "Lionel Messi",
    "instructions": "",
    "sportHint": "",
}

# Run the Actor and wait for it to finish
run = client.actor("filip_cicvarek/athlete-intelligence-agent").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 '{
  "athleteName": "Lionel Messi",
  "instructions": "",
  "sportHint": ""
}' |
apify call filip_cicvarek/athlete-intelligence-agent --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,filip_cicvarek/athlete-intelligence-agent"
        }
    }
}
```

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/laUsUAP6nGaP4H0Qe/builds/Y0LPMpQ0584pRWar4/openapi.json