Guide

Find waiver-wire gems with snap share before your league does

Quick answer: Pull every RB, WR and TE from /players in about 14 requests, compare each player's recent snap share with his earlier average, and keep the ones rostered in under 50% of leagues who now play 50%+ of snaps after a 10-point jump. In 2025, 14 of 30 snap-share risers kept a 3+ PPR-per-game gain for the rest of the season. Only 8 of 42 players who spiked on points alone did.

Requests per run
~14
Plan
Basic
Rostered filter
< 50%
Role signal
+10 snap pts

Why does snap share beat last week's box score?

Because the waiver wire overreacts to points and underreacts to playing time. A 25-point week on 30% of the snaps is a touchdown and a long catch. A quiet 8 points on 80% of the snaps is a coach telling you who his guy is. The second player is the one who is still on your wire, because nobody sorts free agents by snap share.

We checked it on the 2025 season. We split skill players into two groups using Weeks 1–4 as the baseline and Weeks 5–8 as the signal, then looked at what they scored in Weeks 9–17:

2025: snap-share risers vs point-only risers (PPR per game)
GroupPlayersWks 1–4Wks 5–8Wks 9–17Kept +3 PPR/g
Snap risers (+15 pts, now 50%+)305.29.87.814 (47%)
Point risers (+5 PPR/g, snaps flat)428.717.99.48 (19%)

The point spikers were the shinier pickup in Week 9, averaging 17.9 a game, and then they gave back almost all of it: 9.4 the rest of the way, less than a point above where they started. The snap risers never looked as exciting, but they kept more than half of their gain. That's the whole strategy in one table: buy the role, not the week.

Two of the 2025 names that made the list early: Kimani Vidal went from 3% of the Chargers' snaps in Weeks 1–4 to 56% in Weeks 5–8, and from 0.0 to 13.2 PPR a game. Oronde Gadsden II went from 37% to 71% and from 4.4 to 15.6. Both were free in most leagues when their snap share moved.

How do I rank the waiver risers in Python?

One script, no database. It sweeps /players by position (each player carries his weekly snap rows, weekly stats and percent_owned), finds the last complete week, and compares the recent window with everything before it. Set GRIDIRON_API_KEY and run it:

import os
from collections import defaultdict
import requests

API = "https://api.gridirondata.com/api/v1"
H = {"x-api-key": os.environ.get("GRIDIRON_API_KEY", "YOUR_KEY")}
SEASON = "2026"
TRAIL = 2            # weeks in the "recent" window
MAX_ROSTERED = 50    # only players you can probably still add

def sweep(position):
    out, cursor = [], None
    while True:
        params = {"position": position, "limit": 100, **({"cursor": cursor} if cursor else {})}
        r = requests.get(f"{API}/players", headers=H, params=params, timeout=60)
        r.raise_for_status()
        body = r.json()
        out += body["players"]
        cursor = body.get("next_cursor")
        if not cursor:
            return out

def ppr(row):
    for k in ("fantasy_points_ppr", "points", "fantasy_points"):
        if row and row.get(k) is not None:
            return float(row[k])
    return None

def avg(xs):
    xs = [x for x in xs if x is not None]
    return sum(xs) / len(xs) if xs else None

players = [p for pos in ("RB", "WR", "TE") for p in sweep(pos)]   # ~14 requests

# The last complete week: the latest one in which 28+ teams have snap rows
# (a Thursday game alone doesn't count).
teams_by_week = defaultdict(set)
for p in players:
    for wk, row in ((p["seasons"].get(SEASON, {}).get("snap_counts") or {}).get("weekly") or {}).items():
        teams_by_week[int(wk)].add(row.get("team"))
last = max(w for w, t in teams_by_week.items() if len(t) >= 28)
recent = range(max(2, last - TRAIL + 1), last + 1)     # leave at least one earlier week
earlier = range(1, recent.start)

rows = []
for p in players:
    block = p["seasons"].get(SEASON, {})
    owned = block.get("percent_owned") or 0
    if owned > MAX_ROSTERED:
        continue
    snaps = (block.get("snap_counts") or {}).get("weekly") or {}
    stats = block.get("weekly_stats") or {}
    snap = lambda wks: avg([(snaps.get(str(w)) or {}).get("offense_pct") for w in wks])
    pts = lambda wks: avg([ppr(stats.get(str(w))) for w in wks if str(w) in stats])
    s_new, s_old = snap(recent), snap(earlier)
    if s_new is None or s_old is None or s_new < 50 or s_new - s_old < 10:
        continue                                   # no real role, or no real change
    p_new, p_old = pts(recent), pts(earlier)
    rows.append({
        "player": p["player_name"], "pos": p["position"],
        "team": block.get("team") or (snaps.get(str(last)) or {}).get("team"),
        "owned": owned, "snap_old": s_old, "snap_new": s_new, "delta": s_new - s_old,
        "ppr_new": p_new, "ppr_old": p_old, "status": block.get("injury_status") or "-",
    })

