FMInside APIfminside.net ↗
Access the Football Manager player database via API. Search players, browse full rosters, and retrieve detailed profiles including positions, club, and attributes.
What is the FMInside API?
The FMInside API exposes 4 endpoints covering the Football Manager player database, letting you search for players by name, paginate through the full catalog, and retrieve individual profiles with fields like club, height, positions, foot ratings, and FM unique IDs. The get_player_details endpoint accepts a profile URL and returns a complete player record, while get_player_by_id lets you look up any player directly by their FM unique ID.
curl -X GET 'https://api.parse.bot/scraper/e737f35d-e126-4fda-8e43-a3a67a4f722f/search_players?limit=5&query=Mbappe' \ -H 'X-API-Key: $PARSE_API_KEY'
Typed, relational, agent-ready
A generated client with real types, enums, and the links between objects — the structure a flat JSON response can't carry. Autocompletes in your editor and reads cleanly to coding agents.
- Fully typed · autocompletes
- Objects link to objects
- Typed errors & pagination
Typed Python client. Set up the SDK in your uv project, then pull this API’s typed client:
uv add parse-sdk uv run parse init uv run parse add --marketplace fminside-net-api
uv run parse add --marketplace pulls a pinned snapshot of this canonical API — it won’t change underneath you. To customize it, subscribe and swap to your own copy.
"""Walkthrough: FMInside SDK — browse, search, and inspect Football Manager players."""
from parse_apis.FMInside_Player_API import FMInside, Player, PlayerSummary, PlayerNotFound
fminside = FMInside()
# Search for players by name, capped to 3 results
for summary in fminside.player_summaries.search(query="Mbappe", limit=3):
print(summary.name, summary.age, summary.positions)
# Get full player details by unique ID
player = fminside.players.get(player_id="85139014")
print(player.name, player.club, player.current_ability, player.potential_ability)
print(player.nationality, player.contract_end)
# Navigate from summary to full detail via .details()
summary = fminside.player_summaries.list(limit=1).first()
if summary:
full = summary.details()
print(full.name, full.club, full.current_ability, full.nationality)
if full.attributes:
print(full.attributes.technical, full.attributes.physical)
# Typed error handling for a nonexistent player
try:
fminside.players.get(player_id="0000000000")
except PlayerNotFound as exc:
print(f"Player not found: {exc.player_id}")
print("exercised: player_summaries.search / players.get / player_summaries.list / summary.details")
Full-text search over the FM player database by name or keyword. Returns a list of matching player summaries with IDs, positions, age, and profile URLs. The server returns only top matches for the query.
| Param | Type | Description |
|---|---|---|
| limit | integer | Maximum number of results to return. |
| queryrequired | string | Player name or search phrase. |
{
"type": "object",
"fields": {
"total": "integer total number of players returned",
"players": "array of player summary objects with name, unique_id, url, age, positions, and image_url"
},
"sample": {
"data": {
"total": 5,
"players": [
{
"age": "26",
"url": "/players/7-fm-26/85139014-kylian-mbappe",
"name": "Kylian Mbappé",
"image_url": "https://img.fminside.net/facesfm26/85139014.png",
"positions": [
"AMR",
"AML",
"ST"
],
"unique_id": "85139014"
}
]
},
"status": "success"
}
}About the FMInside API
Search and Browse
The search_players endpoint accepts a required query string and an optional limit integer. It returns a players array of summary objects, each containing name, unique_id, url, age, positions, and image_url, along with a total count of matched results. The list_players endpoint works without a query, paginating through the full player database up to the requested limit and returning a count alongside the same summary array.
Player Profiles
get_player_details takes a relative or absolute player profile URL — obtainable from any search or list result — and returns a detailed record. Fields include full_name, club, age, height (in CM), positions (as an array of abbreviation strings), left_foot, image_url, url, and unique_id. get_player_by_id returns the identical structure using only the numeric FM unique_id, which avoids the need to construct or store profile URLs.
Data Coverage
All player records reflect the Football Manager database as indexed on fminside.net. The positions field returns abbreviations such as ST, CM, or GK, and left_foot provides a rating string for the player's non-dominant foot. The image_url field points to the player's face image hosted on the source site. Pagination in list_players continues loading results automatically until the requested limit is satisfied.
The FMInside API is a managed, monitored endpoint for fminside.net — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when fminside.net changes and a check fails, the API is automatically queued for repair and re-verified. It is built to keep working as the site underneath it changes.
This isn't an official fminside.net API — it's an independent, maintained REST wrapper over public data. Where the source has no official API (or only a limited one), Parse gives you a stable contract over a source that never promised one, and keeps it current. Need a new endpoint or field? You can revise it yourself in plain English and the agent rebuilds it against the live site in minutes — contributing the change back to the shared API is free.
Will this API break when the source site changes?+
Is this an official API from the source site?+
Can I fix or extend this API myself if I need a new endpoint or field?+
What happens if I call an endpoint that has an issue?+
- Build a scouting tool that searches players by name and filters on positions returned in the summary array
- Populate a squad-builder UI with full player profiles including club and height from get_player_details
- Sync a local FM player database by paginating list_players to a specified limit
- Cross-reference players by FM unique_id across multiple datasets using get_player_by_id
- Display player face images in a fantasy-FM app using the image_url field from any endpoint
- Aggregate positional distribution across a club's roster using positions arrays from bulk list results
- Resolve player profile URLs to full records without storing URL patterns by using the unique_id lookup
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 100 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
One credit = one API call regardless of which marketplace API you call. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.