Movie Script Scraper

Find publicly available movie scripts and screenplays by title, extract clean metadata, and return screenplay text in structured dataset rows that are ready for research, indexing, enrichment, and analysis workflows.

This Actor is designed for clients who need script data without building and maintaining their own crawler. It searches supported public screenplay sources automatically, emits one metadata row per matched script, and streams script text as chunk rows while the run is still in progress.

Verified example

A live single-title Matrix run returned one metadata record and eight text chunks in 6.4 seconds at 256 MB. A separate 100-script IMSDb run completed in 7 minutes 44 seconds with 1,107 valid dataset rows. Source availability and input affect performance.

{"type":"script_metadata","title":"The Matrix","scriptUrl":"https://imsdb.com/scripts/Matrix,-The.html","hasScriptText":true,"chunkCount":8,"wordCount":23137}

What You Get

• Public screenplay discovery from supported script sources
• Movie title, writers, genres, source URLs, format, draft details when available
• Plain-text screenplay chunks for sources that expose readable HTML or TXT script text
• Compact metadata rows for PDF, external, or metadata-only matches
• Linked error diagnostics for unsupported inputs, extraction failures, or no-result searches
• Low-cost defaults: no browser, no proxy by default, 256 MB for automatic PDF support; 128 MB with PDF extraction off

Best For

• Screenplay research datasets
• Movie script search and cataloging
• LLM or vector-index preparation
• Writer, genre, and structure analysis
• Building internal screenplay reference tools
• Finding public source links for scripts at scale

Supported Sources

Title searches automatically check IMSDb, Daily Script and SimplyScripts. Direct Script Slug URLs are also supported.

Source	Support
IMSDb	Metadata and HTML script text
The Daily Script	Metadata, HTML text, and TXT text
SimplyScripts	Metadata, TXT links, PDF links, and conservative external-link handling
Script Slug	Direct script URLs: metadata and public PDF links when available

Readable HTML and TXT results are delivered first. If the requested limit still has room, text PDFs are converted using PDF to Markdown Scraper. OCR and AI cleanup are off. Conversion has separate page charges; partial or unreadable results are labeled in Downloads. Set extractPdfText to false to keep PDF links only.

Input

Provide a movie name or search list, then optionally set Maximum scripts. PDF controls and the release-year filter are advanced options.

One Movie

Use movieName when you want one best-match screenplay.

{
  "movieName": "The Matrix"
}

Multiple Searches

Use searches when you want results for multiple movie titles or search terms.

{
  "searches": ["The Matrix", "Alien", "Terminator"]
}

Input Notes

• If movieName and searches are both filled, movieName takes priority.
• Keep movie titles specific for best matching.
• Results are pushed to the dataset as they are scraped, not only after the run finishes.
• Single-title runs use the cheapest defaults. Multi-search runs use more memory because they can return many scripts and chunks.

Output

Results are available in the default dataset. The Actor emits these row types:

Type	Meaning
script_metadata	One summary row for each matched script
script_chunk	Plain-text screenplay content split into ordered chunks
script_analysis	Optional analysis row in advanced runs

Error diagnostics are stored in the linked ERRORS key-value record, outside the paid default dataset. They retain type: "error" and the existing error fields. A run with no delivered screenplay metadata fails clearly.

Unknown or unavailable success fields are omitted instead of filled with null.

Metadata Row Example

{
  "type": "script_metadata",
  "source": "imsdb",
  "scrapedAt": "2026-06-08T07:00:00.000Z",
  "scriptId": "imsdb-the-matrix",
  "scriptUrl": "https://imsdb.com/scripts/Matrix,-The.html",
  "title": "The Matrix",
  "writers": ["Larry Wachowski", "Andy Wachowski"],
  "genres": ["Action", "Sci-Fi", "Thriller"],
  "scriptFormat": "html",
  "hasScriptText": true,
  "chunkCount": 8,
  "wordCount": 23137,
  "characterCount": 143493,
  "sceneCount": 119
}

The metadata row does not contain the full script text.

Chunk Row Example