rows.sort(key=lambda r: -r["delta"])
window = f"week {last}" if recent.start == last else f"weeks {recent.start}-{last}"
print(f"Snap risers through Week {last} (recent = {window}), rostered under {MAX_ROSTERED}%:")
for r in rows[:15]:
    pts_txt = "-" if r["ppr_new"] is None else f"{r['ppr_new']:.1f}"
    print(f"{r['player']:<22}{r['pos']:<3}{r['team'] or '-':<4} {r['owned']:5.1f}% rostered  "
          f"snaps {r['snap_old']:3.0f}% -> {r['snap_new']:3.0f}% ({r['delta']:+.0f})  "
          f"PPR/g {pts_txt:>5}  {r['status']}")

A few details are doing real work. The "last complete week" check waits until 28 teams have snap rows, so a Thursday game doesn't count as a week. Players need an earlier week to compare against, so a rookie's first game can't fake a +80 jump. And percent_owned lives on the season block, so it's the current rostered rate, not a historical one.

What does the output look like?

Here's the top of a real run early in the 2026 season, through Week 2 (a thin one-week baseline, which is exactly when the list is noisiest):

Snap risers through Week 2 (recent = week 2), rostered under 50%:
Germie Bernard        WR PIT    3.8% rostered  snaps   4% ->  79% (+75)  PPR/g   7.5  Healthy
Myles Price           WR MIN    0.1% rostered  snaps   5% ->  50% (+45)  PPR/g   0.0  Healthy
Konata Mumpfield      WR LAR    0.6% rostered  snaps  26% ->  69% (+43)  PPR/g   2.2  Healthy
Ben Sinnott           TE WAS    0.2% rostered  snaps  26% ->  68% (+42)  PPR/g   1.6  Healthy
Laquon Treadwell      WR IND    0.0% rostered  snaps  35% ->  74% (+39)  PPR/g   9.1  Healthy
Will Shipley          RB PHI    0.7% rostered  snaps  18% ->  51% (+33)  PPR/g   4.9  Healthy
Jaylin Noel           WR HOU    5.8% rostered  snaps  30% ->  60% (+30)  PPR/g   5.4  Healthy
Johnny Mundt          TE PHI    0.1% rostered  snaps  36% ->  64% (+28)  PPR/g   2.8  Healthy

Read it top to bottom and you can already see the two kinds of riser. Germie Bernard jumped from 4% to 79% of Pittsburgh's snaps. That was a fill-in role: Michael Pittman Jr. didn't play that week, which our Week 3 usage report flagged. Laquon Treadwell went from 35% to 74% and scored 9.1 on the new role, with Alec Pierce on IR. He's a fill-in too, but one with a long runway, which is often the best kind of waiver add.

How do I tell a breakout from a fill-in?

A snap jump has three common causes, and only one of them is a breakout. Before you burn a waiver claim, run the name through this checklist:

  • Did a same-position teammate sit? Look at the team's other WRs, or other RBs, in the same week. If the starter was DNP, the riser is a fill-in. He's worth a stash in deep leagues and nothing more once the starter's status turns back to Active.
  • Did the teammate play and lose snaps? That's a depth-chart change, and it's the breakout. The snap share moved from one player to the other with both healthy.
  • Did the offense run more plays? A blowout or overtime inflates everyone's snaps slightly, but it doesn't move a player from 35% to 74%. Share is a percentage of the team's plays for exactly that reason.

The snap share guide walks through the classic example: Amon-Ra St. Brown was at 98% of Detroit's snaps two weeks before his 2021 breakout reached the box score.

Which thresholds should I tune?

  • TRAIL sets how many weeks count as "recent". Two is right from about Week 5 on. Early in the season it falls back to one week automatically.
  • MAX_ROSTERED should match your league. In 10-team leagues, 60 is fine. In deep or 14-team leagues, drop it to 25 and the list gets more interesting.
  • The 50% floor works for WRs and TEs. Running backs rarely clear it outside workhorse backfields, so try 40 if you're hunting backs.
  • Byes drop out cleanly: a player with no snap row in a week simply has nothing to average, so a bye neither helps nor hurts him.

Want the points angle too? Add a column for ppr_new - ppr_old and mark players whose points rose with their snaps as "role-backed". That's the same split the weekly usage report uses.

How many requests does it cost, and when should I run it?

About 14 requests per run, on Basic ($5 for 5,000 a month): the weekly snap rows are not on the free plan. Run weekly all season it's about 60 a month. Run it once a week, on Tuesday afternoon Eastern: Sunday's stats and snaps land Monday at about 11:00 am ET, and Monday night's on Tuesday. The data refreshes on that schedule, so running it every hour only spends requests. If you want the list for several leagues, save the sweep to a JSON file and re-filter it locally with different MAX_ROSTERED values.

More tools like this are in the guides.

Frequently asked questions

How many requests does the waiver script use?

About 14: four pages of running backs, six of wide receivers and four of tight ends from /players. Those weekly rows come with Basic ($5/month, 5,000 requests a month), which covers a weekly run all season; a free key gets profiles only.

When should I run it each week?

Tuesday afternoon Eastern. Sunday stats and snaps land Monday at about 11:00 am ET and Monday night's on Tuesday, so a Tuesday run sees the whole week before most waiver deadlines.

What does percent_owned mean?

The share of fantasy leagues where the player is rostered, from 0 to 100. The script keeps players under 50 by default, which is roughly the pool that is still available in a typical 12-team league.

Why do some risers show a teammate's name in the news?

Because the most common reason a backup's snap share jumps is that the starter ahead of him sat. Check the starter's status before you spend a waiver priority: if he returns, the role usually goes with him.