# Letterboxd Film Pages Scraper (`parseforge/letterboxd-films-scraper`) Actor

Pull film data from Letterboxd. Returns title, year, runtime, tagline, description, poster, director, production companies, countries, languages, genres, IMDB + TMDB IDs, average rating, watch count, like count, list count, tags. Look up by slug or pull from popular lists.

- **URL**: https://apify.com/parseforge/letterboxd-films-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Videos, Other, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $14.00 / 1,000 result items

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🎞️ Letterboxd Film Database Scraper

> 🚀 **Pull Letterboxd films with cast, directors, writers, themes, languages, studios, rating, watch counts, TMDB and IMDB IDs. 38 fields per film.**

> 🕒 **Last updated:** 2026-05-08 · **📊 38 fields** per record · **Letterboxd films** · cast + directors + writers + editors + producers + composers · genres + themes + languages + studios · rating + watch / like / list counts · TMDB + IMDB IDs

The **Letterboxd Film Database Scraper** pulls film records from Letterboxd, the social network for cinephiles. Output includes poster URL, slug, title + original title, year, runtime, tagline, description, directors + writers + editors + producers + cinematography + composers, full cast (names) + cast with character roles, genres + themes, primary language + spoken languages, production companies + studios, countries, alternative titles, average rating, rating count, watched-by count, liked-by count, appears-in-lists count, trailer URL, TMDB + IMDB IDs, and the Letterboxd URL.

Direct lookup only - feed a list of slugs (e.g. `the-godfather`, `pulp-fiction`), get rich records back. Each record is parsed from the film's HTML page. The scraper uses Chrome TLS fingerprinting via impit to bypass Cloudflare without needing a residential proxy, so 100 lookups complete in under a minute.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Film recommender builders, cinephiles, ML researchers, journalists, content marketers, fan-app developers | Film-recommender training, cinephile content, retrospective writing, watch-history analytics, fan apps |

---

### 📋 What the Letterboxd Film Database Scraper does

Five filtering workflows in a single run:

- 🆔 **Direct slug lookup.** One slug per line, full film record per slug.
- 🎭 **Full cast + crew.** Cast (with character roles), directors, writers, editors, producers, composers.
- 🏷️ **Genres + themes.** Both Letterboxd's genres tab and themes tab.
- 📊 **Member stats.** Watched-by, liked-by, and appears-in-lists counts.
- ⚡ **Fast no-proxy bypass.** Chrome TLS fingerprint via impit. 100 films in under a minute.

> 💡 **Why it matters:** clean, server-side filtering and fresh data on every run.

---
### 🎬 Full Demo

_🚧 Coming soon: a 3-minute walkthrough showing how to go from sign-up to a downloaded dataset._

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td><code>maxItems</code></td><td>integer</td><td><code>10</code></td><td>Records to return. Free plan caps at 10, paid plan up to 1,000,000.</td></tr>
<tr><td><code>slugs</code></td><td>string</td><td><code>""</code></td><td>Newline-separated film slugs (e.g. `the-godfather`, `inception`). Full URLs are also accepted.</td></tr>
</tbody>
</table>

**Example: classic films.**

