Notion

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.

EveryPage is a published Notion integration — you can find it in Notion's integration gallery.

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, then either let EveryPage create an "EveryPage Reads" database on a page you choose, or point the sync at a database you already have. 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 Create a new database, pick a parent page and click Create database. EveryPage creates "EveryPage Reads" there and starts with a default sync: all three event types, all documents. (Or choose Use an existing database — see below.)
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.

Use an existing database

Instead of creating a fresh database, you can point the sync at one that already exists — typically the Proposal tracker that ships with the EveryPage Notion template, which adds its own formula columns and views on top of the Reads schema. Duplicate the template into your workspace, then:

1. In Notion, share the database with EveryPage: open the database's ··· menu → Connections → add EveryPage. Only shared databases appear in the picker.
2. On the Notion card, choose Use an existing database, pick it from the list and click Use this database.

EveryPage reads the database's schema and checks that these columns exist with these Notion property types:

Column names are matched exactly, including case and spacing. Share link (URL) and QR code (Files & media) are optional: add them if you want those cells filled, leave them out if you don't. Any extra columns are ignored — formulas, rollups, statuses and relations you add for your own tracking are never touched, and rows only ever write the columns above.

If a column is missing or has the wrong type, the card refuses the database and lists exactly what to fix (for example "Date: expected Date, found Text"). Correct the property in Notion and try again; nothing is changed on your connection until the check passes. A database that does not appear in the list, or is refused as "not found or not shared", has not been shared with the EveryPage connection yet.

Adopting a database keeps your existing event and scope settings. Once it is connected, click Send test row — that is the way to verify the columns are wired up: the sample row lands in the database with every cell EveryPage can fill.

Change location can also point the sync at an existing database: choose Use an existing database in the picker it opens. New reads sync to the new database; rows already in the old one stay where they are.

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.

Share links and QR codes

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. Create a new database or point the sync at an existing one 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. Pick a new parent page to create a new "EveryPage Reads" database there, or choose Use an existing database to sync into one you already have (see Use an existing database). Either way, new reads sync to the new database and rows already in the old one 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.

Related docs

• Embedding documents
• QR codes
• Webhooks
• Email gates and lead capture
• Reader identities