canonical: https://jentic.com/apis/filedroppr.com/filedroppr

# Filedroppr EveryPage API

The EveryPage API uploads documents and returns trackable share links, then reports how each link is read. A single file can carry several link variants, each tracked on its own, and readership reports break viewing down to the page on paid plans, alongside reader annotations and page marks. Recent events and completed viewing-gate responses are listable, and webhooks push document events as they happen. Every error under the versioned path is an RFC 9457 problem document, so a client can branch on its code.

## For AI agents

Upload documents, mint trackable share links and link variants, and read readership reports down to the page. List events and gate responses, and register webhooks for document activity.

## Scope

Does not handle e-signatures, document generation, or long-term file storage tiers. Use for sharing documents through trackable links and reading their readership only.

## Capabilities

- Upload a PDF and get a trackable share link, or import one from an export URL
- Create and manage link variants so one document can have several tracked links
- Read a document's readership report, including per-page viewing time on paid plans
- Pull reader annotations and page marks left on a document
- List recent events and completed viewing-gate responses from readers
- Register webhooks to receive document events as they happen

## Use cases

### Agent-driven document sharing through Jentic

An AI agent uploads a proposal, mints a tracked share link, and later reads the readership report to see whether the recipient opened it and which pages held their attention. With link variants the agent can give each recipient their own link, so the report attributes views to the right person without a person opening the dashboard.

Example prompt: Upload a PDF, create a link variant for one recipient, then read that document's readership report

### Per-recipient link variants

Sales and partnerships send the same document to many people but want to know who engaged. EveryPage lets a file carry multiple link variants, each tracked separately, so an integration can generate a distinct link per recipient and later compare their readership side by side.

Example prompt: Create three link variants on one file and list the variants to confirm each has its own tracked link

### Readership-driven follow-up

Knowing a prospect read pages three through five changes the follow-up. EveryPage reports readership down to the page and surfaces reader annotations, and webhooks deliver viewing events as they happen, so an assistant can trigger a timely nudge the moment a key page is reached.

Example prompt: Register a webhook for viewing events, then read the per-page readership for a document to find its most-read pages

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| POST | `/api/v1/files` | Upload a document |
| GET | `/api/v1/files` | List your files |
| GET | `/api/v1/files/{uuid}` | Get a file's details |
| POST | `/api/v1/files/{uuid}/variants` | Create a link variant |
| GET | `/api/v1/files/{uuid}/readership` | A file's readership report |
| GET | `/api/v1/files/{uuid}/readership/pages` | A file's per-page readership |
| POST | `/api/v1/webhooks` | Create a webhook |
| GET | `/api/v1/events` | List recent events |

## Key resources

- **Files** — Upload, import, list, read, and delete documents behind trackable links
- **Variants** — Create, update, and delete per-link variants of a file
- **Events** — Readership reports, page marks, annotations, events, and gate responses
- **Webhooks** — Register, list, test, and delete webhooks for document activity

## AI readiness

This API is usable in Jentic One now. Its AI-readiness score against Jentic's framework shows where it stands today and where improvements would make it even easier for agents to use.

- **Score:** 78 / 100
- **Maturity:** AI-Ready
- **Dimensions:**
  - Foundational Compliance: 89 / 100
  - Developer Experience & Jentic Compatibility: 66 / 100
  - AI-Readiness & Agent Experience: 75 / 100
  - Agent Usability: 94 / 100
  - Security: 71 / 100
  - AI Discoverability: 76 / 100
- **View full report:** https://jentic.com/apis/filedroppr.com/filedroppr/scorecard
- **How the score is calculated:** https://docs.jentic.com/reference/api-readiness-framework/overview/
- **More about the dimensions:** https://docs.jentic.com/reference/api-readiness-framework/specification/#dimensional-model-overview

### Score it yourself

Every API in the directory is allowlisted, so you can re-score it with no key required.

- **Score your own API:** https://jentic.com/scorecard.md
- **Scoring CLI agent skill:** https://github.com/jentic/jentic-api-scorecard/blob/main/skills/jentic-api-scorecard/SKILL.md

```sh
npx @jentic/api-scorecard-cli score <openapi-url>
```

## Why Jentic

- **Setup:** Wiring the EveryPage API by hand means choosing between a personal API key and an OAuth 2.0 token, branching on its RFC 9457 error bodies, and managing link variants and webhooks yourself. Through Jentic you install once, import it from the API Directory, store the credential once, and your agent calls it.
- **Permission scoping:** You choose which operations your agent may call, so it can upload documents and read readership while the delete and webhook-management operations stay out unless you add them. The OAuth token exchange, oEmbed, and public QR-code links are open operations that need no credential at all.
- **Credential handling:** Your EveryPage API key is stored once, encrypted, by your own Jentic One instance and injected at execution time. It never enters the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'upload a document and get a share link' or 'read a document's readership', and Jentic returns the matching EveryPage operation with its input schema so the agent calls the right endpoint without browsing the reference docs.

## Related APIs

- **Filestack** — Filestack uploads, transforms, and delivers files, an alternative when tracking readership is not the point.
- **PDFMonkey** — PDFMonkey generates PDFs from templates that EveryPage can then share and track.
- **PDFEndpoint** — PDFEndpoint renders HTML to PDF, producing documents EveryPage can host and track.

## FAQ

### What authentication does the EveryPage API use?

It accepts a personal API key or an OAuth 2.0 access token, both sent as a Bearer token in the Authorization header, per its OpenAPI spec. Some endpoints, such as the OAuth token exchange, the oEmbed provider, and the public QR-code links, need no credential.

### Can I track readership per page with the EveryPage API?

Yes. The readership report covers a document's overall engagement, and on paid plans a per-page endpoint breaks viewing time down page by page. You can also pull reader annotations and page marks left on the document, and list the raw viewing events behind them.

### What are the rate limits for the EveryPage API?

The OpenAPI spec does not state a numeric rate limit, though it notes that every error under the versioned path is an RFC 9457 problem document you can branch on. Check the EveryPage documentation for current rate limits before syncing many files.

### Is there an EveryPage MCP server?

You don't need an MCP server to give your agent the EveryPage API. Jentic connects it directly from the API Directory: import it, store your credential once, and your agent calls the upload, variant, readership, and webhook operations on demand.

### Can I limit what my agent is allowed to do with the EveryPage API?

Yes. Write a rule that allows the upload, file-read, and readership operations and leaves the delete and webhook-management operations off the list, so an agent can share documents and report on them without removing files or changing your webhooks. Every call it makes is recorded in your Jentic One audit log.

### How do I share a tracked document with the EveryPage API through Jentic?

Search Jentic for 'upload a document and get a share link', add the EveryPage API from the directory, and store your API key once; your agent then uploads the file, creates a link variant, and reads its readership. To run it on your own infrastructure, install Jentic One from its GitHub repo.