Letterboxd Has No API: How to Export Film and Review Data in 2026

Letterboxd is where serious film culture lives online — ratings, reviews, lists, and watch diaries from millions of cinephiles. It is also, after years of “coming soon,” still without a public API. The developer waitlist has existed for ages and access remains effectively closed to the general public. If you want Letterboxd film and review data programmatically, the HTML pages are the API. This guide covers exactly that: how to export film and review data from Letterboxd’s public surface in 2026, given that Letterboxd has no API you can sign up for.

The API gap, plainly

Letterboxd has talked about an API for years and has run a private/waitlisted program, but there is no open, self-serve public API a developer can request a key for and start building against. For practical purposes:

• There is no documented public REST/GraphQL endpoint you can call.
• The waitlist has been the answer for so long that planning around “the API” is not a plan.
• Everything you can see in a logged-out browser — film pages, rating distributions, reviews, member diaries, lists — is server-rendered HTML.

So when people say Letterboxd has no API, they mean it in the way that matters: you build against the public HTML, not a sanctioned data feed. The upside is that Letterboxd’s HTML is clean, consistent, and stable — it is one of the more pleasant sites to extract from.

What data is actually available

From the public pages you can reliably get:

• Film data: title, release year, the canonical film slug/URL, director(s), the average weighted rating, the rating count, and the rating histogram (how many half-star to five-star ratings).
• Reviews: the reviewer’s username, their star rating (Letterboxd uses half-star granularity, 0.5–5.0), whether it is a rewatch, whether the review is liked, the like count, the review date, and the review text.
• Spoiler and length handling: reviews can be truncated on listing pages and marked as spoilers — the full body lives on the individual review page.
• Member context: diaries, lists, and a member’s own review history, all paginated.

The half-star scale and the rating histogram are the fields that make Letterboxd uniquely valuable versus IMDb or other sources.

How the public HTML surface works

A few mechanics define a Letterboxd API alternative built on HTML:

• Film pages carry structured data. The film page exposes the title, year, and director in clean markup and includes JSON-LD (application/ld+json) for the core film fields and aggregate rating — parse that first, fall back to the DOM for anything not in it.
• The ratings histogram is its own fragment. Letterboxd serves the rating distribution from a dedicated path under the film, which is the reliable way to get the full half-star breakdown rather than scraping the visual bars.
• Reviews are paginated. A film’s reviews live at /film/<slug>/reviews/ and page with /page/<N>/. You loop pages until the review list is empty. You can also sort (by recency, by activity) via the URL.
• Full text needs the per-review page. On listing pages, longer reviews and spoiler reviews are truncated. Each review has its own permalink; fetch it to get the complete body. Build the full-text fetch into your loop for any review flagged as truncated or spoiler-hidden.
• Members and lists paginate the same way. A member’s reviews, diary, and lists all follow the /page/<N>/ pattern.

One practical note from the field: some of these paths (the full-text review page, certain AJAX fragments) reject naive curl with a 403 but respond fine to a browser-grade HTTP client that sends realistic headers. Use a proper scraping HTTP client, not bare curl.

Rate limits and how to live with them

There is no published quota because there is no API, but it is a normal site with normal protections:

• Keep concurrency modest and add jitter; you are walking pagination, so politeness keeps you unblocked.
• Use a browser-grade client (realistic user agent and headers) — the bare-curl 403 is the most common false alarm.
• Cache the film-level data (rating, histogram, director) once per film rather than re-fetching it for every review.
• For a popular film with thousands of reviews, plan for an overnight crawl across the review pages, and fetch full text only where needed to keep request counts down.

▶ Try the Letterboxd Film Review Scraper on Apify — export ratings, histograms, and full-text reviews for any film. No auth required.

A clean output schema

Normalize to one row per review, carrying the film context:

{
  "film_slug": "the-substance",
  "film_title": "The Substance",
  "film_year": 2024,
  "director": "Coralie Fargeat",
  "film_avg_rating": 3.9,
  "film_rating_count": 412000,
  "rating_histogram": { "0.5": 4200, "1": 6100, "3": 88000, "4": 150000, "5": 90000 },
  "review_id": "987654321",
  "reviewer_username": "filmfan_42",
  "rating": 4.5,
  "is_rewatch": false,
  "review_text": "A body-horror gut-punch that earns every gross-out...",
  "contains_spoilers": false,
  "likes_count": 213,
  "review_date": "2026-05-30",
  "review_url": "https://letterboxd.com/filmfan_42/film/the-substance/",
  "scraped_at": "2026-06-07T12:00:00Z"
}

Keep rating as a half-step float (0.5–5.0, nullable — some reviews carry no rating), keep rating_histogram as an object, and store contains_spoilers and is_rewatch since both change how you interpret the text.

Use cases

• Film sentiment and reception research. Track how a release’s rating and review tone evolve from premiere through wide release.
• Recommendation and taste modeling. Half-star ratings tied to usernames are a strong collaborative-filtering signal.
• Cultural and academic study. Analyze review language at scale across genres, directors, or eras.
• Marketing and distribution insight. Studios and distributors gauge cinephile reception independent of aggregate critic scores.

Build it yourself vs. a managed actor

Letterboxd’s clean HTML makes a basic build approachable — JSON-LD for the film, paginate the reviews, fetch full text where truncated. The maintenance cost is smaller than most sites here, but the per-review full-text fetch, the spoiler/truncation handling, the browser-grade-client requirement, and pagination across thousands of reviews still add up into a real job. A managed actor turns it into a film URL and handles the full-text fetch and pagination. Build it yourself for one film; use the managed route for a corpus or an ongoing reception monitor.

Common pitfalls

• Using bare curl — it 403s on the full-text and AJAX paths; send realistic browser headers.
• Trusting truncated text — listing-page bodies are cut off; fetch the review permalink for the full text.
• Forcing a 5-star integer scale — Letterboxd is half-stars, and some reviews have no rating at all.
• Scraping the histogram bars visually — use the dedicated ratings fragment for exact counts.
• Ignoring is_rewatch — rewatch reviews skew sentiment and recency analysis.

Wrapping up

Letterboxd has no API you can sign up for, and the waitlist is not a plan — but the public HTML is clean, structured, and stable, which makes it one of the friendlier sites to export from. The approach is JSON-LD for the film, the ratings fragment for the histogram, paginated review pages, and a per-review full-text fetch with a browser-grade client. Build it yourself for a single film, or let a managed scraper handle full text, spoilers, and pagination for a full reception dataset.

▶ Open the Letterboxd Film Review Scraper on Apify — half-star ratings, histograms, and complete review text for any film. Pay per review returned, no API key needed.