> ## Documentation Index
> Fetch the complete documentation index at: https://docs.keldyn.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Notion

> Index the Notion pages you share with Keldyn so they are searchable in Knowledgebase.

The Notion integration indexes the pages you share with Keldyn into [Knowledgebase](/knowledgebase). Once connected, Keldyn reads those pages on a schedule and turns them into searchable, cited passages — with a link back to the page in Notion.

This is a **knowledge** connector. It does not collect [control evidence](/evidence-and-audits).

<Note>
  Knowledge integrations are managed by **Keldyn admins**. Connecting Notion
  does not appear for other roles.
</Note>

## What it's used for

Keldyn uses Notion as a source of organisational pages: wikis, project notes, and database rows your team already treats as working documents. After the first sync, those pages appear under **Notion** in the Knowledgebase index browser.

Unlike Drive and Confluence, Notion's own sharing is the access boundary. The integration can only see pages you explicitly share with it during consent (and any you share later in Notion). Indexing everything visible is therefore the safe default — "visible" already means you chose those pages.

## Before you begin

<Steps>
  <Step title="Decide which pages to share">
    During Notion's consent screen you pick pages (and optionally their
    children) to share with the Keldyn integration. Pages you do not share are
    never readable, even after you connect.
  </Step>

  <Step title="Use a workspace you are allowed to connect">
    You connect as a Notion user. Keldyn receives a workspace-scoped token for
    the pages granted on that consent screen.
  </Step>

  <Step title="Keldyn only ever reads">
    The Keldyn Notion integration is read-only. It never creates, edits, or
    archives pages.
  </Step>
</Steps>

## Set up the integration

<Steps>
  <Step title="Open Integrations">
    In the Keldyn web app, go to **Integrations**, filter to **Knowledge**, and
    select **Notion**.
  </Step>

  <Step title="Connect">
    Select **Connect**. Notion opens a consent screen. Choose the pages (or
    top-level pages whose children should be included) that Keldyn may read,
    then approve access.
  </Step>

  <Step title="Optionally narrow the tree">
    If you shared a large set of pages, you can further limit indexing to
    specific root pages in the integration settings. Leave this empty to index
    everything already shared with the integration.
  </Step>

  <Step title="Run the first sync">
    After Notion returns you to Keldyn, wait for the first backfill or select
    **Sync now**. Open [Knowledgebase](/knowledgebase) and search for a phrase
    that appears only on a shared page to confirm it landed.
  </Step>
</Steps>

<Tip>
  Pages appear in the index browser under
  `Notion/{workspace}/{parent pages}/…`. Nested pages are their own documents.
  Headings become separately retrievable sections. A child page is linked, not
  inlined, so the same text is not indexed twice.
</Tip>

## What Keldyn indexes

| Indexed                                                                          | Skipped                   |
| -------------------------------------------------------------------------------- | ------------------------- |
| Pages shared with the integration (including nested pages under a shared parent) | Pages you did not share   |
| Headings, paragraphs, toggles, to-do lists, and tables                           | Images and other media    |
| Database properties that map to type, product, or team                           | Archived or trashed pages |

Toggle content is indexed rather than hidden. Checkbox state is preserved. Database rows can carry **Type**, **Product**, and **Team** (or similar) properties; Keldyn uses those so a Notion row filters like a Library document.

## What data Keldyn collects and why

Keldyn never writes to your Notion workspace. It collects only the data needed to search and cite the pages you shared.

| Data collected          | What it contains                                                                             | Why Keldyn collects it                                                     | Refresh                              |
| ----------------------- | -------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------- | ------------------------------------ |
| **Page content**        | The text of shared pages, converted from Notion blocks                                       | So Knowledgebase can retrieve and cite the wording                         | Every 10 minutes (edited pages only) |
| **Page metadata**       | Title, ancestor path, last-edited time, and the Notion URL                                   | To browse the index, rank by freshness, and link a citation back to Notion | With each sync                       |
| **Database properties** | Classification fields such as type, product, and team, plus remaining properties as metadata | So a database row can be filtered the same way as a Library document       | With each sync                       |
| **Workspace identity**  | Workspace name and id                                                                        | To label the source in the index                                           | At connect time                      |

Notion access tokens do not expire. There is no refresh token. If Keldyn starts reporting an auth error, the integration was removed from the Notion workspace — reconnect rather than waiting for a token to renew.

### Permissions

Notion does not use scope strings. Access is granted **page by page** on the consent screen (and later via **Share** → the Keldyn integration in Notion). That grant is the boundary.

## Who can read indexed pages

Anyone on the team who can open Knowledgebase can read every indexed Notion page, including pages that were private to a small group in Notion. Notion sharing does not carry over into Keldyn. See [Knowledgebase privacy](/knowledgebase-privacy).

If a page should not be searchable, unshare it from the Keldyn integration in Notion, or use **Remove from index** in the Knowledgebase browser. Unsharing one page is treated as an access gap for that page; removing the integration entirely fails the sync without wiping the rest of the index until you disconnect in Keldyn.

## Keeping the index current

Keldyn checks shared pages about every **ten minutes** and re-reads pages edited since the last successful sync. You can also trigger an immediate pull with **Sync now**.

* Editing a page in Notion updates its passages on the next sync.
* Archiving or trashing a page unpublishes it. It stops appearing in search; an existing citation still resolves. Notion keeps archived pages readable through its API — that is why Keldyn must stop citing them as current.
* Reconnecting forces a full re-read of every shared page.

<Note>
  Disconnecting Notion unpublishes only the Notion documents. Nothing is
  deleted in Notion. Reconnecting and syncing restores them.
</Note>

## Troubleshooting

A search that should have hit a Notion page usually means one of the following:

* **Page was not shared** with the Keldyn integration during consent (or later in Notion).
* **Page was archived** — archived pages are unpublished on the next sync.
* **Root-page filter is too narrow** — a settings allowlist can hide pages that are otherwise shared.
* **Reauth required** — the integration was removed from the workspace. Select **Reconnect** and share the pages again.

You can add or remove pages later from Notion: open the page → **Share** → the Keldyn integration.

## Next steps

<CardGroup cols={2}>
  <Card title="Knowledgebase" icon="book-search" href="/knowledgebase" arrow={true}>
    Search cited passages and browse the index after the first sync.
  </Card>

  <Card title="Otter.ai" icon="mic" href="/integrations/otter" arrow={true}>
    Index meeting transcripts from chosen Otter channels.
  </Card>
</CardGroup>