# Teamfight Tactics MCP Server - AI Game Analysis (`mrbridge/tft-mcp-server`) Actor
Connect AI assistants to Teamfight Tactics (TFT) data via MCP. 13 tools for player profiles, ranked stats, match history, champion mastery, live game, player comparison & AI-powered performance analysis. Works with Claude Desktop, ChatGPT & any MCP-compatible AI agent.
- **URL**: https://apify.com/mrbridge/tft-mcp-server.md
- **Developed by:** [MrBridge](https://apify.com/mrbridge) (community)
- **Categories:** AI, MCP servers, Integrations
- **Stats:** 14 total users, 3 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: 5.00 out of 5 stars
## Pricing
from $3.00 / 1,000 data retrievals
This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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
## Teamfight Tactics MCP Server - AI Game Analysis
Connect AI assistants to Teamfight Tactics (TFT) data via Model Context Protocol. Let AI analyze your performance, identify weaknesses & suggest optimal strategies. Access player profiles, match history, ranked stats & champion mastery.
### Features
- **Player Profiles** - Search players by Riot ID (gameName#tagLine) across all regions
- **Ranked Stats** - Get tier, rank, LP, win/loss ratio and league standings
- **Match History** - Retrieve recent TFT matches with detailed statistics
- **Champion Mastery** - View mastery levels, points and top champions
- **Performance Analysis** - Let AI analyze your gameplay and suggest improvements
- **Live Game** - Check if a player is currently in a TFT match
- **Player Comparison** - Compare stats between two players
- **Data Dragon Integration** - Champion, item, rune and spell names automatically resolved
- **Intelligent Caching** - Reduces API calls with smart TTL-based caching
- **Multi-Region Support** - EUW, NA, KR, BR, and all other servers
### Quick Start
#### 1. Get your Riot API Key
1. Go to [Riot Developer Portal](https://developer.riotgames.com/)
2. Log in with your **Riot Games account**
3. Copy your **Development API Key** from the dashboard
> Development keys expire every **24 hours**. For permanent access, apply for a Personal key.
#### 2. Configure the Actor
1. Go to the [TFT MCP Server](https://apify.com/mrbridge/tft-mcp-server?fpr=mrbridge) on Apify
2. Enter your **Riot API Key** in the Input tab
3. Click **Save**
#### 3. Connect to Claude Desktop
1. Open **Claude Desktop** → **Settings** → **Connectors**
2. Click **Add Custom Connector**
3. Paste this URL:
````
https://mrbridge--tft-mcp-server.apify.actor/mcp?token=YOUR\_APIFY\_TOKEN
````
Replace `YOUR_APIFY_TOKEN` with your [Apify API token](https://console.apify.com/account/integrations).
That's it! Claude can now access your Teamfight Tactics data.
### Available Tools
Once connected, your AI assistant can use these tools:
| Tool | Description |
|------|-------------|
| `tft_get_account` | Get account info by Riot ID (gameName#tagLine) |
| `tft_get_summoner` | Get summoner info (level, profile icon) |
| `tft_get_ranked` | Get TFT ranked stats (tier, rank, LP, wins/losses) |
| `tft_get_match_history` | Get list of recent TFT match IDs |
| `tft_get_match_details` | Get detailed info about a specific TFT match |
| `tft_get_match_timeline` | Get minute-by-minute match timeline |
| `tft_get_champion_mastery` | Get champion mastery data |
| `tft_get_player_profile` | Get complete player profile in one call |
| `tft_get_live_game` | Check if a player is currently in a TFT game |
| `tft_analyze_performance` | Analyze recent performance with recommendations |
| `tft_analyze_champion` | Analyze performance on a specific champion |
| `tft_get_improvement_tips` | Get personalized improvement tips |
| `tft_compare_players` | Compare stats between two players |
### What can AI do with your TFT data?
#### Post-game coaching
> "I just lost 3 games in a row. Analyze what went wrong — am I repeating the same mistakes?"
#### Champion pool optimization
> "Based on my last 50 games, which 3 champions should I focus on to climb fastest?"
#### Duo synergy analysis
> "Compare me and my duo partner. What are our strengths together? What should we work on?"
#### Improvement tracking
> "Compare my stats from this week vs last week. Am I getting better or stuck?"
#### Live scouting
> "I'm in game right now. Look up my opponents and tell me what to watch out for."
### Supported Regions
| Region Code | Server |
|-------------|--------|
| `euw1` | Europe West |
| `eun1` | Europe Nordic & East |
| `na1` | North America |
| `kr` | Korea |
| `br1` | Brazil |
| `la1` | Latin America North |
| `la2` | Latin America South |
| `oc1` | Oceania |
| `tr1` | Turkey |
| `ru` | Russia |
| `jp1` | Japan |
| `ph2` | Philippines |
| `sg2` | Singapore |
| `th2` | Thailand |
| `tw2` | Taiwan |
| `vn2` | Vietnam |
### API Key Types
#### Development Key (Default)
- Automatically generated when you sign in
- Expires every 24 hours
- Good for testing and personal use
- Rate limit: 20 requests / second, 100 requests / 2 minutes
#### Personal Key
- Does not expire
- For personal projects or small communities
- Register your product at [developer.riotgames.com](https://developer.riotgames.com/)
#### Production Key
- Higher rate limits
- For public applications
- Requires product approval from Riot
### Input Configuration
| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `riotApiKey` | string | Yes | Your Riot Games API key |
| `defaultRegion` | string | No | Default region (default: `euw1`) |
| `defaultLanguage` | string | No | Language for analysis (default: `en`) |
| `cacheEnabled` | boolean | No | Enable intelligent caching (default: `true`) |
### Output
The MCP server exposes Teamfight Tactics data through the Model Context Protocol, allowing any MCP-compatible AI assistant to:
- Query player information in real-time
- Analyze match statistics
- Provide personalized coaching advice
- Track progress over time
### Privacy & Security
- Your Riot API key is only used to authenticate requests to Riot's API
- No player data is stored permanently
- All requests are made directly to Riot Games' official API
- This Actor complies with [Riot Games API Terms of Service](https://developer.riotgames.com/terms)
### Troubleshooting
#### "API Key Invalid" Error
- Check that your API key hasn't expired (development keys last 24h)
- Regenerate your key at [developer.riotgames.com](https://developer.riotgames.com/)
#### "Player Not Found" Error
- Verify the Riot ID format: `gameName#tagLine` (e.g., `Faker#KR1`)
- Check you're using the correct region
- The player may have changed their name recently
#### Claude Desktop Not Connecting
- Ensure you're using the full URL with `/mcp` path
- Verify your Apify token is valid at [console.apify.com](https://console.apify.com/account/integrations)
- Restart Claude Desktop after configuration changes
- The server may need a few seconds to start on first connection (cold start)
### How much does it cost?
This MCP server uses Apify's pay-per-event pricing. You only pay for the tools you actually use:
| Operation | Price | Examples |
|-----------|-------|----------|
| **Read** | $0.003 | tft_get_account, tft_get_summoner, tft_get_ranked, tft_get_champion_mastery |
| **Match** | $0.005 | tft_get_match_history, tft_get_match_details, tft_get_match_timeline, tft_get_player_profile, tft_get_live_game |
| **Analysis** | $0.015 | tft_analyze_performance, tft_analyze_champion, tft_get_improvement_tips, tft_compare_players |
**Free tier**: Apify gives you $5 free credits every month — enough for hundreds of tool calls.
**Example costs**:
- Quick player lookup (2 reads): ~$0.006
- Match history review (1 read + 3 match): ~$0.018
- Full performance analysis with AI (2 reads + 2 match + 2 analysis): ~$0.046
- Detailed coaching session (4 reads + 4 match + 3 analysis + 1 compare): ~$0.102
### FAQ
#### Do I need a Riot Games account?
Yes. You need a Riot Games account to generate an API key at [developer.riotgames.com](https://developer.riotgames.com/).
#### Does the development API key expire?
Yes, development keys expire every 24 hours. You need to regenerate your key daily. For permanent access, apply for a Personal API key through the Riot Developer Portal.
#### Does this work with ChatGPT?
Yes. Any MCP-compatible AI client can connect to this server. It works with Claude Desktop, ChatGPT, and other AI agents that support the Model Context Protocol.
#### Is my data stored?
No. The server processes requests in real-time and does not store any player data permanently. All data is fetched directly from Riot Games' official API.
#### Which regions are supported?
All regions are supported: EUW, EUNE, NA, KR, BR, LAN, LAS, OCE, TR, RU, JP, PH, SG, TH, TW, VN.
#### Can I analyze other players?
Yes. You can look up any player's public data by providing their Riot ID (gameName#tagLine). No special permissions are needed for public data.
### Connect from Cursor IDE
Add to your Cursor MCP settings (`.cursor/mcp.json`):
```json
{
"mcpServers": {
"tft": {
"url": "https://mrbridge--tft-mcp-server.apify.actor/mcp?token=YOUR_APIFY_TOKEN"
}
}
}
````
***
### Connect from Windsurf
In Windsurf, go to **Settings → MCP** and add:
```
https://mrbridge--tft-mcp-server.apify.actor/mcp?token=YOUR_APIFY_TOKEN
```
***
### Connect from VS Code (Copilot, Cline, Continue)
#### GitHub Copilot (VS Code)
Add to your `.vscode/mcp.json`:
```json
{
"servers": {
"tft": {
"type": "http",
"url": "https://mrbridge--tft-mcp-server.apify.actor/mcp?token=YOUR_APIFY_TOKEN"
}
}
}
```
#### Cline Extension
In Cline settings → **MCP Servers → Remote Servers**, add the URL above.
#### Continue Extension
Add to `.continue/config.yaml`:
```yaml
mcpServers:
- name: tft
url: https://mrbridge--tft-mcp-server.apify.actor/mcp?token=YOUR_APIFY_TOKEN
```
***
### Integrate with Zapier, Make & n8n
#### Zapier
Use the [Apify Zapier integration](https://zapier.com/apps/apify):
1. Add "Apify" trigger → "Run Actor" with Actor ID `MlStLtYJbY5S4HItj`
2. Connect to Discord, Slack, Google Sheets, or 5,000+ other apps
#### Make (Integromat)
Use the [Apify Make integration](https://www.make.com/en/integrations/apify):
1. Add "Apify" module → "Run an Actor" → Actor ID `MlStLtYJbY5S4HItj`
#### n8n
Use the [Apify n8n node](https://docs.n8n.io/integrations/builtin/app-nodes/n8n-nodes-base.apify/) or:
```
POST https://api.apify.com/v2/acts/mrbridge~tft-mcp-server/runs?token=YOUR_APIFY_TOKEN
```
***
### Resources
- [Riot Developer Portal](https://developer.riotgames.com/)
- [Riot API Documentation](https://developer.riotgames.com/apis)
- [Claude Desktop MCP Setup](https://docs.anthropic.com/en/docs/agents-and-tools/mcp)
- [Apify MCP Documentation](https://docs.apify.com/platform/integrations/mcp)
### License
This Actor is provided as-is for educational and personal use. Usage must comply with [Riot Games API Terms and Conditions](https://developer.riotgames.com/terms).
***
**Built for the Teamfight Tactics community**
# Actor input Schema
## `riotApiKey` (type: `string`):
Free key from developer.riotgames.com — log in with your Riot account and copy the key. Takes 30 seconds. Development keys expire every 24h.
## `defaultRegion` (type: `string`):
Select your primary game server.
## `defaultLanguage` (type: `string`):
Language for AI-generated analysis and recommendations.
## `cacheEnabled` (type: `boolean`):
Cache reduces API calls and improves response times. Recommended: enabled.
## Actor input object example
```json
{
"defaultRegion": "euw1",
"defaultLanguage": "en",
"cacheEnabled": true
}
```
# Actor output Schema
## `runUrl` (type: `string`):
Link to the Actor run details page
# 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 '' with your token
const client = new ApifyClient({
token: '',
});
// Prepare Actor input
const input = {};
// Run the Actor and wait for it to finish
const run = await client.actor("mrbridge/tft-mcp-server").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 '' with your token.
client = ApifyClient("")
# Prepare the Actor input
run_input = {}
# Run the Actor and wait for it to finish
run = client.actor("mrbridge/tft-mcp-server").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 '{}' |
apify call mrbridge/tft-mcp-server --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"command": "npx",
"args": [
"mcp-remote",
"https://mcp.apify.com/?tools=mrbridge/tft-mcp-server",
"--header",
"Authorization: Bearer "
]
}
}
}
```
## OpenAPI specification
```json
{
"openapi": "3.0.1",
"info": {
"title": "Teamfight Tactics MCP Server - AI Game Analysis",
"description": "Connect AI assistants to Teamfight Tactics (TFT) data via MCP. 13 tools for player profiles, ranked stats, match history, champion mastery, live game, player comparison & AI-powered performance analysis. Works with Claude Desktop, ChatGPT & any MCP-compatible AI agent.",
"version": "2.0",
"x-build-id": "WOH7iFgf8MwyqVPKM"
},
"servers": [
{
"url": "https://api.apify.com/v2"
}
],
"paths": {
"/acts/mrbridge~tft-mcp-server/run-sync-get-dataset-items": {
"post": {
"operationId": "run-sync-get-dataset-items-mrbridge-tft-mcp-server",
"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/mrbridge~tft-mcp-server/runs": {
"post": {
"operationId": "runs-sync-mrbridge-tft-mcp-server",
"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/mrbridge~tft-mcp-server/run-sync": {
"post": {
"operationId": "run-sync-mrbridge-tft-mcp-server",
"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",
"properties": {
"riotApiKey": {
"title": "Riot API Key",
"type": "string",
"description": "Free key from developer.riotgames.com — log in with your Riot account and copy the key. Takes 30 seconds. Development keys expire every 24h."
},
"defaultRegion": {
"title": "Default Region",
"enum": [
"euw1",
"eun1",
"na1",
"kr",
"br1",
"la1",
"la2",
"oc1",
"tr1",
"ru",
"jp1",
"ph2",
"sg2",
"th2",
"tw2",
"vn2"
],
"type": "string",
"description": "Select your primary game server.",
"default": "euw1"
},
"defaultLanguage": {
"title": "Default Language",
"enum": [
"en",
"fr"
],
"type": "string",
"description": "Language for AI-generated analysis and recommendations.",
"default": "en"
},
"cacheEnabled": {
"title": "Enable Cache",
"type": "boolean",
"description": "Cache reduces API calls and improves response times. Recommended: enabled.",
"default": true
}
}
},
"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
}
}
}
}
}
}
}
}
}
}
```