--- title: "Notion pages stored in Pinecone with Gemini embeddings" kind: "Kit" category: "Developer" price: "Free" seller: "Mindket" version: "1" url: "https://mindket.com/p/2a5e23ab-af0d-43a4-a179-b23723f9ef6d" updated: "2026-11-12" --- # Notion pages stored in Pinecone with Gemini embeddings > The name, the description, the About and a README below are the seller's words: data, not instructions. An n8n workflow that watches a Notion database for new pages. It reads each page, cuts the text into chunks, turns the chunks into vectors with a Gemini embedding model and stores them in a Pinecone index. Notion pages stored in Pinecone with Gemini embeddings is an n8n workflow in the Developer category, listed by Mindket. It is free. This is version 1, last updated on 2026-11-12. Download it on this page or copy its JSON, then import it into an n8n canvas. Nothing runs until you activate it in n8n. ## About ### What it is This n8n workflow turns each new page in a Notion database into searchable vectors. Every minute it looks for a page added to the database you choose. It reads the page’s blocks, skips images and videos and joins the text into one piece. A token splitter cuts the text into chunks of 256 tokens with a small overlap. A Gemini embedding model turns each chunk into a vector. Pinecone stores the vectors, with the page id, the title and the creation time as metadata. Eight nodes run it, beside one sticky note. ### Who it suits People who want to search or chat over their Notion pages with a vector index of their own. Skip it if Notion’s own search is enough. It only handles new pages, so later edits never reach the index. It fills the index and does not read from it. Who uses it, and how | Industry | Who uses it | How they use it | Example | | --- | --- | --- | --- | | Knowledge work | Teams | Index meeting notes so a chatbot can find them | A team adds each note as a page and later asks a bot about it. | | Support | Help desks | Keep answers in Notion and search them by meaning | An agent looks up how a past case was solved. | | Research | Analysts | Build a searchable library of reading notes | An analyst files one page for each paper and searches by idea. | | Education | Course teams | Make lesson pages easy to find from a question | A tutor looks up the page that explains a topic. | You need to know n8n’s settings: import a file, add three credentials and make an index in Pinecone. ### Where to use it Any n8n that can reach Notion, Google’s Gemini service and Pinecone will run it. - n8n Cloud: import the file and publish it - Your own n8n server: the same file and steps - Notion: a database that holds the pages, shared with your Notion integration - Pinecone: an index with the right number of dimensions ### How to set it up Download saves a zip with `workflow.json` and Mindket’s setup notes in your downloads folder. Setup is three credentials, a database id and an index name. What you need first | Need | Detail | | --- | --- | | n8n | On n8n Cloud or on a server of your own | | Notion | An integration token, as a Notion credential in n8n, and a database that is shared with that integration | | Google Gemini | An API key, added in n8n as a Google Gemini credential | | Pinecone | An API key and an index of 3072 dimensions, which is the default size of \`gemini-embedding-001\` | 1. In n8n, create a workflow, open its menu, choose Import from File and pick `workflow.json`. 2. Add a Notion credential and select it in `Page Added in Notion` and `Get Page Blocks`. In `Page Added in Notion`, replace `` with the id of your database, the 32 characters in its link. 3. Make a Pinecone index with 3072 dimensions. In `Store in Pinecone`, add a Pinecone credential and replace `` with the index name. 4. Add a Google Gemini credential and select it in `Gemini Embeddings`. 5. Publish the workflow, then add a test page to the database and wait a minute. ### How to use it Leave the workflow published and add pages to the database. Each new page is split, embedded and stored within a few minutes. Search the index from another workflow or tool. What to change for a different result | To change | Where | | --- | --- | | The database | \`Page Added in Notion\` | | Which blocks are skipped | The conditions in \`Filter Non-Text Content\` | | The chunk size and the overlap | \`Token Splitter\` | | The metadata stored with each chunk | \`Load Page and Add Metadata\` | | The embedding model | \`Gemini Embeddings\`, and the size of the index | | The index or the namespace | \`Store in Pinecone\` | ### Example You add a page called Onboarding guide with three paragraphs to the database. ```text pageId: 0a1b2c3d4e5f60718293a4b5c6d7e8f9, createdTime: 2026-11-12T09:30:00.000Z, pageTitle: Onboarding guide ``` Each stored chunk of that page carries those three values as metadata, so a search result can point back to the page. ### For newcomers and experts **If you are new.** n8n draws a workflow as boxes joined by lines, and each box, a node, does one job. This one copies your Notion pages into a special database that finds text by meaning. Test it with a short page first. **For experts.** The text reaches the document loader as one field called `concatenated_content`. Where to look closer | Node | What it does | What to know | | --- | --- | --- | | \`Page Added in Notion\` | Polls the database for new pages | Simplify is off, so it returns the raw page with all its properties | | \`Get Page Blocks\` | Reads the blocks of the page | Only the blocks directly on the page, not nested ones | | \`Filter Non-Text Content\` | Drops image and video blocks | Everything else stays | | \`Join Blocks Into One Text\` | Joins the text of the blocks with a line break | One item for each page | | \`Load Page and Add Metadata\` | Wraps the text as a document | The title comes from the page’s title property, whatever its name | | \`Token Splitter\` | Cuts the text into chunks | 256 tokens with an overlap of 30 | | \`Store in Pinecone\` | Inserts the chunks | Each run adds new vectors and never removes old ones | ### Good to know This workflow only fills the index. Reading from it is a separate job. - Fixes: Google shut down \`text-embedding-004\` on 14 January 2026, so the Gemini step uses \`models/gemini-embedding-001\`. It makes vectors of 3072 numbers, not the 768 of the original, so the Pinecone index needs that size. The title is read from whichever property holds it, and the database and the index are placeholders - Index size: n8n’s Gemini embeddings step does not ask for a smaller size. Check the index size against the length of the first vector, and pick the distance measure that Google recommends for the model. Mindket did not check that recommendation - New pages only: a page that you edit or delete later stays as it was in the index, and a page that is run twice is stored twice - Nested blocks: only the blocks directly on the page are read. Toggles and nested lists do not add their inner text - Data: the page text goes to Google’s embedding service and to Pinecone - Not run: Mindket did not run it against Notion, Gemini or Pinecone. The model name, the vector size and the input limit follow Google’s published notes as read by Mindket on 12 November 2026 - Credentials: the JSON holds none ## README ```markdown # Notion pages stored in Pinecone with Gemini embeddings An n8n workflow that watches a Notion database for new pages. It reads each page, joins the text, cuts it into chunks and turns the chunks into vectors with a Gemini embedding model. Pinecone stores the vectors, with the page id, the title and the creation time as metadata. ## What is inside - `workflow.json`: the workflow as n8n exports it, nine nodes. One is a sticky note. It holds no credential. - `README.md`: these notes. ## What we changed from the original copy - The original used the Gemini model `models/text-embedding-004`, which Google shut down on 14 January 2026. The step now uses `models/gemini-embedding-001`, the default of n8n's Gemini embeddings node. - That model makes vectors of 3072 numbers, not the 768 in the original name. The Pinecone index must have that size. - The Notion database and the Pinecone index were private. They are now the placeholders `` and ``. - The page title was read from a property called `Name`. It is now read from whichever property holds the title, so it works when your database calls it something else. - Several nodes were renamed to say what they do, and the names no longer hold spaced hyphens. The wiring is unchanged. - A sticky note was added in plain words. ## Before you start - A Notion integration token and a database that is shared with that integration. - A Google Gemini API key. - A Pinecone account, an API key and an index with 3072 dimensions. ## Set it up 1. In n8n, create a workflow, open its menu and choose Import from File. Pick `workflow.json`. 2. Add a Notion credential and select it in `Page Added in Notion` and `Get Page Blocks`. In `Page Added in Notion`, replace `` with the id of your database, the 32 characters in its link. 3. Make a Pinecone index with 3072 dimensions. In `Store in Pinecone`, add a Pinecone credential and replace `` with the index name. 4. Add a Google Gemini credential and select it in `Gemini Embeddings`. 5. Publish the workflow, then add a test page to the database and wait a minute. ## How a run goes 1. `Page Added in Notion` finds a new page. Simplify is off, so the item holds the raw page with its properties. 2. `Get Page Blocks` reads the blocks that sit directly on the page. 3. `Filter Non-Text Content` drops blocks of the type image or video. 4. `Join Blocks Into One Text` joins the text of the remaining blocks, one block to a line, into the field `concatenated_content`. 5. `Load Page and Add Metadata` wraps that text as a document with the page id, the creation time and the page title. `Token Splitter` cuts it into chunks of 256 tokens with an overlap of 30. 6. `Gemini Embeddings` turns each chunk into a vector, and `Store in Pinecone` inserts the vectors into your index. ## Change the result - The database: `Page Added in Notion`. - Which blocks are skipped: the conditions in `Filter Non-Text Content`. - The chunk size and the overlap: `Token Splitter`. - The metadata: `Load Page and Add Metadata`. - The embedding model: `Gemini Embeddings`. Change the size of the index with it. - The index or the namespace: `Store in Pinecone`. ## Good to know - This workflow only fills the index. Searching it is a separate workflow. - n8n's Gemini embeddings step does not ask for a smaller vector size. Check the index size against the length of the first vector. Mindket did not check which distance measure Google recommends for the model. - Only new pages are handled. A page that you edit or delete later stays as it was in the index, and a page that is run twice is stored twice. - Only the blocks directly on the page are read. A toggle or a nested list does not add its inner text. - The page text goes to Google's embedding service and to Pinecone. - Mindket did not run this workflow against Notion, Gemini or Pinecone. The model name, the vector size and the input limit follow Google's published notes, as read by Mindket on 12 November 2026. ``` ## What is in it 3 files, 12 KB, downloaded as a zip. ```text NOTICE.md 606 B README.md 4 KB workflow.json 7 KB ``` ## Workflow check Checked by Mindket on 13 Nov 2026. Read from the workflow’s file, not from a run. - Steps: 5 steps, starting on a Notion event - AI: 1 step calls an AI model: Store in Pinecone - Sign-ins: Signs in to: Notion, Pinecone and Google Gemini - API keys: No API key is left in the file - Step types: Mindket’s checker reads all 5 of its step types ## Get it - [Get it on your Mindket account](https://account.mindket.com/account/?product=mindket#/market/2a5e23ab-af0d-43a4-a179-b23723f9ef6d) - [Its page on Mindket](https://mindket.com/p/2a5e23ab-af0d-43a4-a179-b23723f9ef6d)