Free plan

Notion

Embed documents in Notion, or sync reading sessions to a Notion database.

EveryPage integrates with Notion in two independent ways: embed documents directly into Notion pages with no setup required, or sync your document reading analytics to a Notion database.

Embeds

Paste an EveryPage /embed/ link into Notion's Embed block and the document renders inline. No authentication or connection is needed. Views of embedded documents are attributed with source=embed in your readership analytics.

For guidance on creating embed links, see embedding documents.

Database sync

Connect your EveryPage account to Notion via OAuth, and EveryPage creates an "EveryPage Reads" database on a page you choose. Each synced event then writes one row into it.

Setup

  1. Go to Account and find the Notion card.
  2. Click Connect Notion and authorize EveryPage. On Notion's consent screen, share the pages you want EveryPage to be able to use as a parent — only shared pages appear in the picker.
  3. Choose a parent page and click Create database. EveryPage creates "EveryPage Reads" there and starts with a default sync: all three event types, all documents.
  4. Adjust the sync settings that appear below the card, then click Save sync settings:
    • Events: Viewed, Downloaded, Gate completed (any combination; at least one).
    • Scope: all documents, or up to 20 hand-picked documents.
  5. Optionally click Import recent reads to backfill history. See Backfilling history.

Database columns

The "EveryPage Reads" database is created with these columns:

  • Document (title) - The file's name.
  • Reader (text) - The reader's identity, in order of preference: the invite name, the invite email, the email captured by a gate, or Reader #N for a pseudonymous reader.
  • Event (select) - Viewed, Downloaded, or Gate completed.
  • Pages read (number) - Pages viewed in the session.
  • Time spent (number) - Duration in minutes, to one decimal place.
  • Read-through % (percent) - Pages read divided by the document's page count, capped at 100%. Left empty when the page count is unknown.
  • Returning (checkbox) - Whether this reader has read this document before.
  • Source (select) - How the document was reached: link, qr, email, or embed.
  • Country (select) - The reader's country, resolved in flight from their IP address, which is never stored.
  • Session link (URL) - The document's readership page in EveryPage.
  • Share link (URL) - The durable share link to the document: its short ID, or its UUID if no short ID exists.
  • QR code (files) - The document's QR code image, pointing at the public QR endpoint for its durable share link.
  • Date (date) - The event time in UTC. For an imported session, this is when the session started, not when you ran the import.
  • Details (text) - Captured form fields from a gate completion, one field: value per line.

Not every column is filled on every row. Only Viewed rows carry session detail (Reader, Pages read, Time spent, Read-through %, Returning, Source, Country); Downloaded rows carry only the document, event, date and links; Gate completed rows carry the Reader, Source and Details. A Viewed row whose session cannot be found still writes, with the basics only.

Plan support

The Notion integration is available on all plans. One exception: gate.completed events (which carry captured lead data) require a Pro subscription at the time the event occurs. Gate events from free or basic accounts are not synced.

See plans and limits for subscription details.

Sync scope and limits

You can sync all your documents or hand-pick up to 20 specific documents. Changing the scope affects future events only; rows already written stay in the database.

Backfilling history

Import recent reads writes past reading sessions into the database. It covers the last 30 days, up to 250 sessions, newest first, and it imports Viewed sessions only — past downloads and gate completions are not backfilled.

A session is skipped if this connection has already delivered it, or has a delivery for it still in flight. Sessions whose deliveries were abandoned are deliberately re-importable, so an import is the recovery path after a spell of failed syncing.

The database must exist before you can import, and only one import can be in flight at a time: starting a second while the first is still delivering is refused.

One connection per user

Each EveryPage account holds a single Notion connection. Reconnecting to the same workspace refreshes the token and keeps your database and settings — this is how you recover from revoked access. Reconnecting to a different workspace clears the stored database and parent page, because the old database lives somewhere the new token cannot reach; your event and scope choices survive, but you must create a database again.

Schema management

The database schema is version-gated. A database created today is born at the current version and is never patched. Databases created before an optional column existed (Share link, QR code) are patched exactly once, when a delivery first notices the version is behind.

After that one-shot upgrade, a column you delete in Notion stays deleted. EveryPage never re-adds it: rows write only the properties the database still has, and the missing one is skipped silently.

This keeps sync from breaking over cosmetic columns. If EveryPage cannot read your database's schema when a row is due, it omits the optional columns for that row rather than failing the write.

The "Share link" column stores the document's durable short-ID URL, never a vanity slug. A Notion row is a permanent record, and a slug is not: it can be renamed or dropped, and it only resolves on a custom domain, so a slug in this cell would go stale.

The "QR code" column holds an image file. Notion renders external files as image thumbnails only when the URL path has an image extension (e.g., .png), so EveryPage uses a /qr-code.png alias for this endpoint. The QR image is cached for 24 hours.

Failure handling

When syncing cannot continue, EveryPage pauses the connection and emails you the reason. Your configuration — database, events, scope — is kept, and the Notion card shows the state:

  • Authorization revoked: Notion rejected the token, which is how it signals that access was removed. Click Reconnect Notion to resume.
  • Database missing: Notion could not find the "EveryPage Reads" database — it was deleted, or moved out of EveryPage's reach. Pick a parent page and create a new database to resume.
  • Delivery failing: 20 deliveries in a row exhausted all their retries. Fix whatever is refusing the writes, then click Resume syncing.

Only the delivery-failing state is resumable in place; the other two need a reconnect or a new database. To stop syncing entirely, click Disconnect — this removes the connection and its queued rows, but leaves the Notion database and everything already written in it.

Testing the connection

Once the database exists, click Send test row to push one sample Viewed row through the real delivery path. It confirms EveryPage can write to your database and lets you check the column names and types.

Reconnecting and moving the database

To connect a different workspace, click Reconnect Notion on the Notion card.

To put the Reads database somewhere else, click Change location and pick a new parent page. This creates a new "EveryPage Reads" database there: new reads sync to it, and rows already in the old database stay where they are.

Lead capture

If you use email gates to capture reader emails, gate completions with captured emails appear in your Notion database. The "Details" column shows the captured form fields. These rows require Pro; gate completions from free or basic accounts are logged but not synced.

See email gates and lead capture for more on capture gates.

Session tracking

A Viewed row is written once per completed reading session: the event fires when the reader's session ends, not when they open the document. Reading the same document twice writes two rows. Your own reads never produce rows — owner activity does not raise events.

See reader identities for how EveryPage identifies readers across sessions.