```json
{
    "maxItems": 10,
    "slugs": "the-godfather\nthe-shawshank-redemption\npulp-fiction\ngoodfellas\nschindlers-list\nthe-dark-knight\ninception\nfight-club\nforrest-gump\ninterstellar"
}
````

**Example: foreign cinema.**

```json
{
    "maxItems": 10,
    "slugs": "spirited-away\nparasite-2019\noldboy-2003\namelie\nrome-open-city\ntokyo-story\nseven-samurai"
}
```

***

### 📊 Output

Each record contains **38 fields**. Download as CSV, Excel, JSON, or XML.

#### 🧾 Schema

| Field | Type | Example |
|---|---|---|
| 🖼️ `posterUrl` | string | `"https://a.ltrbxd.com/.../poster.jpg"` |
| 🆔 `slug` | string | `"the-godfather"` |
| 📛 `title` | string | `"The Godfather"` |
| 📅 `year` | number | `1972` |
| ⏱️ `runtimeMinutes` | number | `175` |
| 📜 `tagline` | string | `"An offer you can't refuse."` |
| 📜 `description` | string | `"The aging patriarch of an organized crime dynasty..."` |
| 🎬 `directors` | array | `["Francis Ford Coppola"]` |
| 🎭 `cast` | array | `["Marlon Brando","Al Pacino","James Caan",...]` |
| 🎭 `castWithRoles` | array of objects | `[{"name":"Marlon Brando","role":"Don Vito Corleone"},...]` |
| ✍️ `writers` | array | `["Mario Puzo","Francis Ford Coppola"]` |
| ✂️ `editors` | array | `["William Reynolds","Peter Zinner"]` |
| 🏷️ `genres` | array | `["Crime","Drama"]` |
| 🏷️ `themes` | array | `["Mafia","Family Dynasty"]` |
| 🌐 `primaryLanguage` | string | `"English"` |
| 🏢 `studios` | array | `["Paramount Pictures","Alfran Productions"]` |
| ⭐ `averageRating` | number | `4.5` |
| 🗳️ `ratingCount` | number | `987456` |
| 👁️ `watchedBy` | number | `2400000` |
| ❤️ `likedBy` | number | `850000` |
| 🆔 `tmdbId` | number | `238` |
| 🆔 `imdbId` | string | `"tt0068646"` |
| 🌐 `letterboxdUrl` | string | `"https://letterboxd.com/film/the-godfather/"` |

#### 📦 Sample records

<details>
<summary><strong>🎞️ The Godfather (1972)</strong></summary>

```json
{"slug":"the-godfather","title":"The Godfather","year":1972,"directors":["Francis Ford Coppola"],"averageRating":4.5,"watchedBy":2400000,"tmdbId":238,"imdbId":"tt0068646"}
```

</details>

<details>
<summary><strong>🎞️ Parasite (2019)</strong></summary>

```json
{"title":"Parasite","year":2019,"directors":["Bong Joon-ho"],"primaryLanguage":"Korean","averageRating":4.5}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 🎭 | **Real cast + crew.** Cast names with character roles, full director / writer / editor / producer / composer credits. |
| 📊 | **Letterboxd-only metrics.** Watched-by, liked-by, appears-in-lists counts unique to Letterboxd. |
| 🏷️ | **Themes alongside genres.** Letterboxd's themes (e.g. Mafia, Existentialism, Family Dynasty), richer than generic genres. |
| 🆔 | **TMDB + IMDB IDs.** Cross-platform joins out of the box. |
| ⚡ | **Fast no-proxy bypass.** 100 films in under a minute, no residential proxy needed. |

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Filters | Setup |
|---|---|---|---|---|---|
| **⭐ This Actor** | $5 free credit | **Letterboxd** | Live per run | Lookup | ⚡ 1 min |
| TMDB API | Free with key | Same films | Live | Yes | 🐢 Code |
| OMDb (paid) | $1+/1k | IMDB-style | Live | Yes | 🐢 Account |
| Manual scraping | Free | All | Live | DIY | 🐢 Days |

***

### 🚀 How to use

1. 📝 **Sign up.** [Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) (takes 2 minutes).
2. 🌐 **Open the Actor.** Find the Letterboxd Film Database Scraper on the Apify Store.
3. 🎯 **Set input.** Pick filters and `maxItems`.
4. 🚀 **Run it.** Click **Start**.
5. 📥 **Download.** Grab results in the **Dataset** tab as CSV, Excel, JSON, or XML.

> ⏱️ Total time from signup to dataset: **3-5 minutes.** No coding required.

***

### 💼 Business use cases

<table>
<tr>
<td width="50%" valign="top">

#### 🎬 Film Recommender + Apps

- Build a Letterboxd-style app
- Train cast-based similarity
- Discover-by-theme tools
- Cinephile newsletters

</td>
<td width="50%" valign="top">

#### 📰 Film Journalism

- Director retrospectives
- Cast filmographies
- Theme-based pieces
- Award-season coverage

</td>
</tr>
<tr>
<td width="50%" valign="top">

#### 🤖 ML + Research

- Cast-graph extraction
- Theme-genre embeddings
- Rating-prediction models
- Cross-platform ID joins

</td>
<td width="50%" valign="top">

#### 🎓 Film Studies

- Course materials
- Research on film networks
- Reproducible film datasets
- Hobbyist criticism

</td>
</tr>
</table>

***

### 🔌 Automating Letterboxd Film Database Scraper

Control the scraper programmatically:

- 🟢 **Node.js.** Install the `apify-client` NPM package.
- 🐍 **Python.** Use the `apify-client` PyPI package.
- 📚 See the [Apify API documentation](https://docs.apify.com/api/v2) for full details.

The [Apify Schedules feature](https://docs.apify.com/platform/schedules) lets you trigger this Actor on any cron interval.

***

### 🌟 Beyond business use cases

Data like this powers more than commercial workflows.

<table>
<tr>
<td width="50%">

#### 🎓 Research and academia

- Film studies datasets
- Cast-network analysis
- Reproducible Letterboxd snapshots
- Theme-evolution research

</td>
<td width="50%">

#### 🎨 Personal and creative

- Personal watchlist apps
- Cinephile blogs
- Side projects with film data
- Letterboxd-style hobby projects

</td>
</tr>
<tr>
<td width="50%">

#### 🤝 Non-profit and civic

- Library cinema programs
- Free film-education content
- Heritage cinema preservation
- Community film clubs

</td>
<td width="50%">

#### 🧪 Experimentation

- Train recommender systems
- Prototype theme-discovery tools
- Build cast-graph visualizers
- Test rating-prediction models

</td>
</tr>
</table>

***

### 🤖 Ask an AI assistant about this scraper

Open a ready-to-send prompt in the AI of your choice:

- 💬 [**ChatGPT**](https://chat.openai.com/?q=How%20do%20I%20use%20the%20Letterboxd%20Film%20Database%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🧠 [**Claude**](https://claude.ai/new?q=How%20do%20I%20use%20the%20Letterboxd%20Film%20Database%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🔍 [**Perplexity**](https://perplexity.ai/search?q=How%20do%20I%20use%20the%20Letterboxd%20Film%20Database%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🅒 [**Copilot**](https://copilot.microsoft.com/?q=How%20do%20I%20use%20the%20Letterboxd%20Film%20Database%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)

***

### ❓ Frequently Asked Questions

#### 🧩 How does it work?

Provide a list of Letterboxd film slugs. The Actor fetches each film's HTML page (using Chrome TLS fingerprinting), parses JSON-LD plus structured DOM, and emits one record per film.

#### 📊 How many fields per record?

38, including cast (with roles), directors, writers, editors, producers, themes, languages, studios, rating, watch / like / list counts, TMDB and IMDB IDs.

#### 🆔 Where do I get slugs?

From Letterboxd URLs - `https://letterboxd.com/film/the-godfather/` → slug = `the-godfather`. The Actor accepts both formats.

#### ⚡ Why so fast without a proxy?

The Actor uses impit (Rust-backed HTTP client) which mimics Chrome's TLS fingerprint. Letterboxd's Cloudflare lets it through without challenge.

#### 🎭 Does it return the full cast?

All cast members listed on the film's main page (typically 20-30+ depending on film).

#### 🏷️ What are themes?

Letterboxd's curated thematic tags (e.g. Mafia, Existentialism, Coming of Age) - distinct from generic genres.

#### 📊 Are member stats live?

Yes. Watched-by / liked-by / appears-in-lists are pulled from each film's main page on every run.

#### 🆔 Are TMDB and IMDB IDs always present?

Yes for the vast majority of films. Letterboxd cross-references both.

#### 🆓 Do I need an API key?

No. Letterboxd has no public API; the Actor scrapes HTML.

#### 💳 Do I need a paid Apify plan?

No. The free plan covers preview runs (10 records).

***

### 🔌 Integrate with any app

Letterboxd Film Database Scraper connects to any cloud service via [Apify integrations](https://apify.com/integrations):

- [**Make**](https://docs.apify.com/platform/integrations/make) - Automate multi-step workflows
- [**Zapier**](https://docs.apify.com/platform/integrations/zapier) - Connect with 5,000+ apps
- [**Slack**](https://docs.apify.com/platform/integrations/slack) - Get run notifications
- [**Airbyte**](https://docs.apify.com/platform/integrations/airbyte) - Pipe data into your warehouse
- [**GitHub**](https://docs.apify.com/platform/integrations/github) - Trigger runs from commits
- [**Google Drive**](https://docs.apify.com/platform/integrations/drive) - Export datasets to Sheets

***

### 🔗 Recommended Actors

- [**🎬 TMDB Movies, TV, People**](https://apify.com/parseforge/tmdb-movies-tv-scraper) - Pull movies, TV, people with cast, crew, trailers, ratings
- [**🍳 Meal Recipes**](https://apify.com/parseforge/themealdb-recipes-scraper) - Recipes with ingredients, instructions, image, video
- [**🍹 Cocktail Drinks**](https://apify.com/parseforge/thecocktaildb-drinks-scraper) - Cocktail recipes with ingredients, glass, IBA, image
- [**🃏 Yu-Gi-Oh! Card Database**](https://apify.com/parseforge/yugioh-card-database-scraper) - Yu-Gi-Oh! cards with stats, archetypes, sets, prices
- [**🧠 Open Trivia DB Questions**](https://apify.com/parseforge/opentdb-trivia-scraper) - Trivia questions across 24 categories with answers

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more reference-data scrapers.

***

**🆘 Need Help?** [**Open our contact form**](https://tally.so/r/BzdKgA) to request a new scraper, propose a custom data project, or report an issue.

***

> **⚠️ Disclaimer:** this Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Letterboxd, its maintainers, the Letterboxd community, or any film studio, distributor, director, or actor. All trademarks mentioned are the property of their respective owners. Only publicly available open data is collected.

# Actor input Schema

## `maxItems` (type: `integer`):

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## `mode` (type: `string`):

Choose 'lookup' to fetch films by slug, or 'search' to find films by keyword (title, director, etc).

## `slugs` (type: `string`):

Lookup mode only. Letterboxd film slugs (URL part). One per line. Examples: `inception`, `parasite-2019`, `the-godfather`.

## `query` (type: `string`):

Search mode only. Free-text query matched against Letterboxd's film index (title, director, cast). Paginates via cursor — set maxItems to as many as you need.

## Actor input object example

```json
{
  "maxItems": 10,
  "mode": "lookup",
  "slugs": "inception\nparasite-2019\nthe-godfather\nthe-dark-knight\npulp-fiction\n2001-a-space-odyssey\nthere-will-be-blood\nthe-godfather-part-ii\nspirited-away\nin-the-mood-for-love\ngoodfellas\nfight-club\nthe-shawshank-redemption\nthe-empire-strikes-back\nblade-runner-2049\noppenheimer\nthe-lord-of-the-rings-the-fellowship-of-the-ring\nthe-lord-of-the-rings-the-two-towers\nthe-lord-of-the-rings-the-return-of-the-king",
  "query": "godfather"
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "maxItems": 10,
    "mode": "lookup",
    "slugs": `inception
parasite-2019
the-godfather
the-dark-knight
pulp-fiction
2001-a-space-odyssey
there-will-be-blood
the-godfather-part-ii
spirited-away
in-the-mood-for-love
goodfellas
fight-club
the-shawshank-redemption
the-empire-strikes-back
blade-runner-2049
oppenheimer
the-lord-of-the-rings-the-fellowship-of-the-ring
the-lord-of-the-rings-the-two-towers
the-lord-of-the-rings-the-return-of-the-king`,
    "query": "godfather"
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/letterboxd-films-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "maxItems": 10,
    "mode": "lookup",
    "slugs": """inception
parasite-2019
the-godfather
the-dark-knight
pulp-fiction
2001-a-space-odyssey
there-will-be-blood
the-godfather-part-ii
spirited-away
in-the-mood-for-love
goodfellas
fight-club
the-shawshank-redemption
the-empire-strikes-back
blade-runner-2049
oppenheimer
the-lord-of-the-rings-the-fellowship-of-the-ring
the-lord-of-the-rings-the-two-towers
the-lord-of-the-rings-the-return-of-the-king""",
    "query": "godfather",
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/letterboxd-films-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "maxItems": 10,
  "mode": "lookup",
  "slugs": "inception\\nparasite-2019\\nthe-godfather\\nthe-dark-knight\\npulp-fiction\\n2001-a-space-odyssey\\nthere-will-be-blood\\nthe-godfather-part-ii\\nspirited-away\\nin-the-mood-for-love\\ngoodfellas\\nfight-club\\nthe-shawshank-redemption\\nthe-empire-strikes-back\\nblade-runner-2049\\noppenheimer\\nthe-lord-of-the-rings-the-fellowship-of-the-ring\\nthe-lord-of-the-rings-the-two-towers\\nthe-lord-of-the-rings-the-return-of-the-king",
  "query": "godfather"
}' |
apify call parseforge/letterboxd-films-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=parseforge/letterboxd-films-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Letterboxd Film Pages Scraper",
        "description": "Pull film data from Letterboxd. Returns title, year, runtime, tagline, description, poster, director, production companies, countries, languages, genres, IMDB + TMDB IDs, average rating, watch count, like count, list count, tags. Look up by slug or pull from popular lists.",
        "version": "1.0",
        "x-build-id": "LmKcB1zuUUXDOkHKx"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~letterboxd-films-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-letterboxd-films-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/parseforge~letterboxd-films-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-letterboxd-films-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/parseforge~letterboxd-films-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-letterboxd-films-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "lookup",
                            "search"
                        ],
                        "type": "string",
                        "description": "Choose 'lookup' to fetch films by slug, or 'search' to find films by keyword (title, director, etc)."
                    },
                    "slugs": {
                        "title": "Film slugs",
                        "type": "string",
                        "description": "Lookup mode only. Letterboxd film slugs (URL part). One per line. Examples: `inception`, `parasite-2019`, `the-godfather`."
                    },
                    "query": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Search mode only. Free-text query matched against Letterboxd's film index (title, director, cast). Paginates via cursor — set maxItems to as many as you need."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
