PDF workflows for humans, apps, and AI agents

Your UI. Your workflow. Your storage.

Embed and control PDFs in React or JavaScript, prefill forms from your systems, and extend the same workflow to AI agents. People review, correct, sign, and submit.

Install the agent skill
import { EmbedPDF } from '@simplepdf/react-embed-pdf';

export function Document() {
  return (
    <EmbedPDF
      mode="inline"
      style={{ width: 900, height: 800 }}
      companyIdentifier="yourcompany"
      document={{ url: 'https://cdn.simplepdf.com/simple-pdf/assets/forms/fw9.pdf' }}
    />
  );
}
@simplepdf/react-embed-pdf400+React docs

The PDF stack you don't have to build

Rendering is the easy part. Production PDF workflows also need field normalization, editing, signing, programmatic control, storage, submissions, and workflow events.

viewer + editor

Renders, zooms, fills, annotates, signs. Runs in an iframe in your app.

field detection

AcroForm fields read out with stable IDs. Comb fields, checkboxes, signatures.

content extraction

Parse document content as structured Markdown in the browser for search, extraction, automation, or AI workflows.

white label

Your logo, your loading screen, no "Powered by SimplePDF". Keep the built-in editor UI or reduce it and drive the document from your own application controls.

programmatic control

Every editor operation is callable from your code through the typed SDK. The same operations can also be exposed as client-side tools for supported AI SDKs.

POST /documents/{document_id}/prefills

Stage known field values from your backend, workflow, or agent, then hand the person a link to a prefilled draft.

webhooks

submission.created with short-lived URLs for the completed PDF and structured field data, keyed by stable field ID.

your storage

S3, Azure Blob Storage or SharePoint. Bytes go browser to bucket over signed URLs.

portal + audit

Shareable links, submission dashboard, members and roles, audit log.

You build your product. We make the PDFs work.

25,000+
PDFs processed by SimplePDF every day.

Malformed forms, weird rendering: at our volume we hit every edge case first and our tooling fixes it once, for everyone.

A broken PDF never becomes your on-call problem. Focus on your product: we'll handle the PDFs.

Keep your PDF data in your infrastructure

PDF editing happens in the browser. With BYOS, document and submission data moves directly between the browser and storage you control, without passing through SimplePDF application servers. The one opt-in exception, off by default: a designated submission-name field, stored on SimplePDF to label the submission in the dashboard.

Your AI provider is separate too: SimplePDF parses the PDF outside the LLM, and your application decides what extracted context gets sent to the model.

Browser
your UI

Your components, your routes, your auth.

@simplepdf/embed + @simplepdf/react-embed-pdf

Typed actions, events, tool registry. Zero runtime dependencies at the root.

editor iframe

The PDF is rendered, filled and edited here. With bring your own storage, saved bytes go directly to storage you control.

document bytes, over signed URLs →

Your storage

S3, Azure Blob Storage or SharePoint. Browser to bucket, no proxy.

submission.created →

Your backend

Webhook with metadata, your correlation context, and short-lived URLs for the completed PDF and the answers as JSON.

if you add AI: only the context you put in the prompt →

Your AI provider

Optional. Provider-agnostic: the model your AI stack supports. Tool calls come back and execute in the browser.

Data
Where it goes
PDF bytes while editing
The browser. With bring your own storage, saved bytes go browser to bucket over signed URLs.
Prefill field values
Your storage: Prefill requires a readable bring-your-own-storage configuration, so the browser can retrieve the staged values.
Submitted field values
Your storage when you bring your own; SimplePDF-managed storage otherwise. The webhook carries a short-lived field_data_url, not the values themselves.
AI context, when used
SimplePDF parses fields and content in the browser. Your application chooses which extracted context to send to its configured AI provider. The PDF itself never goes to the model.
Workflow metadata and submission context
SimplePDF, then your backend via webhook.
API key
Your server only. It never ships to the browser.

Bring your own AI

If you add an AI workflow, your app chooses the provider, route, key, and policy. SimplePDF doesn't require proxying prompts through its infrastructure.

Bring your own storage

S3, Azure Blob Storage or SharePoint over short-lived signed URLs.

Edits stay in the browser

Operations run against the live document, not an uploaded copy.

S3-compatible

Any bucket that speaks the S3 API, in your own account and region.

Azure Blob Storage

Container-scoped SAS, no standing credentials in the browser.

SharePoint

For Microsoft-centric organisations already storing records there.

Is SimplePDF the right tool?

SimplePDF fits when your product needs a live PDF surface that people or application code can read, fill, edit, sign, or submit. The same interaction layer can also be exposed to AI agents. If not, one of these may fit better.

What you are building
Use
Render a public PDF on a page, nothing else
pdf.js, when you want to own the interaction layer yourself
View documents inside a workflow: faxes, scans, records pulled from storage
SimplePDF
Viewer mode, the same embed, read-only. Display your faxes straight in your app when they come from SRFax, Documo, eFax or Phaxio.
Build your own PDF editor from primitives: custom rendering, annotation engine, offline processing
Apryse (PDFTron), Nutrient (PSPDFKit), EmbedPDF, engine-level control; you build and maintain the workflow layer
Load a form, fill it, submit it, with a person accountable for the answers
SimplePDF
Intake, onboarding, claims, immigration, tax, HR, anything signed.
Generate documents from data, no human involved

One PDF. Three operators.

A person, your application, or an AI agent can drive the same live PDF. AI is optional: the human and application SDKs use the same underlying interaction layer.

In agent-assisted workflows, review, signing, and submission stay with the person.

A person

Embed the editor. Fill, sign, submit.

Your app

Your UI, driving the live document through the SDK.

An AI agent

