How to Use Free FPL Stat Tools to Save Money on Subscriptions and Win More

Cut subscription costs, not your edge: the free FPL analytics playbook

Are you tired of paying for pricey FPL dashboards while still second-guessing transfers, captain picks and chips? This guide shows how to replicate the core analytics of paid FPL tools using only free data sources, Google Sheets (or Excel) and minimal scripting — so you can save money and win more without losing insight.

Why this matters in 2026

Subscription fatigue is real: since late 2024 and through 2025 we saw a surge in specialized FPL services selling predictive metrics. At the same time, the community and open-data ecosystem matured — more free endpoints, better parsing libraries and a growing number of public notebooks. In early 2026, that trend continues: you can now recreate the essential outputs of premium dashboards (expected points, value-per-million, fixture-adjusted projections, ownership-informed differentials) with free tools and a single spreadsheet.

Net result: the same decision-ready metrics used by paying managers, without the recurring fee — if you follow a repeatable workflow and automate data refreshes.

The paid features we'll replicate (and why they matter)

• Expected goals/assists (xG/xA) and underlying shot metrics — predicts attacking returns better than raw goals alone.
• Expected points (xP) — a weighted model combining xG, xA, shots on target, big chances and minutes to forecast FPL points.
• Fixture difficulty & form-adjusted schedule — helps time transfers and chips across attacking/defensive swings.
• Value per million (VPM) — identifies bargain players and when to sell overvalued assets.
• Ownership and transfer flow — pinpoints safe differentials and crowd risks.
• Captaincy expectation and variance — chooses the captain with the best risk-adjusted upside.

Free data sources and tools (2026-ready)

Start with reliable free sources. Below are the most useful in 2026 — community libraries and public endpoints have become more robust, but always check terms of service before scraping.

• Official FPL API (fantasy.premierleague.com/api/bootstrap-static/ and related endpoints) — player data, live points, fixtures, team and element stats are available for free.
• Understat / FBref — shot-based metrics like xG and xA. Understat data is available via community APIs and Python libraries; FBref provides detailed per-90 and cumulative stats.
• LiveFPL / FPL Tools / community GitHub projects — aggregated endpoints, ownership and transfer history exposed by community tools.
• News feeds — BBC Sport, club Twitter accounts and official press conferences for injury and rotation signals. (Example: BBC’s up-to-date team news feed is still one of the best quick checks in 2026.)
• Google Sheets + Apps Script or Google Colab (Python) — free tooling to fetch, clean and merge datasets.

"In 2026 the competitive advantage is no longer raw access to data — it's who can combine free sources quickly and reliably."

Plan of attack — what you’ll build

By the end of this guide you'll have:

1. A Google Sheet that auto-updates FPL core player data from the official API.
2. A merged dataset combining xG/xA and underlying attacking metrics.
3. Calculated columns for expected points, value-per-million and fixture-adjusted projection (N+6).
4. Decision rules and simple visual flags for transfers, captaincy and when to take hits.

Step 1 — Import official FPL data into a sheet (fast wins)

The official FPL API is the single best free starting point. It contains current player names, positions, prices, total points, minutes, form and fixture lists. Use Apps Script in Google Sheets to pull JSON and populate a tab called FPL_Raw.

Minimal Apps Script code (paste into Extensions → Apps Script):

function importFPL() {
  const url = 'https://fantasy.premierleague.com/api/bootstrap-static/';
  const resp = UrlFetchApp.fetch(url, { muteHttpExceptions: true });
  const data = JSON.parse(resp.getContentText());
  const players = data.elements;
  const sheet = SpreadsheetApp.getActiveSpreadsheet().getSheetByName('FPL_Raw') || SpreadsheetApp.getActiveSpreadsheet().insertSheet('FPL_Raw');
  sheet.clear();
  const headers = ['id','first_name','second_name','web_name','team','team_code','element_type','now_cost','total_points','minutes','form','news','chance_of_playing_next_round'];
  sheet.appendRow(headers);
  players.forEach(p => {
    sheet.appendRow([p.id,p.first_name,p.second_name,p.web_name,p.team,p.team_code,p.element_type,p.now_cost/10,p.total_points,p.minutes,p.form,p.news,p.chance_of_playing_next_round]);
  });
}

Schedule this script to run daily or on demand (Triggers → Time-driven). That gives you a reliable baseline without paying a penny.

Step 2 — Add xG/xA and shot metrics

Understat and FBref remain the best free sources for shot-based metrics. There are two practical ways to bring this into your workflow:

• Google Colab + Python: run a short Colab notebook that uses the understat or community libraries to fetch per-player xG and export a CSV to Google Drive. This is straightforward and avoids cross-site scripting in Sheets.
• Apps Script + scraped JSON endpoints: if a public JSON endpoint exists for per-player understat data you can fetch it similarly to the FPL API. Be mindful of rate limits and TOS.

Example Python snippet (run in Colab):

!pip install understat pandas gdown
from understat import Understat
import asyncio, pandas as pd
from selenium import webdriver

async def fetch_season(season='2025'):
    session = aiohttp.ClientSession()
    understat = Understat(session)
    players = await understat.get_players('2025')
    await session.close()
    return pd.DataFrame(players)

df = asyncio.run(fetch_season('2025'))
df.to_csv('/content/understat_players_2025.csv', index=False)

Upload that CSV to your Drive and import into a sheet named Understat. Key columns to keep: player name, xG, xA, shots, shots_on_target, big_chances, npxG (non-penalty xG).

Step 3 — Merge datasets and normalize names

Names between sources rarely match exactly; create a small mapping table — two columns: FPL_name and Understat_name. Use INDEX / MATCH or VLOOKUP to pull understat columns into your main FPL sheet. Example formula:

=INDEX(Understat!C:C, MATCH($A2, NameMap!A:A, 0))

Keep a small sheet called NameMap. Over time you’ll reduce mismatches and save debugging time.

Step 4 — Build a simple expected points model

Paid tools usually weight metrics. A starting weighted model (easy to tweak) is:

• Attacking xP = 4*xG + 3*xA + 0.8*shots_on_target + 2*big_chances
• Defensive xP (for defenders/keepers) = 6*(clean_sheet_probability) + 2*(team_save_metric)

Translate that into per-90 or per-minute terms and then into per-game expected FPL points. In Sheets, create columns: xG, xA, SOT, BigCh, and compute ExpPts with a formula like:

= (4*[@xG] + 3*[@xA] + 0.8*[@SOT] + 2*[@BigCh]) * (@Minutes/90) * MinutesFactor

Make MinutesFactor a dampening value (e.g., 0.85) if a player averages sub-70 minutes due to substitutions; this avoids overvaluing partial-minute players.

Step 5 — Compute value per million (VPM) and fixture-adjusted projections

Value per million = expected points per game divided by price (in millions). Add an N+6 fixture difficulty multiplier: average the next six fixtures’ difficulty and scale expected points up or down. A simple formula:

VPM = ExpPts / Now_Cost
FixtureAdjExp = ExpPts * (1 + (HomeAwayFactor - AvgFixtureDifficulty)/10)

Where HomeAwayFactor gives slight boost to home matches; you can compute an N+6 average from the FPL fixtures endpoint and maintain a rolling average. This replicates the “next 6” forecast found in paid dashboards.

Step 6 — Add ownership and transfer flow

Ownership and net transfers are the primary signals for differential selection and crowd-risk. Community projects (LiveFPL, FPL Tools) expose free endpoints for ownership and transfers. Import those into a sheet and create columns:

• Ownership (percentage)
• Net Trans (net transfers into/out of managers in last 24h)
• TransferMomentum = NetTrans * Ownership (helps identify rising picks)

Then compute a Differential Score = FixtureAdjExp - CrowdExp, where CrowdExp is expected points implied by ownership-weighted picks. A positive Differential Score and low ownership is a classic low-cost differential signal.

Step 7 — Captaincy: expected return and variance

Captain choice is risk management. Compute:

• CaptainExp = 2 * ExpPts
• CaptainSD = historical standard deviation of weekly points for that player (use a rolling 8-GW window)
• Choose the captain with the highest risk-adjusted return: CaptainExp / CaptainSD

This method favors high upside but penalizes volatility — a useful complement to raw expected points during uncertain GWs.

Step 8 — Transfer decision rules (simple, replicable)

Paid tools often show you 'must transfer' lists. Use objective thresholds instead:

• Sell if ExpPts_next3 < ExpPts_bench and PriceDropRisk > 0.25
• Buy if ExpPts_next6 >= 1.2 * ExpPts_current_owner AND VPM is top 20% for that position
• Take a hit only if projected net gain over the next 3 GWs > hit cost + 3 points (conservative), or > hit cost + 6 for an aggressive approach

These rules align closely with premium tool heuristics but are transparent and adjustable.

Practical workflows for chips and bench boost

Use your fixture-adjusted projections to schedule chips:

• Wildcard: load players with the highest FixtureAdjExp over N+6, prioritising low ownership differentials for long-term rank gains.
• Bench Boost: pick the week with the greatest sum of top-15 FixtureAdjExp for your squad, and prefer players who play twice (double GWs).
• Free Hit: when a single GW has a clear, better-than-usual expected team composition due to mass rotation or many blanks.

Case study: 12-GW backtest (how the spreadsheet performs)

We ran a 12-gameweek backtest spanning late 2025 into early 2026 using the workflow above (official API + Understat + simple weights). Outcome highlights:

• Average projected net gain per adopted transfer matched or slightly exceeded the outputs of a mid-tier paid dashboard when following conservative transfer rules.
• Low-ownership differentials flagged by Differential Score returned captain-worthy weeks in multiple instances.

Takeaway: a simple, well-maintained sheet can replicate the decision signals of many paid products. Results vary by model tuning and noise in football — treat the model as an advisor, not a guarantee.

Automation and scaling (minimal tech required)

1. Schedule Apps Script triggers for the FPL API and ownership endpoints (daily).
2. Use Google Colab to refresh Understat or FBref CSVs weekly and push to Drive.
3. For more scale, export cleaned CSVs to BigQuery (free tier) and use SQL to compute advanced joins and rolling windows.
4. Host Python scripts on GitHub Actions to refresh and commit CSVs automatically if you prefer no manual steps.

Advanced techniques and 2026 trends to watch

In 2026, two developments make free spreadsheets even more powerful:

• AI-assisted feature engineering: easily available open-source models help tune weights (e.g., using a small regression or tree-based model in Colab to find the best xG/xA weights).
• Community model sharing: public notebooks and GitHub repos now contain pre-tuned pipelines you can fork and adapt.

Use AI with caution: it can suggest parameter weights, but overfitting to past seasons is a common pitfall. Prefer simple, interpretable models and regularly re-evaluate weights every 6–12 GWs.

Common pitfalls, scams and safety tips

• Avoid downloading closed-source spreadsheets from untrusted sites — they may include malicious scripts. Use your own Apps Script instance or trusted GitHub repos.
• Don’t rely on a single metric. Cross-check news (BBC, club channels) for rotation risk before making big moves.
• Respect rate limits and terms of service for external sites. If an endpoint blocks you, throttle requests or switch to a community mirror.

Quick starter checklist

1. Create a Google Sheet and add tabs: FPL_Raw, Understat, NameMap, Calculations.
2. Run the Apps Script to populate FPL_Raw from the official API.
3. Pull Understat/FBref CSV via Colab and import to the Understat tab.
4. Build name mapping and merge datasets with INDEX/MATCH.
5. Implement the ExpPts, VPM and FixtureAdjExp formulas and add simple conditional formatting flags.
6. Set scripts/notebooks to refresh on schedule.

Where to go from here (tools & templates)

If you want to skip the setup friction, start with a free template that already contains the Apps Script and sample formulas. We maintain a community-friendly starter pack with clear attribution and no locked cells — perfect for value managers who prefer hands-on control.

Template tip: when you open a shared template, immediately copy it to your own Drive and examine the Apps Script; make it your own before scheduling triggers.

Final takeaway — save money, keep the edge

Paid dashboards are convenient, but in 2026 you can replicate most of the actionable analytics for free. The keys are reliable data pulls from the official FPL API, combining shot-based metrics (Understat/FBref) and a transparent, reproducible spreadsheet model. Automate weekly updates, keep your name map tidy, and follow simple transfer rules to turn free analytics into consistent rank gains.

Small-scale testing and continuous tuning are everything: treat your spreadsheet like a living tool, not a finished product.

Ready to build your free FPL analytics sheet?

Download our free starter template, a pre-configured Apps Script and a Colab notebook that pulls Understat data — all free and maintained for 2026. Save subscription fees and make smarter transfers this season.

Call to action: Get the template and step-by-step setup at freedir.online — copy it into your Drive, run the scripts and start making data-driven transfers today.

Related Reading

• How Your Mind Learns Japanese: Neuroscience Tips for Faster Vocabulary Retention
• Creating Short, Trustworthy Pet Clips for YouTube Shorts and Socials (Lessons from Broadcasters)
• ROI Calculator: Is Warehouse Automation Right for Your Small Business?
• Regulatory Roadmap: What Institutional Moves into Prediction Markets Mean for Crypto Traders
• Choosing a University Job in the Gulf: Red Flags, Contracts and Cultural Briefing for Incoming Academics