AI Document Summarizer and Field Extractor

Turn public web pages (HTML, no JavaScript rendering) or plain text into a short summary plus the exact fields you name, as typed JSON rows. Point it at job ads, product pages, press releases or policies, list the fields you want (price, salary, deadline, skills, anything), and get one clean row per document, ready for a spreadsheet, a database or your app.

You bring the model: your own OpenAI key, or a key for OpenRouter or any other OpenAI-compatible service. Your provider bills you for the model; this Actor charges 0.01 USD per processed document plus 0.005 USD per run. No key yet? Just press Start: without a key the run is a preview of the first 3 documents with placeholder values, which costs only the 0.005 USD start fee.

What people use it for

• Job ads: salary, location, remote or not, required skills and the application deadline.
• Product pages: price, currency, stock status, brand and key specifications.
• Press releases and news: company, date, people mentioned and a two-sentence summary.
• Policies and terms: retention periods, notice periods, fees and the clauses you care about.
• Any list of pages you already have: one row per page with the same fields, so pages from different sites become comparable.

How to use it

1. Add the pages under Page URLs, or paste text under Inline documents.
2. Under Fields to extract, name each field, pick its type (string, number, boolean or string[]) and say in a few words what it means.
3. Add your API key under Model and API key and press Start. Or press Start without a key first: the preview shows the exact output format on your own pages for the start fee only.

Example input

{
    "openaiApiKey": "sk-...",
    "model": "gpt-4o-mini",
    "urls": ["https://example.com/"],
    "fields": [
        { "name": "company", "type": "string", "description": "who published the page" },
        { "name": "salary", "type": "number", "description": "monthly salary in DKK" },
        { "name": "remote", "type": "boolean" },
        { "name": "skills", "type": "string[]", "description": "required skills" }
    ],
    "summaryLength": "short",
    "outputLanguage": "English"
}

For OpenRouter or another OpenAI-compatible service, also set openaiBaseUrl (for example https://openrouter.ai/api/v1) and use that service's model name (for example openai/gpt-4o-mini).

Example output

Illustration of the output format. The values below are made up to show the shape of a row for the example input above (a job ad); they are not from a real run.

{
    "name": "Junior Python Developer - Example ApS",
    "source": "url",
    "url": "https://jobs.example.com/junior-python-developer",
    "title": "Junior Python Developer - Example ApS",
    "status": "ok",
    "summary": "Example ApS is hiring a junior Python developer in Aarhus to build internal data tools. The role uses Python and SQL, and applications close on 31 October.",
    "fields": {
        "company": "Example ApS",
        "salary": 42000,
        "remote": false,
        "skills": ["Python", "SQL"]
    },
    "model": "gpt-4o-mini",
    "charged": true,
    "parts": 1,
    "truncated": false,
    "usage": { "promptTokens": 2314, "completionTokens": 187 }
}

A real preview row. This is what a run without a key returned on 2026-10-02 for the default input (example.com and two fields), shortened: placeholder values, not charged.

{
    "name": "Example Domain",
    "url": "https://example.com/",
    "model": "test-mode",
    "summary": "[test mode] 27 words. Starts with: This domain is for use in documentation examples without needing permission. ...",
    "fields": { "company": "[test mode] company", "topics": [] },
    "charged": false
}

What you get per document

Field	Meaning
name, url, title	Where the document came from
summary	2, 5 or 12 sentences, in the document's language or the one you choose
fields	Your fields, typed: string, number, boolean or string[]; null when not stated
status	always ok: skipped and failed documents are not in the dataset
charged	Whether this row was billed
parts, truncated, chars, usage	How the document was processed and the model tokens used

Numbers are normalized: 1.234,50 kr, 1,234.50 and EUR 1 200 all come back as plain numbers.

Pricing (pay per event)

Event	Price
Actor start	0.005 USD per run
Document processed	0.01 USD per document

• The model is billed by your provider, not by this Actor. Set openaiApiKey to your OpenAI key, or to a key for an OpenAI-compatible service plus its openaiBaseUrl.
• No key, preview: without a key the Actor runs in test mode on the first 3 documents, with placeholder values instead of a model call, and says so in the status message. It costs only the 0.005 USD start fee. If none of those pages can be fetched, it shows one built-in sample instead.
• You only pay for documents that were processed successfully. Skipped and failed documents are free: they are listed with the reason in the ISSUES record of the run's key-value store, not in the dataset.
• The run stops starting new documents when your maximum charge for the run is reached, and after 5 documents in a row fail at the model (for example a wrong API key).
• Test mode works the same way on up to 10 documents, also with a key present. Use it to check your field definitions before a paid run.

FAQ

Do I need an API key? For real summaries and fields, yes: an OpenAI key, or a key for an OpenAI-compatible service (OpenRouter and others) together with its openaiBaseUrl. Without a key you get the preview described above.

Which models work? Any chat model your key can use that can answer in JSON. With OpenAI, gpt-4o-mini is fast and cheap and gpt-4o is stronger. With OpenRouter, use its model ids, for example openai/gpt-4o-mini.

What does a run cost? Here: 0.005 USD per run plus 0.01 USD per document processed, so 100 pages cost 1.005 USD on Apify. Your provider bills the model separately; at OpenAI's list price for gpt-4o-mini when this was written (0.15 USD per million input tokens), a 10,000-character page is well under 0.001 USD. Set a maximum charge for the run and the Actor stops starting documents when it is reached.

Am I charged for pages that fail? No. Skipped pages (robots.txt, not found, not HTML, private addresses) and model failures are free and listed with the reason in the run's ISSUES record.

Can it read PDFs, JavaScript-heavy sites or whole websites? Not yet: one HTML or plain-text page per URL, read without running JavaScript, and links are not followed. For a page that needs JavaScript, paste its text as an inline document.

Is my API key safe? It is a secret input: Apify stores it encrypted, and the Actor never writes it to the output or the log. It is only sent to the model endpoint you choose, which must be a public address.

Can I call it from my own code or an automation tool? Yes: like every Apify Actor it runs from the Apify API, the Python and JavaScript clients, and Apify's integrations (Make, Zapier, n8n and others). The API tab on this page shows a ready example.

Good to know

• One page per URL; the Actor does not crawl links. HTML and plain-text pages only (no PDF yet).
• Pages are read as served, without running JavaScript: text that only appears after scripts run (many single-page apps) is not seen. Paste such text as an inline document instead.
• robots.txt is respected, on every redirect too. Pages it disallows are skipped and not charged.
• Only public addresses are fetched: local, private and cloud-metadata addresses are refused, for pages, redirects and your own model endpoint alike.
• Long documents are processed in parts of about 12,000 tokens (roughly 36,000 characters of English text, fewer for Chinese or Japanese) and the part results are merged. Text beyond "Max characters per document" (default 40,000, up to 400,000) is cut off, and the row says truncated: true. Longer documents mean more model calls on your provider's bill.
• Limits per run: at most 1,000 documents, 30 fields (descriptions up to 120 characters) and instructions up to 500 characters.
• The model must be able to answer in JSON; most current chat models can. Summary quality and languages are the model's: the summary follows the document's language unless you set one.
• Text inside the document is treated as data: the model is told to ignore instructions hidden in a page.
• Your API key is a secret input: it is stored encrypted by Apify and never written to the output or log.