KeepTradeCut APIkeeptradecut.com ↗
Access KeepTradeCut dynasty fantasy football player rankings, crowdsourced trade values, and recent trades from Sleeper and MFL leagues via a clean REST API.
What is the KeepTradeCut API?
The KeepTradeCut API exposes 3 endpoints covering dynasty fantasy football player rankings, individual player details, and recent real trades pulled from Sleeper, MFL, and other platforms. The get_dynasty_rankings endpoint returns up to 500 dynasty-relevant players with crowdsourced trade values, positional ranks, tiers, and keep/trade/cut vote counts — filterable by position and scoring format.
curl -X GET 'https://api.parse.bot/scraper/52095a49-4d80-48b7-9495-40d7716e1e65/get_dynasty_rankings?limit=10&scoring=superflex&position=all' \ -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 keeptradecut-com-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: KeepTradeCut dynasty fantasy football rankings and trades."""
from parse_apis.keeptradecut_com_api import KeepTradeCut, Position, Scoring, PlayerNotFound
client = KeepTradeCut()
# Browse top superflex QB rankings
for player in client.players.search(position=Position.QB, scoring=Scoring.SUPERFLEX, limit=5):
print(f"{player.rank}. {player.playerName} ({player.team}) - Value: {player.value}")
# Drill into a specific player for full details via sub-resource
top_player = client.players.search(scoring=Scoring.SUPERFLEX, limit=1).first()
if top_player:
detail = top_player.detail.get(scoring=Scoring.SUPERFLEX)
print(f"\n{detail.playerName}: {detail.college}, Round {detail.pickRound} Pick {detail.pickNum}")
print(f" Trade value: {detail.value}, Tier: {detail.overallTier}, ADP: {detail.startupAdp}")
# Fetch recent real trades
for trade in client.trades.list(limit=3):
print(f"\nTrade {trade.id} ({trade.date}): Team1 sent {trade.teamOne.playerIds} for {trade.teamTwo.playerIds}")
print(f" League: {trade.settings.teams} teams, {trade.settings.qBs} QB, PPR={trade.settings.ppr}")
# Handle player-not-found gracefully
try:
client.players.get(slug="nonexistent-player-9999")
except PlayerNotFound as exc:
print(f"\nPlayer not found: {exc}")
print("\nExercised: players.search / player.detail.get / trades.list / players.get")
Retrieve dynasty fantasy football player rankings with crowdsourced trade values. Results are ordered by rank (highest value first). Each player includes their current trade value, positional rank, tier, and keep/trade/cut vote counts. The ranking pool is the top 500 dynasty-relevant players.
| Param | Type | Description |
|---|---|---|
| limit | integer | Maximum number of players to return. |
| scoring | string | Scoring format for values. |
| position | string | Filter by position. |
{
"type": "object",
"fields": {
"players": "array of player ranking objects with playerName, playerID, slug, position, team, age, rookie, college, seasonsExperience, value, rank, positionalRank, overallTier, positionalTier, overallTrend, kept, traded, cut",
"scoring": "string",
"total_players": "integer",
"position_filter": "string"
},
"sample": {
"data": {
"players": [
{
"age": 30.1,
"cut": 85059,
"kept": 170913,
"rank": 1,
"slug": "josh-allen-365",
"team": "BUF",
"value": 9999,
"rookie": false,
"traded": 44235,
"college": "Wyoming",
"playerID": 365,
"position": "QB",
"playerName": "Josh Allen",
"overallTier": 1,
"overallTrend": 1,
"positionalRank": 1,
"positionalTier": 1,
"seasonsExperience": 8
}
],
"scoring": "superflex",
"total_players": 5,
"position_filter": "QB"
},
"status": "success"
}
}About the KeepTradeCut API
Dynasty Rankings
The get_dynasty_rankings endpoint returns an ordered list of dynasty fantasy football players ranked by crowdsourced trade value (highest first). Each player object includes playerName, playerID, slug, position, team, age, value, rookie, seasonsExperience, and college. You can filter by position (e.g. QB, RB, WR, TE) and scoring format, and use the limit parameter to control how many results come back. The pool covers the top 500 dynasty-relevant players.
Player Details
get_player_details takes a player slug — like josh-allen-365 or bijan-robinson-1414 — obtained from the rankings endpoint. It returns deeper attributes including age, team, rank, value, number (jersey), rookie status, and the raw vote counts: kept, traded, and cut. These counts reflect how the KeepTradeCut community has voted on each player, giving a direct read on consensus sentiment beyond the aggregate score. The scoring parameter adjusts values for PPR or other formats.
Recent Trades
get_recent_trades surfaces actual trades executed in dynasty leagues on connected platforms. Each trade object contains a date, two team sides (teamOne and teamTwo) each with a place finish and a playerIds array, and a settings block that includes teams, qBs, ppr, and tep (tight-end premium). Player IDs in trade objects map directly to playerID values from the rankings endpoint, so you can cross-reference what players moved and at what relative values.
The KeepTradeCut API is a managed, monitored endpoint for keeptradecut.com — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when keeptradecut.com 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 keeptradecut.com 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 dynasty trade analyzer that compares aggregate
valuescores for players on each side of a proposed deal - Track rookie
valuetrends over a season by pollingget_dynasty_rankingswithposition=QBand filteringrookie=true - Populate a dynasty startup draft board sorted by
rankand broken out bytier - Audit real league trades from
get_recent_tradesto identify systematic market inefficiencies in PPR vs. non-PPR formats - Surface
kept,traded, andcutvote distributions on a player profile page to show community sentiment alongside trade value - Generate positional scarcity reports by querying
get_dynasty_rankingsfor each position and comparing value drop-offs by tier - Match
playerIdsfrom recent trades back to player names and values to build a trade history feed for a fantasy news app
| 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.
Does KeepTradeCut have an official developer API?+
What does the `scoring` parameter actually change in the rankings?+
scoring value adjusts the trade value returned for each player to reflect that scoring context (e.g. PPR). The positional rank and vote counts (kept, traded, cut) remain based on the full crowdsourced dataset but the numeric values shift to reflect how the community rates players under that format.Do the recent trades include picks or just players?+
get_recent_trades endpoint returns playerIds arrays for each team side. Based on the current response shape, traded draft picks are not explicitly surfaced as separate objects. You can fork this API on Parse and revise it to add a picks field to the trade endpoint if that data is needed.Is redraft or best-ball ranking data available?+
How fresh is the trade data from `get_recent_trades`?+
date field so you can see when it was recorded. Trades are sourced from Sleeper, MFL, and other connected platforms as they occur in those leagues, but there is no guaranteed real-time SLA — treat the data as near-recent rather than live.