# Backup Actor (`navi-ben/backup-actor`) Actor

A bridge between India's e-paper readers and your systems: discovers, extracts, rebuilds and verifies every page, and delivers each edition as one PDF. 138 titles, 12 languages.

- **URL**: https://apify.com/navi-ben/backup-actor.md
- **Developed by:** [ben rodriqz](https://apify.com/navi-ben) (community)
- **Features:** Full permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$180.00 / 1,000 edition downloadeds

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

### What does Backup Actor do?

**Backup Actor is a bridge between India's e-paper readers and your own systems.** Every e-paper site hides its pages behind its own viewer: tiles, fragments, page maps, readers that only ever show a screen at a time. Backup Actor goes through each viewer the way it was built to be read, gathers every page of the edition, rebuilds it, and hands you **one clean PDF per edition**, ready to flow into your archive, your monitoring desk or your pipeline.

**138 titles and editions. 12 languages. One call.**

### The architecture

Moving a newspaper from a publisher's reader into your system is not one download. It is hundreds of requests across an unreliable public internet, any one of which can stall, drop or come back damaged. Backup Actor treats every edition as a transfer that must arrive whole, and runs it through a layered pipeline:

**1. Discovery layer.** Locates the edition for your date inside the publisher's own reader and maps every page, supplement and pull-out in true reading order.

**2. Extraction layer.** Pulls each page at the highest resolution the reader serves, many pages in parallel over one pooled connection.

**3. Resilience layer.** The internet is not reliable, so the pipeline never assumes it is:

- **Network faults** (dropped connections, timeouts, lag spikes, a server that stops answering mid-page) are caught and the request is sent again automatically.
- **Exponential back-off with jitter** spaces the retries out, so a struggling server gets room to recover instead of a flood.
- **Rate-limit awareness**: when a publisher asks for patience (`429`, `Retry-After`), the pipeline waits exactly as asked, then resumes.
- **Fault isolation**: one failing page never stops its edition, and one failing edition never stops the run.

**4. Reconstruction layer.** Rebuilds what readers serve in pieces: tiled pages are stitched back into whole pages, low-resolution pages are rebuilt from their full-resolution article crops, and where the publisher offers its own press PDF, that original is kept with its vector text intact. Images are embedded losslessly, never re-compressed.

**5. Integrity layer.** Before anything is delivered, every page is accounted for: page counts are checked against the publisher's own listing, thumbnail-sized images are caught, and odd formats are normalised. An edition missing even one page is marked `partial`, never passed off as complete. **No broken editions, no silent gaps.**

**6. Delivery layer.** The verified pages are bound into a single PDF and handed to you with a direct link, ready for your archive, your monitoring desk or your pipeline.

### Why teams use it

- **Morning-ready**: schedule it and every edition is waiting before the day starts.
- **Built for scale**: up to 50 editions a run, four at once.
- **Honest output**: every edition says what it is: complete, partial, or not out yet.
- **Plugs in anywhere**: Apify API, webhooks, schedules and integrations.

### How to use it

1. Choose your **titles**.
2. Choose a **date**, or leave it empty for today (India time).
3. Click **Start**, then download your PDFs from the **Output** tab, or fetch them through the API.

```json
{ "papers": ["sakshi", "eenadu"], "date": "2026-11-02" }
```

### Output

One row per edition, with its PDF link. Export as JSON, CSV, Excel or HTML.

```json
{
  "paperName": "Sakshi (Hyderabad Main)",
  "date": "2026-11-02",
  "status": "ok",
  "pages": 22,
  "sizeBytes": 56282776,
  "pdfUrl": "https://api.apify.com/v2/key-value-stores/.../records/sakshi_2026-11-02.pdf"
}
```

`status` is `ok`, `partial`, `not-available` (not out yet, or no edition that day), `failed`, `not-allowed` (titles marked *subscription* or *internal* are reserved), or `limit-reached`.

### Pricing

**$0.105 per edition delivered.** Nothing is charged for an edition that is not available. The run stops at your spending limit.

### FAQ

- **Whose content is it?** The publishers'. Backup Actor retrieves only what they make freely readable on their own sites. Use it for your own reading, research and monitoring.
- **An edition failed?** Publishers' sites go down at times. Run it again later.
- **Need another title, or a custom pipeline?** Open an issue in the **Issues** tab.

# Actor input Schema

## `papers` (type: `array`):

Which e-papers to download. Each becomes its own PDF.

## `date` (type: `string`):

The day's edition to download, as YYYY-MM-DD. Leave empty for today (India time).

## `parallelPapers` (type: `integer`):

How many newspapers are downloaded at the same time. More is faster but uses more memory.

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

How many pages of an edition are downloaded at the same time.

## `accessKey` (type: `string`):

Only if the owner gave you one. Leave empty otherwise.

## Actor input object example

```json
{
  "papers": [
    "sakshi",
    "eenadu"
  ],
  "parallelPapers": 2,
  "maxConcurrency": 8
}
```

# Actor output Schema

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

No description

## `files` (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 = {
    "papers": [
        "sakshi",
        "eenadu"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("navi-ben/backup-actor").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 = { "papers": [
        "sakshi",
        "eenadu",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("navi-ben/backup-actor").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 '{
  "papers": [
    "sakshi",
    "eenadu"
  ]
}' |
apify call navi-ben/backup-actor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,navi-ben/backup-actor"
        }
    }
}
```

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/BGjW8irv9EpCD35WD/builds/ReBbwmYOeDBjolUtt/openapi.json