# Manual Remake: Confusing Manual to Clear Printable PDF (`pandadad0214/manual-remake`) Actor

Upload a confusing manual (PDF or photos) and get a clear English print PDF: plain steps, parts list, warnings, flagged gaps, a checklist, and cleaned pictures numbered to match. Try the free sample with no key and no charge. Your own remake uses your LLM key.

- **URL**: https://apify.com/pandadad0214/manual-remake.md
- **Developed by:** [Panda Federation](https://apify.com/pandadad0214) (community)
- **Categories:** AI, Automation, Other
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

## Manual Remake: rewrite a confusing manual into a clear, printable PDF

**Upload a PDF or photos of an existing instruction manual and get back a clearer English manual you can keep or print.** Manual Remake by Panda Federation rewrites the steps in plain English, cleans up the parts list, pulls every warning into one place, estimates difficulty and time, flags missing or unclear steps instead of guessing, adds a checklist, and (Standard edition) straightens, crops and cleans **your own pictures** and adds red numbered markers that match the rewritten steps.

This is a rewrite of the file you upload. It is not an official or certified replacement for the manufacturer's manual and makes no safety, standards or compliance claim.

### Use it on Apify

Manual Remake runs as an Apify Actor (publishing soon at `apify.com/pandadad0214/manual-remake`). There is nothing to install.

#### Free sample (no upload, no key, no charge)

Click **Start** with no files (or tick **Free sample**) and you get a real remade PDF of a short, fictional demo manual (the "Birchline ST-2 side table") that ships with the Actor. It shows the full layout: at-a-glance box, warnings, parts list, plain-English steps, flagged gaps, cleaned pictures with numbered markers and the checklist. The sample uses a pre-made rewrite, so no AI model is called, no key is needed and nothing is charged. The PDF and the run summary are clearly marked **FREE SAMPLE**: it is never presented as a remake of your file.

#### Remake your own manual (paid)

1. Upload the manual in **Manual files** (PDF or photos of the pages), or paste direct public or share links in **Manual links**.
2. Paste your **LLM API key** (OpenAI, or any OpenAI-compatible provider with an https **LLM base URL**). Your own manual is always rewritten with your own key, so model usage is billed by your provider. The key is stored encrypted and never logged. If you upload files without a key, the run stops and asks for one; it never swaps in the demo.
3. Leave **Reuse and clean pictures** on for the Standard edition, or turn it off for a Text-only edition.
4. Click **Start**, then download **OUTPUT.pdf** from the run's **Output** tab (or **Storage → Key-value store**).

**Supported inputs:** files uploaded in the **Manual files** box, and direct public links (including Google Drive and Dropbox share links). Links to private Apify storage do not work, because the Actor runs with limited permissions and cannot read other stores in your account; upload the file instead.

**Model provider errors:** if your provider says the key is wrong, the model does not exist, or the account has no credit left (`insufficient_quota`), the run stops with that message and nothing is charged. Add credit or fix the key with your provider and run again.

#### Pricing (pay per successful run)

| Edition | What you get | Price |
|---|---|---|
| **Standard** | Text remake + your pictures straightened, cropped, cleaned and numbered to match the steps | **$39 per run** |
| **Text-only** | Text remake: plain-English steps, parts list, warnings, difficulty/time, flagged gaps, checklist | **$9 per run** |

- You are charged once, only when the remade PDF is delivered.
- If your upload has no usable pictures (or you turn pictures off), the run is Text-only and priced as Text-only. The PDF and the run summary say so.
- Up to **15 pages or photos per run** (PDF pages plus extra photos; pictures inside a PDF page are not counted twice). Over 15, the run stops with a clear message and nothing is charged. Split longer manuals into several runs.
- Refused or failed runs cost nothing, and the free sample is always free.
- If your **Maximum cost per run** is below the edition's price, the run stops before calling your model, so you do not spend model credit on a remake that cannot be delivered.

#### Input examples

Free sample: `{}` or `{"sampleMode": true}`

Your own manual:

```json
{
  "fileUrls": ["https://example.com/side-table-manual.pdf"],
  "includeImages": true,
  "checklistMode": true,
  "paperSize": "letter",
  "llmApiKey": "<your key>",
  "llmModel": "gpt-4o-mini"
}
```

#### What is in the PDF

- **At a glance:** difficulty (Easy / Moderate / Hard, with the reason), time estimate, people needed, tools
- **Warnings from the original manual**, kept in plain words and never softened
- **Parts list** with tick boxes; quantities the source does not give are shown as "?"
- **Steps** in plain English, one action per line, with parts and tools per step and the source page
- **Missing or unclear in the source** boxes where a step, value or part use is missing (nothing is invented: no made-up torque values, voltages, sizes or safety steps)
- **Your pictures, cleaned** (Standard): straightened, cropped, paper evened out, with red numbered markers matching the step numbers
- **Checklist page** to tick off as you go
- A footer on every page: *rewrite of your uploaded manual, not a certified replacement*

#### Other outputs

| Key / view | What it is |
|---|---|
| `OUTPUT.pdf` | The print-friendly remade manual |
| `REMAKE.md` | The same content as Markdown |
| `REWRITE.json` | Structured rewrite (steps, parts, warnings, gaps, figures) |
| `fig-N.png` | Each cleaned picture with its numbered markers (Standard) |
| `SUMMARY` | Edition (`sample`, `text` or `standard`), `sample` flag, counts, pictures used or skipped and why, hidden text removed, what was charged, one-line `takeaway` |
| Dataset (overview view) | An overview row, then one row per warning, part, step, gap and picture, each with a one-line `summary` |

#### Hidden text in uploads

Some PDFs carry text people cannot see (white, microscopic, invisible or off-page text) or lines aimed at AI tools ("ignore previous instructions..."). Manual Remake removes that text before the rewrite (white text on a coloured warning banner and the invisible text layer of scanned PDFs are kept, because those are real content), tells the model to ignore any that slips through, never copies it into the output, and reports how many items were removed in `SUMMARY`.

#### Good to know

- **English output only** in this version.
- **No new artwork:** only your own pictures are reused. Phone layout, video scripts and zoomed insets are not in this version.
- **Photos and scans:** pages without a text layer are read from the picture by the model, so use a model that accepts images (gpt-4o-mini does).
- **HEIC photos:** export them as JPEG or PNG first.
- How this differs from step-by-step chat helpers: those walk you through a manual on screen; Manual Remake gives you a finished document to keep, print or share.

### For developers

Python 3.13 Actor (`apify/actor-python`). The pipeline is split so every stage except the model call can be tested offline:

| Module | Job |
|---|---|
| `src/extract.py` | Sniffs PDF vs image, enforces the 15-unit cap, extracts visible text (drops hidden/AI-directed text), pulls embedded pictures and renders scanned pages |
| `src/imaging.py` | Deskew (projection profile), crop to content, clean (paper to white, despeckle, contrast, sharpen), numbered callouts |
| `src/rewrite.py` | Prompt, OpenAI-compatible call on the user's key, and `normalize()` (renumbers steps, re-maps callouts, drops dangling references and AI-directed text) |
| `src/pdfout.py` | reportlab print PDF and Markdown |
| `src/pipeline.py` | Ties it together with an injectable `rewrite_fn` |
| `src/main.py` | Apify input, free sample mode, downloads, max-charge check before the model call, pay-per-event charging (`text-remake` / `standard-remake`, once per successful run, only after `OUTPUT.pdf` is saved), outputs |

```bash
python -m venv .venv && .venv/bin/pip install -r requirements.txt pytest
.venv/bin/python tests/make_fixtures.py      # builds the fictional 3-page sample manual
.venv/bin/python -m pytest -q tests           # no model calls; uses tests/fixtures/rewrite_fixture.json
```

The free sample is bundled in `src/sample/` (the fictional manual and its pre-made rewrite); `tests/fixtures` holds the same manual plus a test-only rewrite. The sample manual is fictional and was written for this repo, including its drawings and a planted hidden line used to test the hidden-text filter.

Issues and ideas: open an issue on this repo.

Made by [Panda Federation](https://github.com/pandadad0214/panda-federation-tools).

# Actor input Schema

## `sampleMode` (type: `boolean`):

Turn on to get a free sample PDF made from a short fictional demo manual that ships with the Actor (no model key needed, nothing charged). Your own files are not processed while this is on. The sample also runs automatically when no files or links are given.

## `files` (type: `array`):

Upload the manual: one PDF, several PDFs, or photos of the pages (JPEG, PNG, WebP). Up to 15 pages or photos per run in total (PDF pages + extra photos). Over 15, the run stops with a message and nothing is charged. Leave empty (and links empty) for the free sample.

## `fileUrls` (type: `array`):

Or paste direct public links (or share links) to the PDF or photos. Google Drive and Dropbox share links are converted to direct downloads. Up to 50 MB per file. Private Apify storage links do not work (the Actor runs with limited permissions): use the upload box instead.

## `includeImages` (type: `boolean`):

On (default): pictures from your upload are straightened, cropped and cleaned, and get red numbered markers that match the rewritten steps (Standard edition). Off: text-only remake (Text-only edition). If no usable pictures are found, the run is automatically Text-only and priced as Text-only.

## `checklistMode` (type: `boolean`):

Adds tick boxes to every step and a one-page checklist at the end. Default: on.

## `title` (type: `string`):

Optional. Title for the remade manual. Leave empty to use the product name found in the source.

## `paperSize` (type: `string`):

Page size of the print PDF.

## `llmApiKey` (type: `string`):

Required to remake your own manual (not needed for the free sample). Your own OpenAI API key, or a key for another OpenAI-compatible provider with the base URL below. The rewrite runs on your key, so model usage is billed by your provider, not by this Actor. The key is stored encrypted by Apify and is never logged or saved in the output.

## `llmModel` (type: `string`):

Model name. Must accept pictures when you upload photos or scans (gpt-4o-mini and gpt-4o do). Default: gpt-4o-mini.

## `llmBaseUrl` (type: `string`):

Optional. Leave empty for OpenAI (https://api.openai.com/v1). For another OpenAI-compatible provider, paste its https base URL ending in /v1.

## `pdfPassword` (type: `string`):

Optional. Only for password-protected PDFs you are allowed to open.

## Actor input object example

```json
{
  "sampleMode": false,
  "includeImages": true,
  "checklistMode": true,
  "paperSize": "letter",
  "llmModel": "gpt-4o-mini"
}
```

# Actor output Schema

## `pdf` (type: `string`):

No description

## `table` (type: `string`):

No description

## `markdown` (type: `string`):

No description

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

Agent-friendly keys: `takeaway`, `edition`, `counts`.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("pandadad0214/manual-remake").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("pandadad0214/manual-remake").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 '{}' |
apify call pandadad0214/manual-remake --silent --output-dataset

```

## MCP server setup

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

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/Ew53hMQWqhthcga69/builds/Gap2fY2N6FOHaZKmB/openapi.json