How to Scrape Letterboxd in 2026 (API & Python)

The fastest way to scrape Letterboxd in 2026 is to call a structured API that returns normalized JSON — film detail, rating histograms, member reviews, similar films, and popular charts — instead of parsing Letterboxd's server-rendered pages yourself. Letterboxd doesn't have a self-serve public API yet, so most integrations either build a DIY scraper, lean on a no-code tool, or call a scraping API that already handles the page structure. This guide covers all three approaches, what each returns, where each breaks, and the legal reality up front.

Why scrape Letterboxd?

Letterboxd isn't just another ratings aggregator sitting next to IMDb or Metacritic — it's a social film-diary platform. People log every film they watch, rate it out of five stars, write a review, and follow other members whose taste they trust. That community layer is the actual product, and it shows up in what's worth collecting:

• Community sentiment, not just a score — a film's average rating and its full star-rating distribution (via the rating histogram) tell you whether opinion is polarized or consensus, which a single aggregate number hides.
• Member-level signal — films-watched counts, this-year totals, follower counts, and list counts describe how engaged a given member or audience segment actually is, distinct from critic-facing scores.
• What's trending right now — the popular charts surface films by engagement this week/month/year/all-time, filterable by genre and decade, which tracks what a very active, taste-forward audience is actually watching.
• Taste graphs and discovery — similar-film relationships and person (director/cast) filmographies power recommendation and "if you liked X" features.
• Review and reception research — public reviews carry a star rating, spoiler flag, like count, and comment count, useful for reception trend tracking over time.

Is it legal to scrape Letterboxd?

Option 1: DIY in Python (and why it breaks)

Letterboxd's film and member pages are server-rendered HTML, so a DIY scraper fetches the page and parses the markup for the fields it needs:

import requests
from bs4 import BeautifulSoup

resp = requests.get(
    "https://letterboxd.com/film/parasite-2019/",
    headers={"User-Agent": "Mozilla/5.0 (compatible; research-bot/1.0)"},
)
soup = BeautifulSoup(resp.text, "html.parser")
# Title, year, and synopsis are in visible markup, but the rating
# average and histogram load from separate /csi/ endpoints, not this page

It demos and then breaks:

• The ToS is explicit. Automated data gathering is prohibited outright without written consent — real risk, not a theoretical one, so scope any project narrowly to public reference fields.
• Ratings and histograms live off-page. The average rating and full star distribution are fetched by the front-end from separate /csi/ (client-side include) endpoints after the initial page loads, so a plain HTML fetch of the film page alone misses them.
• Reviews and similar-films paginate separately. Each is its own sub-page (/reviews/by/activity/, /similar/), so a complete film record means several requests, not one.
• Markup shifts with redesigns. Selectors that work today can silently break after a front-end change, with no warning beyond empty fields.

Option 2: No-code tools

Marketplace scraper actors (for example on Apify) exist for one-off Letterboxd pulls — film pages, member profiles, and reviews — and are a reasonable way to eyeball a small sample. They carry the same Terms of Use exposure as DIY scraping described above, and they're awkward to run on a schedule or wire into a pipeline that needs fresh data daily. For anything beyond a manual, occasional pull, a structured API or Letterboxd's own beta program is the better fit.

Option 3: A structured Letterboxd API

For a repeatable workflow with no page parsing or /csi/ endpoint chasing to maintain, a Letterboxd scraping API returns normalized JSON. Search for a film or person:

curl "https://api.crawlora.net/api/v1/letterboxd/search?q=bong+joon+ho" \
  -H "x-api-key: $CRAWLORA_API_KEY"

{
  "code": 200,
  "msg": "OK",
  "data": {
    "query": "bong joon ho",
    "results": [
      { "type": "person", "title": "Bong Joon Ho", "slug": "bong-joon-ho", "role": "director", "uri": "https://letterboxd.com/director/bong-joon-ho/" },
      { "type": "film", "title": "Being John Malkovich", "slug": "being-john-malkovich", "year": 1999, "uri": "https://letterboxd.com/film/being-john-malkovich/" }
    ],
    "source_url": "https://letterboxd.com/s/search/bong%20joon%20ho/"
  }
}