{
  "type": "script_chunk",
  "source": "imsdb",
  "scrapedAt": "2026-06-08T07:00:00.000Z",
  "scriptId": "imsdb-the-matrix",
  "scriptUrl": "https://imsdb.com/scripts/Matrix,-The.html",
  "title": "The Matrix",
  "chunkIndex": 1,
  "chunkMode": "fixed_size",
  "chunkTitle": "Chunk 1",
  "chunkText": "THE MATRIX\\n\\nWritten by Larry and Andy Wachowski...",
  "chunkCharacterCount": 19995,
  "chunkWordCount": 3300,
  "nextChunkIndex": 2
}

The default chunking is optimized for cost by using larger chunks, so fewer dataset rows are created while preserving the full extracted script text.

Error Diagnostic Example

{
  "type": "error",
  "source": "unknown",
  "scrapedAt": "2026-06-08T07:00:00.000Z",
  "url": "https://apify.com/actors/thescrapelab/screenplay-script-scraper",
  "status": "failed",
  "errorType": "NO_RESULTS",
  "errorMessage": "No matching screenplay results found for: Example Missing Movie",
  "retryable": false
}

How To Use The Results

1. Start the Actor from Apify Console.
2. Enter either a single movieName or a searches list.
3. Open the dataset while the run is active to see rows appear during scraping.
4. Use script_metadata rows for cataloging and filtering.
5. Use script_chunk rows for text indexing, search, LLM workflows, or downstream analysis.

Python API Example

from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run_input = {
    "movieName": "The Matrix",
}

run = client.actor("thescrapelab/screenplay-script-scraper").call(run_input=run_input)
if run is None:
    raise RuntimeError("Actor call returned no run or storage metadata")

dataset_id = (run["defaultDatasetId"] if isinstance(run, dict) else run.default_dataset_id)
items = list(client.dataset(dataset_id).iterate_items(clean=True))

metadata_rows = [item for item in items if item.get("type") == "script_metadata"]
chunk_rows = [item for item in items if item.get("type") == "script_chunk"]

print(f"Scripts found: {len(metadata_rows)}")
print(f"Text chunks: {len(chunk_rows)}")

for row in metadata_rows:
    print(row.get("title"), row.get("scriptUrl"), row.get("wordCount"))

For multiple searches:

run_input = {
    "searches": ["The Matrix", "Alien", "Terminator"],
}

Cost And Performance

The Actor is tuned to keep run costs low:

• Uses lightweight HTTP crawling, not a browser
• Uses direct public requests by default, not a proxy
• Uses 256 MB memory for single-title runs with PDF support
• Uses larger text chunks by default to reduce dataset item count
• Streams rows as they are found

For a typical single-title screenplay such as The Matrix, the Actor returns one metadata row plus a small number of chunk rows while preserving the full extracted script text.

Practical Tips

• Use movieName for the cheapest, most focused run.
• Use searches when you want broader discovery across multiple titles.
• Prefer exact titles over broad words.
• Expect metadata-only rows for PDF-only or external sources.
• Check hasScriptText and chunkCount to identify rows with extracted screenplay text.

Limitations

• The Actor only uses publicly accessible pages.
• It does not bypass paywalls, logins, CAPTCHAs, or access controls.
• Source websites can change their layout, availability, or robots rules.
• Some public sources expose only PDF or external links; those may return metadata rows rather than script text.
• Search matching is title-oriented and may return related sequels, remakes, or same-franchise scripts.
• Word counts, scene counts, and draft detection are approximate.

Legal And Ethical Notice

Movie scripts and screenplays may be copyrighted. This Actor is intended for indexing, metadata extraction, research, discovery, and analysis of publicly available pages.

You are responsible for ensuring that your use complies with copyright law, source website terms, robots.txt, and applicable regulations. The Actor is not a piracy tool and does not bypass access controls.

Support

If a title does not return the expected script, try a more exact movie title. If a source changes or a result looks wrong, rerun with a narrower query and review source and scriptUrl in the dataset, plus errorType and errorMessage in the linked ERRORS output.

Error diagnostics previously appeared as dataset rows. Integrations should now read the linked ERRORS output; successful metadata, chunk and analysis fields are unchanged. Errors no longer incur a dataset result event.

Complete content and delivery failures

Before charging a movie-script event, the Actor saves its complete metadata, text chunks and requested analysis as a key-value artifact. Complete screenplay assets links to the SCRIPT_ASSETS index; each entry gives the artifact key and script ID. Dataset metadata, chunk and analysis fields remain unchanged.

