PDF workflows for humans, apps, and AI agents
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.
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' }}
/>
);
}// <div id="editor" style="height: 100vh"></div>
import { createEmbed } from '@simplepdf/embed';
const embed = createEmbed({
// a CSS selector, or the HTMLElement itself
target: '#editor',
companyIdentifier: 'yourcompany',
document: { url: 'https://cdn.simplepdf.com/simple-pdf/assets/forms/fw9.pdf' },
});// expose the live editor as client-side tools
import { useEmbedTools } from '@simplepdf/react-embed-pdf/ai-sdk';
const tools = useEmbedTools(embedRef);
// the model's tool calls execute against the open documentThe 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.
Renders, zooms, fills, annotates, signs. Runs in an iframe in your app.
AcroForm fields read out with stable IDs. Comb fields, checkboxes, signatures.
Parse document content as structured Markdown in the browser for search, extraction, automation, or AI workflows.
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.
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.
Stage known field values from your backend, workflow, or agent, then hand the person a link to a prefilled draft.
submission.created with short-lived URLs for the completed PDF and structured field data, keyed by stable field ID.
S3, Azure Blob Storage or SharePoint. Bytes go browser to bucket over signed URLs.
Shareable links, submission dashboard, members and roles, audit log.
You build your product. We make the PDFs work.
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.
Your components, your routes, your auth.
Typed actions, events, tool registry. Zero runtime dependencies at the root.
The PDF is rendered, filled and edited here. With bring your own storage, saved bytes go directly to storage you control.
Your storage
S3, Azure Blob Storage or SharePoint. Browser to bucket, no proxy.
Your backend
Webhook with metadata, your correlation context, and short-lived URLs for the completed PDF and the answers as JSON.
Your AI provider
Optional. Provider-agnostic: the model your AI stack supports. Tool calls come back and execute in 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.
Any bucket that speaks the S3 API, in your own account and region.
Container-scoped SAS, no standing credentials in the browser.
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.
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.
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' }}
/>// React: typed actions on the live editor
const { embedRef, actions } = useEmbed();
await actions.goTo({ page: 2 });
await actions.selectTool({ tool: 'SIGNATURE' });
await actions.setFieldValue({ fieldId: 'f_last_name', value: 'Doe' });
const fieldsResult = await actions.getFields(); // BridgeResult: { success, data | error }
<EmbedPDF ref={embedRef} onEmbedEvent={(event) => { ... }} /> // e.g. SUBMISSION_SENT
// framework-free: createEmbed({ target, companyIdentifier, document })
// grouped handle: embed.actions / embed.events / embed.lifecycle
// 15 actions, closed error codes: /embed/json// server: the model learns the tools (execute-less definitions)
import { simplePDFToolDefinitions } from '@simplepdf/embed/ai-sdk';
streamText({ model, tools: simplePDFToolDefinitions() });
// browser, Vercel AI SDK: dispatch tool calls against the live editor
import { useEmbedTools } from '@simplepdf/react-embed-pdf/ai-sdk';
const tools = useEmbedTools(embedRef);
const { addToolOutput } = useChat({
onToolCall: async ({ toolCall }) => {
const output = await tools[toolCall.toolName]?.execute(toolCall.input);
addToolOutput({ tool: toolCall.toolName, toolCallId: toolCall.toolCallId, output });
},
});
// TanStack AI: the same tools, passed straight to useChat
import { useEmbedTools } from '@simplepdf/react-embed-pdf/tanstack-ai';
useChat({ connection, tools: useEmbedTools(embedRef) });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.
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_urlStart 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.
{ "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" }{
"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" }
}
}{ "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.
https://{companyIdentifier}.simplepdf.com/api/v1
curl https://acme.simplepdf.com/api/v1/documents \
-H "Authorization: Bearer $SIMPLEPDF_API_KEY"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?
Customize the editor
Can I get submitted form values as structured data?
Set up webhooks
Can I keep the PDFs in my own storage?
Configure your own storage
Can I use SimplePDF without AI?
Can an AI agent fill a PDF?
Try the demo: ask the agent to fill the form
Does the PDF go to an LLM?
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
$ 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$ mkdir -p .agents/skills/build-with-simplepdf && curl -fsSL https://raw.githubusercontent.com/SimplePDF/simplepdf-embed/main/skills/build-with-simplepdf/SKILL.md -o .agents/skills/build-with-simplepdf/SKILL.md$ mkdir -p .cursor/rules && curl -fsSL https://raw.githubusercontent.com/SimplePDF/simplepdf-embed/main/skills/build-with-simplepdf/SKILL.md -o .cursor/rules/build-with-simplepdf.mdc$ mkdir -p .opencode/skills/build-with-simplepdf && curl -fsSL https://raw.githubusercontent.com/SimplePDF/simplepdf-embed/main/skills/build-with-simplepdf/SKILL.md -o .opencode/skills/build-with-simplepdf/SKILL.md> Fetch https://raw.githubusercontent.com/SimplePDF/simplepdf-embed/main/skills/build-with-simplepdf/SKILL.md verbatim with curl -fsSL (not a summarizing fetch), then follow it to add SimplePDF to this app.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