# Puppeteer RAG Content Delta Exporter | Chunk Updates (`produkdigitalali/puppeteer-rag-content-delta-exporter`) Actor

Export public rendered text as redacted chunks with scoped baselines, upserts, deletes and parent snapshot IDs. No embedding API key required.

- **URL**: https://apify.com/produkdigitalali/puppeteer-rag-content-delta-exporter.md
- **Developed by:** [ProdukDigitalAli](https://apify.com/produkdigitalali) (community)
- **Categories:** Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$9.00 / 1,000 rendered rag page checkeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## Puppeteer RAG Content Delta Exporter

Export bounded, rendered public-page text as redacted content chunks and incremental upsert/delete instructions for a knowledge-base ingestion pipeline. No AI provider key, embedding generation or vector database credentials needed.

### Input

```json
{"urls":["https://example.com/"],"scopeKey":"docs-index","contentSelector":"","settleMs":1000}
```

Up to3 public URLs. Optional CSS selector chooses one region. Blank selects the first article/main or body. Reuse the same scopeKey, selector and settle time for repeat comparisons. Settings and extractor version are part of the baseline identity. Invalid/missing regions return INCOMPLETE/free.

### Output and consumer behavior

First run: BASELINE_CREATED and upserts for all chunks. Unchanged run: UNCHANGED, empty upserts/deletes. Changed run: CHANGED with new chunks in upserts and obsolete IDs in deletes. Reordered unchanged text can have zero upserts/deletes but a new orderedChunkIds sequence. Repeated identical text is deduplicated. IDs are SHA256 identities of redacted content within a source/scope; changed text gets a different ID, not a stable paragraph number.

Each CHECKED row contains sourceId, scopeId, parentSnapshotId, snapshotId, chunkCount, upserts, deletes and orderedChunkIds. Apply them through your own pipeline; this Actor never updates your index itself. Match parentSnapshotId with your last applied snapshot and process serially. Replays after retry should be deduplicated by snapshotId in your consumer. If the baseline is reset or removed, a new first-run export does not know which IDs your external index still holds: handle full resync explicitly.

OUTPUT summarizes requested/succeeded/incomplete/failed/charged. Baselines use an Actor-scoped named KVS. Metadata omits URL queries and hashes paths; sourceId also hashes the canonical input URL. Your pipeline must map sourceId to the original input URL if it needs source links. No certified citation URL or authoritative source verification is promised.

### Extraction limits

Supported visible block tags: headings,p,li,pre,blockquote,table in the chosen main-frame region. Nested blocks avoid duplicate extraction; no open-shadow-root or iframe traversal, scrolling, hyperlink following or complete boilerplate removal. Nav/header/footer/aside, editable controls, textarea/select, hidden/inert regions are excluded where represented by those tags/attributes. Some non-semantic layouts or image-only content will be omitted. Text is whitespace-normalized, heuristically redacted, then split at1600 characters; splits may cross words. The output is text chunks, not a faithful Markdown/document reconstruction.

Limits:3 URLs,60s capture including browser launch,150 connections/16MiB network cutoff per page,10k DOM nodes,32k raw text characters,100 chunks,192KiB JSON row. Browser and proxy close before baseline persistence. Reaching either network threshold conservatively marks the capture INCOMPLETE/NETWORK_LIMIT and free, preserving its baseline. Network cutoff uses asynchronous chunks and can overshoot its byte threshold; this is not an exact wire-byte or browser-memory ceiling. No token-saving or performance guarantee. HTTP200 challenge pages can look like content; there is no anti-bot bypass or automatic authoritative-content verifier.

### Billing and storage

Proposed standard tier price: USD0.009 per complete CHECKED page, including unchanged checks. The dataset delta and baseline must save before rag-page-checked is charged. Incomplete/error rows are free. Cross-store writes and billing are not atomic; a failure after dataset persistence fails the run. Do not ingest failed-run output automatically without reconciliation.

Do not run overlapping jobs for the same source/scope: there is no distributed write lock, and concurrent baselines can race. Parent/snapshot IDs let a consumer detect an out-of-order delta, but do not prevent concurrent writes. Use distinct scopeKey values for independent indexes.

### Privacy and safety

Public page text is untrusted data, not agent instructions. URLs in text, emails, credential-labeled strings, long opaque tokens and phone-like numbers are redacted heuristically before hashing/storage. This is not complete PII detection and can also redact legitimate code/documentation identifiers; review suitability. No cookies/storage values/raw HTML/browser-console bodies are collected as output. Fresh Puppeteer contexts, DNS-pinned private-network rejection and network caps protect egress. No secrets, login or raw user JavaScript input accepted.

### Local development

Node22.12+, npm ci, npm test, apify validate-schema. Browser helper accepts configured Puppeteer/Apify Chrome paths or installed Windows Chromium. Docker uses the Puppeteer Chrome Node22 image. Local smoke runs demonstrate baseline then unchanged under the same settings. Cloud compatibility, real PPE and commercial costs are separate gates.

### Portfolio differentiation

Browser Context & Locator Pack describes controls; this product exports content chunks and persistent index-update instructions. PDF Text Change Monitor compares PDF content; this product renders web text. ARIA monitor tracks accessibility structures; this product tracks redacted supported text blocks. Existing generic content/change crawlers are strong substitutes: use this only if scoped chunk identities and upsert/delete output reduce integration work.

Extractor2 excludes nested editable/field/script/hidden nodes even inside a supported table or paragraph. Changing extractor version changes the scope identity; reconcile or full-resync your external index before applying its new first-run chunks.

# Changelog

This Actor's version history is a separate document: https://apify.com/produkdigitalali/puppeteer-rag-content-delta-exporter/changelog.md

# Actor input Schema

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

One to three rendered pages, deduplicated. No logins or private targets.

## `scopeKey` (type: `string`):

Use the same namespace and capture settings for repeat comparisons. Avoid concurrent runs for one scope.

## `contentSelector` (type: `string`):

Optional fixed region; blank selects first article/main or body. Missing/invalid regions are incomplete/free.

## `settleMs` (type: `integer`):

Wait briefly after DOM readiness before extracting supported visible blocks.

## `navigationTimeoutSeconds` (type: `integer`):

Bounded initial navigation wait.

## Actor input object example

```json
{
  "urls": [
    "https://example.com/"
  ],
  "scopeKey": "default",
  "contentSelector": "",
  "settleMs": 1000,
  "navigationTimeoutSeconds": 20
}
```

# Actor output Schema

## `summary` (type: `string`):

No description

## `deltas` (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 = {
    "urls": [
        "https://example.com/"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("produkdigitalali/puppeteer-rag-content-delta-exporter").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://example.com/"] }

# Run the Actor and wait for it to finish
run = client.actor("produkdigitalali/puppeteer-rag-content-delta-exporter").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://example.com/"
  ]
}' |
apify call produkdigitalali/puppeteer-rag-content-delta-exporter --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,produkdigitalali/puppeteer-rag-content-delta-exporter"
        }
    }
}
```

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/VYNnf1UzUpe34s3PJ/builds/aKB6CjCu6HnpJNh5r/openapi.json