# LLM Web Data Extractor for OpenAI, Anthropic, Gemini Keys (`cliqtomedia/llm-web-extractor`) Actor

Turn public web pages into structured JSON with your own OpenAI, Anthropic or Gemini API key. List the fields you want or paste a JSON Schema; get one clean row per page with the tokens your key used. No login, no scraping code.

- **URL**: https://apify.com/cliqtomedia/llm-web-extractor.md
- **Developed by:** [Cliqto Media](https://apify.com/cliqtomedia) (community)
- **Categories:** AI, Developer tools
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.40 / 1,000 page extracteds

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

Turn public web pages into structured JSON with your own OpenAI, Anthropic or Google Gemini API key: give page URLs and the fields you want, and get one row per page with the values and the tokens your key used. A typical run reads one page in a few seconds and costs $0.008 on Apify (run start $0.005 + $0.003 for one page with data); your LLM tokens are billed by your provider.

Use it when you need the same fields from many different sites and do not want to write selectors. The smallest run is one URL, two field names and your API key.

![LLM Web Data Extractor: a public page and two field names go in, your own model returns one JSON row per page with the token count](https://api.apify.com/v2/key-value-stores/Lkpqoi5dHChA0XDf2/records/llm-web-extractor-hero-20261022-v2.png)

### Table of contents

- [What it does](#what-it-does)
- [Your API key is required](#your-api-key-is-required)
- [Quick start](#quick-start)
- [Use cases](#use-cases)
- [Input](#input)
- [Output](#output)
- [Pricing and limits](#pricing-and-limits)
- [API, export and integrations](#api-export-and-integrations)
- [Troubleshooting](#troubleshooting)
- [FAQ](#faq)
- [Support](#support)

### What it does

The Actor downloads each public page, turns its HTML into clean text (Markdown) and sends it to the model you choose, with your field list or JSON Schema. The model answers with JSON that matches your fields. You get one Dataset row per URL with the data, the status, the model and the input and output tokens your key used.

- Values that are not on the page come back as `null`. The model is told never to guess.
- **List mode** returns every record on a page (all plans, all products, all people) in `data.items`.
- A page where the model found none of your fields is marked `not_found` / `NO_DATA`; only the $0.001 page read is charged, not the extraction.

#### Good fit

- The same fields (name, price, date, contact page, specs) from pages on many different sites.
- Pricing tables, product pages, team pages, event pages, job posts: anything readable in the page HTML.
- Teams that already have an OpenAI or Gemini key and want to pay their provider directly for tokens.

#### Not a fit / limits

- Pages that build their content with JavaScript. They are reported as `JS_REQUIRED` and no model call is made.
- Pages behind a login, paywall or bot protection. The Actor never logs in and never bypasses them; HTTP 401/403 pages are errors.
- Crawling a whole site. The Actor reads only the URLs you give (up to 300 per run). It does not follow links.
- Guaranteed accuracy. LLMs can make mistakes; check important values.

### Your API key is required

This Actor does not include model access. You bring a key, and the provider bills its tokens to you.

| Provider | Get a key | Status |
| --- | --- | --- |
| Google Gemini | [aistudio.google.com/apikey](https://aistudio.google.com/apikey) (free tier available) | tested |
| OpenAI | [platform.openai.com/api-keys](https://platform.openai.com/api-keys) | tested |
| Anthropic | [console.anthropic.com/settings/keys](https://console.anthropic.com/settings/keys) | **Anthropic: not tested** with a live key; built to the public API docs |

- The key field is secret. Apify stores it encrypted; the Actor uses it only for this run and never writes it to logs, results or the run summary.
- The key is checked with a free model-info request before any page is read. A wrong key gives one `api_key_invalid` row and stops; no page is charged.
- Without a key the run ends at once with one `api_key_required` row. No page is extracted or charged; only Apify's automatic run-start event (`apify-actor-start`) applies.

**What the quota costs you.** Each page is one model call. A typical page sends 1,000–10,000 input tokens (cap it with `maxPageChars`) and returns 50–500 output tokens. With the default `gemini-flash-lite-latest`, the Apify pricing page used 4,906 input and 121 output tokens; book product pages used about 600–1,300 input and 63–73 output tokens. Check your provider's current prices.

**Quotas and rate limits are yours.** Free tiers allow only a few requests per minute and per day. The Actor waits and retries on a rate limit. When your quota or credit runs out, the run keeps the pages already extracted, marks the rest `skipped` and ends with `PARTIAL` / `QUOTA_LIMIT`. Your provider's terms of use apply to your key. On Gemini's unpaid tier, Google may use the page text and answers to improve its products; use a paid key for private content.

### Quick start

1. Open the **Input** tab. The form is prefilled with `https://apify.com/pricing` and two fields: `plan_name` and `monthly_price`, in list mode.
2. Keep **LLM provider** = Google Gemini (default) or pick OpenAI.
3. Paste your key into **Your API key**.
4. Click **Start**.
5. Open the **Output** tab and check `status` and `data.items`.

Expected result: one `complete` row with four plans and their monthly prices, plus the token count, in a few seconds.

### Use cases

| Buyer job | Input path | Output entity | Key fields | Next integration |
| --- | --- | --- | --- | --- |
| Compare competitor pricing | `urls` + `fields`, `mode: list` | one row per pricing page | `data.items`, `status`, `fetchedAt` | Google Sheets, CSV export |
| Product specs from many shops | `urls` + `jsonSchema` | one row per product page | `data`, `truncated`, `status` | Dataset API, webhook to your database |
| Company facts from About pages | `urls` + `fields` | one row per company page | `data`, `pageTitle`, `finalUrl` | CRM import via Make or Zapier |
| Track token use per page | any | one row per page | `inputTokens`, `outputTokens`, `model` | your cost report |

### Input

#### Input fields

| Field | Plain name | Type | Required | Default / prefill | Allowed values | Effect | Recommendation |
| --- | --- | --- | --- | --- | --- | --- | --- |
| `urls` | Page URLs | array of strings | yes | prefill `https://apify.com/pricing` | 1–300 public http(s) URLs | One model call per page | Duplicates are read once; empty lines are skipped |
| `fields` | Fields to extract | key → description | yes, unless `jsonSchema` | prefill `plan_name`, `monthly_price` | up to 50 fields; type after a colon: `price:number`, `count:integer`, `in_stock:boolean`, `tags:array` | The keys of `data` | Short, clear descriptions help the model |
| `mode` | One record or a list per page | enum | no | default `single`, prefill `list` | `single`, `list` | `list` puts all records in `data.items` | Use `list` for tables and catalogs |
| `provider` | LLM provider | enum | no | `gemini` | `gemini`, `openai`, `anthropic` | Which API gets the key | Anthropic is not tested |
| `apiKey` | Your API key | secret string | yes for any data | — | your provider key | Pays for tokens | Stored encrypted |
| `model` | Model | string | no | empty = `gemini-flash-lite-latest` / `gpt-5.4-mini` / `claude-haiku-5-5` | any model id your key can use | Quality, speed, token price | Reasoning models are slower and use more tokens |
| `jsonSchema` | JSON Schema (advanced) | object | no | — | root object with `properties`, up to 20,000 characters | Replaces `fields` | For nested data and exact types |
| `instructions` | Extra instructions | string | no | — | up to 4,000 characters | Extra hints for the model | Units, currency, what to skip |
| `maxPageChars` | Max page characters sent | integer | no | 40,000 | 2,000–200,000 | Cuts long pages to cap your tokens | Raise it for very long pages (see Troubleshooting) |
| `maxConcurrency` | Pages at the same time | integer | no | 3 | 1–10 | Speed | Lower it for a free-tier key |
| `keepBoilerplate` | Keep navigation and footer | boolean | no | false | true / false | Sends menus and footers too | Only if your data is in the footer |

With no URLs the run does not start. With more than 300 URLs the run fails with `INVALID_INPUT` before any page is read.

#### Interacting settings

| When | Input A | Input B | Effective behavior | Cost/result effect |
| --- | --- | --- | --- | --- |
| Both are set | `jsonSchema` | `fields` | `jsonSchema` wins; `fields` are ignored | none |
| `mode: list` | `mode` | `fields` | Fields describe one record; the result is `data.items` | one charge per page, not per record |
| Long page | `maxPageChars` | page length | Text after the limit is cut; the row has `truncated: true` | more characters = more tokens on your key |
| Many URLs | `urls` | run timeout | 300 pages took about 18 minutes on a free Gemini key | raise the run timeout from the default 300 s |

#### Input examples

##### Pricing plans from one page (the prefill)

```json
{
  "urls": ["https://apify.com/pricing"],
  "fields": [
    { "key": "plan_name", "value": "Name of the pricing plan" },
    { "key": "monthly_price", "value": "Monthly price as shown on the page, with currency" }
  ],
  "mode": "list",
  "provider": "gemini",
  "apiKey": "YOUR_GEMINI_KEY"
}
```

Expected behavior: one page is read and sent once to `gemini-flash-lite-latest`.
Expected output: one `complete` row with `data.items` (plan name and monthly price for each plan).
Cost note: $0.008 on Apify at the Free tier, plus about 5,000 input tokens on your key.

##### Typed fields from product pages

```json
{
  "urls": [
    "https://books.toscrape.com/catalogue/a-light-in-the-attic_1000/index.html",
    "https://books.toscrape.com/catalogue/tipping-the-velvet_999/index.html"
  ],
  "fields": [
    { "key": "title", "value": "Book title" },
    { "key": "price:number", "value": "Price as a number" },
    { "key": "in_stock:boolean", "value": "Is the book in stock" }
  ],
  "provider": "openai",
  "apiKey": "YOUR_OPENAI_KEY"
}
```

Expected output: two rows, each with `data.title`, `data.price` (a number) and `data.in_stock` (true or false).

### Output

#### Output fields

| Field | Meaning | Type | Can be empty? | Example / enum |
| --- | --- | --- | --- | --- |
| `url` | The URL you gave | string | no | `https://apify.com/pricing` |
| `finalUrl` | URL after redirects | string | yes, if the page was not reached | `https://apify.com/pricing` |
| `status` | Row result | enum | no | `complete`, `not_found`, `error`, `skipped`, `api_key_required`, `api_key_invalid` |
| `data` | Your fields, or `items` in list mode | object | yes, when no model answer | `{ "items": [ ... ] }` |
| `provider` | Provider used | string | no | `gemini` |
| `model` | Model used | string | no | `gemini-flash-lite-latest` |
| `inputTokens` | Input tokens billed to your key | integer | yes, when no model call | `4906` |
| `outputTokens` | Output tokens billed to your key | integer | yes, when no model call | `121` |
| `reasoningTokens` | Reasoning tokens, if the model reports them | integer | yes | `0` |
| `pageTitle` | HTML title of the page | string | yes | `Apify pricing - flexible plan + pay as you go · Apify` |
| `pageChars` | Characters of page text (Markdown) | integer | yes | `28144` |
| `truncated` | The page text was cut at `maxPageChars` | boolean | yes | `false` |
| `fetchedAt` | When the page was read (UTC) | string | no | `2026-10-22T05:50:56.165Z` |
| `error` | Why the row is not complete | object | yes | `{ "code": "NO_DATA", "message": "..." }` |

#### Output entities and surfaces

| Situation | Where | Result shape | What to do |
| --- | --- | --- | --- |
| Normal page | Dataset (Output tab) | `status: complete`, `data` filled | Export or use `data` |
| Page without your data | Dataset | `not_found` / `NO_DATA`, tokens shown, $0.001 page read only | Check field names or `maxPageChars` |
| Page gone | Dataset | `not_found` / `NOT_FOUND` (HTTP 404/410), no model call | Fix the URL |
| Page can't be read | Dataset | `error` with `error.code` (`JS_REQUIRED`, `HTTP_ERROR`, `INVALID_URL`, `LLM_TRUNCATED`, ...) | See Troubleshooting |
| Run stopped early | Dataset + `RUN_SUMMARY` | rest of the rows `skipped`, summary `PARTIAL` with `stopReason` | Rerun the skipped URLs |
| Whole run | Key-value store `RUN_SUMMARY` | counts, total tokens, `status`, `stopReason` | Check after each run |

#### Output example

From a real prefill run (full row):

```json
{
  "url": "https://apify.com/pricing",
  "finalUrl": "https://apify.com/pricing",
  "status": "complete",
  "data": { "items": [
    { "plan_name": "Free", "monthly_price": "$0" },
    { "plan_name": "Starter", "monthly_price": "$19" },
    { "plan_name": "Scale", "monthly_price": "$199" },
    { "plan_name": "Business", "monthly_price": "$999" }
  ] },
  "provider": "gemini",
  "model": "gemini-flash-lite-latest",
  "inputTokens": 4906,
  "outputTokens": 121,
  "reasoningTokens": 0,
  "pageTitle": "Apify pricing - flexible plan + pay as you go · Apify",
  "pageChars": 28144,
  "truncated": false,
  "fetchedAt": "2026-10-22T05:50:56.165Z",
  "error": null
}
```

`null` in `data` means the model did not find that value on the page. It is not a zero and not an error.

#### Use case → fields

| Buyer job | Input path | Output entity | Key fields | Next integration |
| --- | --- | --- | --- | --- |
| Pricing comparison | `urls`, `fields`, `mode: list` | pricing page | `data.items`, `fetchedAt` | Google Sheets |
| Product catalog | `urls`, `jsonSchema` | product page | `data`, `status` | Dataset API |
| Token cost report | any | page | `inputTokens`, `outputTokens`, `model` | CSV export |

### Pricing and limits

#### Pricing unit

Pay per event:

| Event | Price | When |
| --- | --- | --- |
| Run start (`apify-actor-start`) | $0.005 per GB of run memory (default 1 GB = one event) | Every run, added by the Apify platform |
| `page-read` | $0.001 | Your model answered for a page: status `complete`, or `not_found` / `NO_DATA` |
| `page-extracted` | Free $0.002, Bronze $0.0018, Silver $0.0016, Gold $0.0014 | The answer had data: status `complete` |

A page with data costs both events: $0.003 at the Free tier, $0.0024 at Gold. A page where the model found none of your fields (`NO_DATA`) costs $0.001.

Not charged: 404 pages, errors (timeouts, blocked or JavaScript-only pages, model errors), skipped pages, runs without a key or with a wrong key (only the run start applies). Your LLM tokens are billed separately by your provider to your key; they are not part of the Apify price.

Stops that protect you:

- **Max total charge** (Apify run option): when the next page would go over it, the run stops, marks the rest `skipped` / `CHARGE_LIMIT` and ends `PARTIAL`. The model is not called for a page that cannot be charged.
- **No data at the start:** if the model finds none of your fields on 10 pages before any page had data, the run stops with `PARTIAL` / `NO_DATA_STREAK` to save your tokens.
- **Dead sites or provider:** after 10 timeouts or connection/model errors in a row, or when no page finishes for 120 s, the run stops with `PARTIAL` / `SOURCE_FAILING` and marks the rest `skipped`.

#### Cost examples

Measured Apify charges at the Free tier (tokens on your key are extra):

| Scenario | Input scope | Charged events | Apify charge | Stop/cap behavior |
| --- | --- | ---: | ---: | --- |
| Prefill | 1 pricing page, list mode | 1 start + 1 page | $0.008 | — |
| Medium | 20 Wikipedia pages | 1 start + 20 pages | $0.065 | — |
| Large | 100 product pages | 1 start + 100 pages | $0.305 | ~5 min on a free Gemini key; raise the timeout |
| Maximum | 300 product pages | 1 start + 300 pages | $0.905 | ~18 min on a free Gemini key; raise the timeout |
| Few matches | 100 book pages, 2 with data | 1 start + 100 reads + 2 pages | $0.109 | ~6 min on a free Gemini key; raise the timeout |
| No key | any | 1 start | $0.005 | stops at once |
| All pages 404 | 300 URLs | 1 start | $0.005 | ~10 s, no model calls |

#### Limits

- Up to 300 URLs per run. Default timeout 300 s, memory 1 GB.
- Server HTML only, no JavaScript rendering, no login, no paywall or bot-protection bypass. Private and internal addresses are blocked.
- Pages up to 5 MB of HTML; text sent to the model up to `maxPageChars`.
- Each request to a site identifies itself as `llm-web-extractor-apify-actor`.

### API, export and integrations

- **API:** start the run with `POST https://api.apify.com/v2/acts/cliqtomedia~llm-web-extractor/runs` and the same JSON as the Input tab; read rows from the run's default Dataset.
- **Export:** JSON, CSV, Excel, XML or RSS from the Output tab or the Dataset API.
- **Scheduling and webhooks:** Apify schedules and webhooks work as for any Actor; pass the key in the saved input.
- **No-code:** Make, Zapier, n8n and Google Sheets integrations read the Dataset.

#### Use with AI agents (MCP)

- MCP server URL with only this Actor: `https://mcp.apify.com?tools=cliqtomedia/llm-web-extractor`.
- Smallest useful input: `{"urls": ["https://apify.com/pricing"], "fields": [{"key": "plan_name", "value": "Name of the pricing plan"}, {"key": "monthly_price", "value": "Monthly price"}], "mode": "list", "provider": "gemini", "apiKey": "YOUR_GEMINI_KEY"}`.
- Key output fields: `status` (`complete` means data), `data` (your fields or `data.items`), `error.code` (why not complete), `inputTokens` and `outputTokens` (tokens on your key).
- Typical run: one page in 3–6 seconds for $0.008 at the Free tier. Limits: 300 URLs per run, an API key is required, pages must be public server HTML.

### Troubleshooting

#### Rows are `not_found` with `NO_DATA`

Symptom: tokens are shown, but `data` is empty or all `null`.
Likely reason: the fields are not on the page, or they are below the `maxPageChars` cut (`truncated: true`). On long Wikipedia pages the population was after character 40,000.
Action: check the field names and descriptions; raise `maxPageChars` for long pages; use `mode: list` for tables.

#### Row error `JS_REQUIRED`

Symptom: no data and no tokens.
Likely reason: the page builds its content with JavaScript; the server HTML is empty.
Action: use a page that shows the data in its HTML, or a browser-based scraper for this site.

#### Run ends `PARTIAL` with `QUOTA_LIMIT` or `RATE_LIMIT`

Symptom: some rows are `skipped`.
Likely reason: your key ran out of quota or kept hitting the provider's rate limit.
Action: top up or wait for the reset, lower `maxConcurrency`, then rerun the skipped URLs.

#### Run ends `PARTIAL` with `TIMEOUT`

Likely reason: many pages and a slow (free-tier) key.
Action: raise the run timeout in the run options, or split the URL list.

#### Run ends `PARTIAL` with `SOURCE_FAILING`

Symptom: many `error` rows with `TIMEOUT`, `CONNECTION_FAILED`, `LLM_TIMEOUT` or `LLM_ERROR`, then `skipped` rows.
Likely reason: the sites or your provider stopped answering.
Action: open one failed URL in a browser, check your provider's status page, then rerun the skipped URLs.

#### Row `api_key_invalid` or run fails with `MODEL_UNAVAILABLE`

Action: check that the key belongs to the selected provider; leave **Model** empty for the default, or pick a model your key can use.

### FAQ

#### Do I need my own API key?

Yes. Without a key the run stops at once with one `api_key_required` row and only the run start is charged.

#### Is Anthropic supported?

The Anthropic option follows the public API docs, but **Anthropic: not tested** with a live key yet. Gemini and OpenAI are tested.

#### Why did a page cost tokens but only $0.001 on Apify?

The model read the page and found none of your fields (`NO_DATA`). Your provider bills those tokens; this Actor charges only the $0.001 page read, not the extraction.

#### Are the values always correct?

No guarantee: LLMs can make mistakes. The model sees only the page text, is told to use `null` instead of guessing, and treats the page as untrusted data. Check important values.

#### How fresh is the data?

Each page is downloaded during the run; `fetchedAt` shows when. Nothing is cached.

### Support

For a bug, a question or a site that does not work, use the Actor's Issues tab on Apify or write to hello@cliqtomedia.com. Include the run ID, the provider and the error code. Never send your API key.

# Changelog

This Actor's version history is a separate document: https://apify.com/cliqtomedia/llm-web-extractor/changelog.md

# Actor input Schema

## `urls` (type: `array`):

Public pages to read (up to 300 per run; 300 pages take about 18 minutes on a free Gemini key, so raise the run timeout). One model call per page. Pages behind a login or paywall, private and internal addresses are not read. Pages that render only with JavaScript are reported as JS_REQUIRED without a model call.

## `fields` (type: `array`):

Field name on the left, a short description for the model on the right. Add a type after a colon: price:number, count:integer, in_stock:boolean, tags:array (text by default). Missing values come back as null. Ignored when a JSON Schema is given.

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

One record: the fields describe the page itself (an article, a product). List: the page holds many records (plans, products, people) and you get them all in data.items.

## `provider` (type: `string`):

Whose API your key belongs to. Gemini has a free tier in Google AI Studio. Anthropic support is built to the public API docs but not yet tested with a live key.

## `apiKey` (type: `string`):

Your own key for the provider above. Required: without it the run stops at once with a hint and nothing is charged for extraction. The provider bills the tokens to this key. The key is stored encrypted, used for this run only and never written to logs or results. Gemini: aistudio.google.com/apikey · OpenAI: platform.openai.com/api-keys · Anthropic: console.anthropic.com/settings/keys

## `model` (type: `string`):

Model id from your provider. Empty = a fast, low-cost default: gemini-flash-lite-latest, gpt-5.4-mini or claude-haiku-5-5. Reasoning models are slower and use more tokens.

## `jsonSchema` (type: `object`):

Instead of fields, paste a JSON Schema whose root is an object with properties. It replaces the fields above. OpenAI uses strict mode only when every object lists all its properties as required and sets additionalProperties to false.

## `instructions` (type: `string`):

Optional hints for the model, up to 4000 characters. Example: give prices as numbers in USD; skip enterprise plans.

## `maxPageChars` (type: `integer`):

Page text longer than this is cut before it is sent, to cap the tokens your key pays for (about 4 characters per token). The row says when a page was cut.

## `maxConcurrency` (type: `integer`):

Parallel pages. Lower it if your key has a small rate limit (for example a free tier).

## `keepBoilerplate` (type: `boolean`):

Send the whole page, including menus, headers and footers. Off by default to save tokens.

## Actor input object example

```json
{
  "urls": [
    "https://apify.com/pricing"
  ],
  "fields": [
    {
      "key": "plan_name",
      "value": "Name of the pricing plan"
    },
    {
      "key": "monthly_price",
      "value": "Monthly price as shown on the page, with currency"
    }
  ],
  "mode": "list",
  "provider": "gemini",
  "maxPageChars": 40000,
  "maxConcurrency": 3,
  "keepBoilerplate": false
}
```

# Actor output Schema

## `results` (type: `string`):

One row per page: status, extracted data, tokens used and errors.

## `data` (type: `string`):

Page URL and the extracted JSON only.

## `runSummary` (type: `string`):

Status, stop reason, counts, tokens billed to your key and error codes.

# 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 = {
    "urls": [
        "https://apify.com/pricing"
    ],
    "fields": [
        {
            "key": "plan_name",
            "value": "Name of the pricing plan"
        },
        {
            "key": "monthly_price",
            "value": "Monthly price as shown on the page, with currency"
        }
    ],
    "mode": "list"
};

// Run the Actor and wait for it to finish
const run = await client.actor("cliqtomedia/llm-web-extractor").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 = {
    "urls": ["https://apify.com/pricing"],
    "fields": [
        {
            "key": "plan_name",
            "value": "Name of the pricing plan",
        },
        {
            "key": "monthly_price",
            "value": "Monthly price as shown on the page, with currency",
        },
    ],
    "mode": "list",
}

# Run the Actor and wait for it to finish
run = client.actor("cliqtomedia/llm-web-extractor").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "urls": [
    "https://apify.com/pricing"
  ],
  "fields": [
    {
      "key": "plan_name",
      "value": "Name of the pricing plan"
    },
    {
      "key": "monthly_price",
      "value": "Monthly price as shown on the page, with currency"
    }
  ],
  "mode": "list"
}' |
apify call cliqtomedia/llm-web-extractor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,cliqtomedia/llm-web-extractor"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/L9djcR83UT6McQ166/builds/IUtoUOux3yGdPy6r4/openapi.json