Then pull a film's detail, rating distribution, and reviews by slug in Python:

import requests
h = {"x-api-key": "YOUR_API_KEY"}
base = "https://api.crawlora.net/api/v1/letterboxd"

film = requests.get(f"{base}/film/parasite-2019", headers=h).json()["data"]
histogram = requests.get(f"{base}/film/parasite-2019/rating-histogram", headers=h).json()["data"]
reviews = requests.get(f"{base}/film/parasite-2019/reviews", headers=h, params={"limit": 20}).json()["data"]

Film detail is normalized JSON (real fields — check the docs):

{
  "data": {
    "slug": "parasite-2019",
    "title": "Parasite",
    "year": 2019,
    "runtime_minutes": 133,
    "directors": [{ "name": "Bong Joon Ho", "slug": "bong-joon-ho" }],
    "genres": ["Thriller", "Comedy", "Drama"],
    "rating": { "average": 4.52, "count": 5553202, "review_count": 740173 }
  }
}

The rating histogram breaks that average down into every half-star bucket, which is where the community-consensus-versus-polarized signal actually lives:

{
  "data": {
    "slug": "parasite-2019",
    "buckets": [
      { "stars": 4, "count": 1231158, "percent": 22 },
      { "stars": 4.5, "count": 960428, "percent": 17 },
      { "stars": 5, "count": 2785234, "percent": 50 }
    ],
    "total_ratings": 5553315
  }
}

Member profiles work the same way — /letterboxd/member/{username} returns films_watched, films_this_year, lists, following, and followers for a public profile — and /letterboxd/popular returns trending films filterable by period, genre, and decade. Store one row per film (or per review, per member) and re-run on a schedule.

What you can collect

Public film and community metadata: search results (film, person, list, and tag matches); film detail (title, year, synopsis, runtime, directors, cast, genres, countries, languages, poster, average rating); full rating histograms (per-half-star counts and percentages); public reviews (rating, liked flag, date, text, spoiler flag, like and comment counts); similar-film relationships; person filmographies by role (director, actor); public member profile stats (films watched, films this year, lists, following, followers); and popular film charts by period, genre, and decade. Public data only — never private diary entries, watchlists, or bulk-republished review text.

Limitations and common challenges

• Explicit ToS restriction. Letterboxd's terms prohibit automated data gathering without written consent — scope any project to public reference fields, never bulk-republish full review text, and consider applying for the official API beta for larger commercial use.
• Ratings load client-side. The average rating and histogram come from separate endpoints the browser fetches after the film page loads, not the initial HTML.
• Per-film fan-out. Reviews and similar films each paginate on their own sub-page, so a complete film record takes multiple requests.
• Member data is personal data. Even public profile stats (watch counts, follower counts) can fall under GDPR/CCPA when tied to an identifiable person — collect only public, factual fields and avoid building a profile database without a lawful basis.
• Public data only. This collects what a film or profile page already shows publicly — never a way around a login wall or a way to build a competing catalog product.

Where this gets used

• Film taste and rating dashboards — track a film's average rating and rating distribution over time.
• Recommendation features — power "similar films" and director/cast-based discovery.
• Trending and popularity tracking — monitor what's climbing the popular charts by genre or decade.
• Reception research — pair review sentiment and volume with a film's release window.

Sources

Start collecting

Try it first, free: run any public URL through the Free Web Scraper, or check whether a site blocks bots with the Anti-Bot Checker — no signup.

Test the search, film, and rating-histogram endpoints in the Playground, check the schema in the API docs, and review pricing. Letterboxd tells you what a community of active film watchers actually rates and discusses; pair it with how to scrape IMDb for the canonical cast/crew record, how to scrape TMDB for a clean catalog and image API, or how to scrape Metacritic for critic-score aggregation, to build a full "what's good, who made it, and what people think" pipeline — and if anime is in scope, how to scrape anime data covers the community databases Letterboxd doesn't track. See also how to choose a web scraping API and is web scraping legal.

Part of our how-to-scrape guide series — every platform we cover, in one index.