The metadata row is delivered through Apify's combined result-write and movie-event operation. The dataset save must succeed before the movie event is charged. Delivery is serialized, and the spending allowance must cover the movie event plus all associated existing dataset events before it begins. Prices and event identifiers are unchanged.

If a later chunk export fails, the saved complete artifact remains available. Storage failures or uncertain charge acknowledgements stop further delivery without automatic paid replay. Inspect the original dataset, saved artifacts and ERRORS before starting another run. A new run is a fresh paid snapshot; this is not an exactly-once service across separate runs or resurrection.

Collection sources

Collection uses public pages, published documents or rendered page content. Optional AI features use OpenRouter. Source API fallbacks and general calls to other Actors are unavailable. The only child Actor is the pinned PDF to Markdown converter used for public text PDFs, with OCR and AI cleanup disabled. A source that cannot provide usable page content may fail or return explicitly incomplete coverage; an older successful run does not guarantee current availability.

Batch-to-TXT tutorial

Use movieName for one best match, or omit it for a batch. maxScripts caps the entire batch, not each query. Searches can return related titles; verify the source and year. Unknown source years cannot be verified by the year filter.

from apify_client import ApifyClient
import os
from pathlib import Path

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("thescrapelab/screenplay-script-scraper").call(
    run_input={"searches": ["The Matrix", "Alien"], "maxScripts": 2,
               "extractPdfText": True, "maxPdfChargeUsd": 0.25},
    max_total_charge_usd=0.50,
)
if run is None:
    raise RuntimeError("No run returned")
dataset_id = run["defaultDatasetId"] if isinstance(run, dict) else run.default_dataset_id
chunks = {}
for row in client.dataset(dataset_id).iterate_items():
    if row.get("type") == "script_chunk":
        chunks.setdefault(row["scriptId"], []).append(row)
for script_id, rows in chunks.items():
    text = "\n\n".join(r["chunkText"] for r in sorted(rows, key=lambda r: r["chunkIndex"]))
    Path(script_id + ".txt").write_text(text, encoding="utf-8")

Open Screenplay downloads for TXT and JSON files, plus Markdown for PDF text. Read each download's status: complete, partial, unavailable or metadata_only. Access uses your Apify storage permissions and retention period; these are not permanent public hosting links. Run summary and PDF conversion details explain coverage and child runs.

PDF limits and charges

The existing screenplay event is $0.012 per delivered screenplay. Existing start/dataset charges also apply. PDF conversion additionally uses the separately billed PDF to Markdown Actor, with no AI cleanup or OCR. Its current highest page-event rate is $0.00125 per extracted page, plus its start event; a 120-page PDF is approximately $0.15 in PDF event fees alone. Applicable platform usage can add costs. The default $0.25 PDF event allowance is shared across the run, not renewed per document, and allows up to approximately 199 pages at that rate. Each PDF attempt is limited to 200 pages and 180 seconds, further bounded by remaining time and allowance. A finite parent event limit further constrains conversion. Platform usage is not capped by the PDF event allowance. Metadata-only and partial results remain explicitly identified; no guaranteed full-script delivery is implied.

This release enables automatic text-PDF conversion. Existing clients can retain link-only behavior with extractPdfText:false. Existing dataset fields and the public Actor URL remain available. No source content is licensed for AI training merely by being publicly accessible.

Larger batches

For a 100-script collection, request 512 MB and use a longer run timeout (900 seconds is a reasonable starting point) and a spending allowance covering all screenplay and optional PDF events. The five-minute default targets the single-movie example. Requested limits are upper bounds: missing, unreadable or unavailable source scripts can reduce delivered results. Discovery allows a small replacement buffer for unavailable matches and stops when the delivered-script limit is reached.

Script Slug PDF extraction is verified through direct supported script URLs; automatic source-wide Script Slug search is not configured. IMSDb, Daily Script and SimplyScripts discovery remain dependent on their available indexes.

Single-title runs with automatic PDF extraction use 256 MB to import complete multi-page results safely. Set extractPdfText:false for the 128 MB HTML/TXT path. The Console memory expression selects 512 MB for search lists. API clients should explicitly request 512 MB for larger batches; the API default is 256 MB. The converter runs separately at 512 MB.

Release-year filters retain scripts with unknown release years. Draft/revision dates are reported separately and are not treated as film release years. SimplyScripts landing pages are followed to readable screenplay documents; navigation text is not delivered as screenplay content.