Editor operations as client tools the model can call.

every operation →
import { EmbedPDF } from '@simplepdf/react-embed-pdf';

<EmbedPDF
  mode="inline"
  style={{ width: 900, height: 800 }}
  companyIdentifier="yourcompany"
  document={{ url: 'https://cdn.simplepdf.com/simple-pdf/assets/forms/fw9.pdf' }}
/>

Live demo with Copilot

Copilot is the open reference implementation for agentic HITL form filling, built on TanStack Start and the Vercel AI SDK.

The agent prepares. The person approves.

Known answers come out of your systems. An agent stages them with the Prefill API or works the live document through tools, and the person reviews, corrects, signs and submits. Your backend receives submission metadata plus short-lived URLs for the completed PDF and structured field data.

From your systems to your backend
The agent does the data entry. Review, signature and submission stay with the person.
CRM / EHR / conversation / database
                 |
                 v
         backend or agent
          /             \
         v               v
   Prefill API       live tools
   (stage known      (the model drives
    values first)     the open editor)
          \             /
           v           v
      the PDF, live in the browser
                 |
                 v
    the person reviews and corrects
                 |
                 v
          signs and submits
                 |
                 v
        webhook -> your backend:
   completed PDF URL + field_data_url
Prefill API

Start with a prefilled form

When the answers already exist in a CRM, an EHR like Epic or any FHIR-based system, a prior submission, a database, or a conversation, stage them before the person opens the PDF. They review, correct, sign, and submit.

PrefillReviewSubmit
GET/documents/{document_id}/fields
POST/documents/{document_id}/prefills
PUT → your storage
{ "fields": [
  { "id": "f_first_name", "value": "Jane" }
] }

Submissions your backend can act on

When the person submits, a submission.created webhook carries your correlation context, a short-lived URL for the completed PDF, and a short-lived URL for the answers as JSON keyed by field ID.

Your backend never parses a PDF to find out what someone entered.

Submission context

Attach non-sensitive correlation metadata: a case ID, a tenant, an environment. It comes back with the webhook, so no lookup call. Keep PII, PHI, secrets and form answers out of it.

"context": { "case": "I-130", "tenant": "acme-eu" }
POST your-app.com/webhooks/simplepdf
{
  "type": "submission.created",
  "data": {
    "document": { "id": "47d8c475...", "name": "intake.pdf" },
    "submission": {
      "id": "a91f20c3...",
      "submitted_at": "2026-07-03T09:12:44Z",
      "url": "short-lived-pdf-url",
      "field_data_url": "short-lived-json-url"
    },
    "context": { "case": "I-130", "tenant": "acme-eu" }
  }
}
GET field_data_url
{ "fields": [
  { "id": "first_name__widget_1", "name": "First name", "value": "Jane" },
  { "id": "agreed_to_terms__widget_1", "name": "Agreed to terms", "value": "checked" }
] }

REST API for management

Manage documents, retrieve field schemas, and read submissions: the REST API orchestrates the client-side embed from your server code. Bearer token, server-only: the key never ships to the browser.

API access is plan-dependent; pricing is the canonical source.

base URL
https://{companyIdentifier}.simplepdf.com/api/v1

curl https://acme.simplepdf.com/api/v1/documents \
  -H "Authorization: Bearer $SIMPLEPDF_API_KEY"
resources
GET  /documents
GET  /documents/{document_id}/fields
POST /documents/{document_id}/prefills
GET  /documents/{document_id}/submissions/{submission_id}

Developer FAQ

Can I build my own toolbar?
Yes. Drive the live editor from your own controls through the typed SDK. The editor is iframe-based, so treat customization as configuration plus programmatic control, not CSS injection.

Customize the editor
Can I get submitted form values as structured data?
Yes. submission.created includes a short-lived field_data_url with the submitted field values keyed by stable field ID, so your backend doesn't need to parse the completed PDF.

Set up webhooks
Can I keep the PDFs in my own storage?
Yes. Bring your own S3-compatible storage, Azure Blob Storage, or SharePoint where supported. With BYOS, document bytes move directly between the browser and your storage over short-lived signed URLs.

Configure your own storage
Can I use SimplePDF without AI?
Yes. Embedding, programmatic control, Prefill, submissions, webhooks, storage, and the REST API work without an LLM. AI adapters are an optional extension of the same editor operations.
Can an AI agent fill a PDF?
Yes. An agent can call tools against the live editor, or a backend or agent can stage known values through Prefill. In the recommended human-in-the-loop workflow, the person reviews, corrects, signs, and submits.

Try the demo: ask the agent to fill the form
Does the PDF go to an LLM?
No. SimplePDF parses and extracts the PDF in the browser, outside the LLM. Your app sends the model only the extracted fields or content the task needs, so the PDF itself never goes to the model and you don't spend tokens parsing it.

PDF to Markdown content extraction

Build with your coding agent

Install one SimplePDF skill, then tell your agent what you want to build. It inspects the repository, asks only what it cannot infer, chooses the smallest correct integration, and implements it.

The skill supports ordinary embeds and programmatic PDF workflows too; it only introduces AI components when your application needs them.

1. Install the skill

SKILL.md
$ mkdir -p .claude/skills/build-with-simplepdf && curl -fsSL https://raw.githubusercontent.com/SimplePDF/simplepdf-embed/main/skills/build-with-simplepdf/SKILL.md -o .claude/skills/build-with-simplepdf/SKILL.md

2. Tell your agent what you want to build

> Add SimplePDF to this app. Inspect the codebase first and use the build-with-simplepdf skill to choose and implement the right integration. Ask me only what you cannot infer.

For agents:Developer Markdownllms.txtEditor contractREST OpenAPISKILL.md