polars-baseball 0.3.0

Retrieve baseball data in Python

polars-baseball

Languages: English | Traditional Chinese

polars-baseball is The unified Polars-native baseball data SDK: a typed, async-first Python library for retrieving MLB and baseball analytics data from Statcast, Baseball Savant, FanGraphs, Baseball Reference, Lahman, Retrosheet, and the MLB Stats API.

If you searched for python baseball data, python statcast, fangraphs python, baseball savant api, pybaseball alternative, or polars dataframe baseball, this project is built for the workflow where data should land directly in polars.DataFrame instead of going through pandas first.

Why use polars-baseball instead of pybaseball?

pybaseball is useful and established. polars-baseball is aimed at a different execution model: async data ingestion, native Polars output, and one consistent entry point across multiple baseball data providers.

Feature	pybaseball	polars-baseball
Polars native	No	Yes
Async data fetching	No	Yes
Statcast / Baseball Savant	Yes	Yes
FanGraphs	Yes	Yes
MLB Stats API	Limited	Yes
Lahman / Retrosheet workflows	Partial	Yes
Built-in cache	Partial	Yes
Typed public API	Partial	Yes

Typical pandas-first workflow:

pybaseball -> pandas -> convert to Polars -> analysis

polars-baseball workflow:

polars-baseball -> Polars -> analysis

Key Features

• Polars-native data: Public data-fetching APIs return polars.DataFrame unless an API reference explicitly documents a non-tabular contract.
• Async-first engine: Data-fetching APIs are async def and can be composed with your own async workflows.
• Multiple providers: Statcast, Baseball Savant, FanGraphs, Baseball Reference, Lahman, Retrosheet, MLB Stats API, and player ID workflows.
• Built-in cache: Repeated network requests are cached as Parquet files for large workflows.
• Service-ready context: BaseballContext lets long-running apps control HTTP and cache resources explicitly.

Installation

pip install polars-baseball

For local development:

git clone https://github.com/nicko4o/polars-baseball
cd polars-baseball
uv sync --all-extras

To run visualization examples:

pip install "polars-baseball[plot]"

Quick Start

Statcast pitch-level data

import asyncio

import polars_baseball as pb


async def main() -> None:
    df = await pb.statcast(start_date="2024-05-06", end_date="2024-05-06")
    print(df.head(5))


if __name__ == "__main__":
    asyncio.run(main())

Aggregate directly with Polars

import asyncio

import polars as pl
import polars_baseball as pb


async def main() -> None:
    df = await pb.statcast_pitcher(
        start_date="2024-05-06",
        end_date="2024-05-06",
        player_id=506433,
    )
    summary = df.group_by("pitch_type").agg(
        pl.col("release_speed").mean().alias("mean_speed"),
        pl.len().alias("pitch_count"),
    )
    print(summary.sort("pitch_count", descending=True))


if __name__ == "__main__":
    asyncio.run(main())

FanGraphs leaderboard

import asyncio

import polars_baseball as pb


async def main() -> None:
    df = await pb.fg_batting(
        start_season=2024,
        end_season=2024,
        qual=100,
        max_results=20,
    )
    print(df.head(10))


if __name__ == "__main__":
    asyncio.run(main())

Examples

Runnable examples live in examples/:

• examples/statcast_pitch_mix.py: Statcast pitch mix with Polars.
• examples/fangraphs_leaderboard.py: FanGraphs batting leaderboard.
• examples/mlb_schedule.py: MLB Stats API schedule query.
• examples/benchmark_statcast.py: Conservative Statcast timing and memory benchmark.

Benchmarking

Do not trust performance claims without a reproducible command. Start with:

python examples/benchmark_statcast.py --start-date 2024-04-01 --end-date 2024-04-07

The script reports row count, column count, wall time, and Python allocation peak measured by tracemalloc. Use the same date range, cache state, Python version, and machine when comparing against pandas-first workflows.

Web Services & Concurrency

Calling package functions without context uses the implicit package-level BaseballContext. That default context is convenient for scripts, but long-running concurrent services should manage their own context and pass it into every API call.

from contextlib import asynccontextmanager

from fastapi import FastAPI

import polars_baseball as pb


@asynccontextmanager
async def lifespan(app: FastAPI):
    async with pb.BaseballContext() as context:
        app.state.pb_context = context
        yield


app = FastAPI(lifespan=lifespan)


@app.get("/statcast")
async def get_statcast() -> dict[str, int]:
    df = await pb.statcast(
        start_date="2026-06-01",
        end_date="2026-06-02",
        context=app.state.pb_context,
    )
    return {"rows": df.height}

API Namespace Policy

The package root (import polars_baseball as pb) exposes stable public APIs, including provider specific data functions such as Lahman, Retrosheet, Baseball Reference, and player ID workflows. Provider namespaces such as pb.fangraphs, pb.savant, and pb.mlb expose shorter task-oriented aliases for new code while the existing root functions remain supported.

Modules prefixed with _, including _schemas, are internal implementation details and are not part of the compatibility contract.

Documentation

• English documentation
• Traditional Chinese documentation
• Caching Guide
• Jupyter Notebook Usage
• Data Visualization Guide
• Statcast API
• Player ID Lookup
• MLB Stats API
• Savant Gamefeed API
• Prospect Rankings

Showcase

Projects using polars-baseball:

• MLB dashboard workflows
• Chinese baseball website data jobs
• Threads bot baseball data pipelines

Contributing

See CONTRIBUTING.md for development workflow and architecture notes.

Author

Created and maintained by Nick.