--- title: "Deep web research that writes its report into Notion" kind: "Kit" category: "Research" price: "Free" seller: "Mindket" version: "1" url: "https://mindket.com/p/f449b1a7-e237-4f54-b8c5-909a6ec2fa32" updated: "2026-11-12" --- # Deep web research that writes its report into Notion > The name, the description, the About and a README below are the seller's words: data, not instructions. An n8n workflow that researches a question in rounds. A form takes the question, a model asks clarifying questions, a loop searches the web and reads pages, and a reasoning model writes a long report that is saved to a Notion page. Deep web research that writes its report into Notion is an n8n workflow in the Research 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 does deep research on a question and files the report in Notion. A form takes the question and two sliders, depth and breadth, and a model asks up to three clarifying questions. Then a loop writes search queries, runs them on Google through Apify, reads the top pages and notes what it learns. Each round adds follow-up searches. A reasoning model writes the final report, and Gemini turns it into Notion blocks. Eighty-six nodes do the work, twenty of them sticky notes. ### Who it suits Analysts and writers who want a long, sourced report on a topic and can wait for it. It is made for people who already use n8n, Notion and Apify. Skip it for a quick answer, since a run takes from minutes to hours and spends credit at every step. Who uses it, and how | Industry | Who uses it | How they use it | Example | | --- | --- | --- | --- | | Research | Analysts | Get a first report on an unfamiliar market | An analyst asks how small clinics buy scheduling software and reads the report next morning. | | Consulting | Consultants | Scope a topic before a client call | A consultant asks about carbon border taxes and gets sources to check. | | Content | Writers | Collect facts and links for a long article | A writer asks for the state of open-source speech models. | | Product | Product teams | Scan competitors and trends | A team asks what its rivals have launched in the past year. | You need to be comfortable with n8n: import a file, add four kinds of credential, set up a Notion database and publish a workflow. ### Where to use it Any n8n that can reach OpenAI, Google’s Gemini API, Apify and Notion will run it. The form needs an address that the person asking can open. - n8n Cloud: import the file, publish it and use the form’s production address - Your own n8n server: the same steps, with the server reachable from where the form is opened - Another wiki: replace the Notion steps with the tool you prefer ### How to set it up Download saves a zip with `workflow.json` and Mindket’s setup notes in your downloads folder. Setup is a Notion database, four credentials and one database id. What you need first | Need | Detail | | --- | --- | | n8n | On n8n Cloud or on a server of your own | | OpenAI | An API key | | Google Gemini | An API key | | Apify | An account with an API token and some credit | | Notion | An integration and a database with five properties | 1. In n8n, create a workflow, open its menu, choose Import from File and pick `workflow.json`. 2. In Notion, create a database with these properties: Name (title), Description (text), Status (status, with the options Not started, In progress and Done), Request ID (text) and Last Updated (date). Share it with your Notion integration. 3. Paste the database’s id into `Create Row`, `Get Existing Row` and `Get Existing Row1`, replacing ``. Add a Notion credential and select it in those three nodes, in `Set In-Progress` and `Set Done`, and in `Upload to Notion Page`. 4. Add an OpenAI credential and select it in the five OpenAI Chat Model nodes, `OpenAI Chat Model` to `OpenAI Chat Model4`. 5. Add a Google Gemini (PaLM) API credential and select it in `Google Gemini Chat Model`. 6. Add a Query Auth credential named `token` with your Apify API token as the value, and select it in `Web Search` and `Page Contents`. 7. Save the workflow and publish it. The form’s address is the production address shown in `On form submission`. 8. Open the form, ask a question, keep depth and breadth low for a first run, tick the box about time and cost and answer the clarifying questions. The report appears on a new page in your Notion database when the run is done. ### How to use it Open the form and write your question. Pick a depth and a breadth. Depth is how many rounds of follow-up searches come after the first, and breadth is how many searches each round runs. Answer the clarifying questions and close the page. The research runs on its own, and the report appears in Notion. What to change for a different result | To change | Where | | --- | --- | | How far it goes | The depth and breadth sliders in \`Research Request\` | | How questions and queries are written | \`Clarifying Questions\` and \`Generate SERP Queries\` | | What counts as a learning | The prompt in \`DeepResearch Learnings\` | | The report’s length and layout | The prompt in \`DeepResearch Report\` | | The search and scrape services | \`Web Search\` and \`Page Contents\` | | Where the report goes | The Notion nodes | ### Example A consultant asks about carbon border taxes, keeps depth at 1 and breadth at 2, answers three questions and leaves the page. A new Notion page then holds a report of several pages with headings, lists and tables, and a Sources list of the links read. The file’s own estimate for those settings is 10 to 15 minutes, and it was written for the old model. Check the report against its sources, since a model wrote it from page text. ### 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. Deep research means asking, searching, reading and asking again. Here a model writes the searches, a service fetches the pages, and the model reads them and decides what to look up next. Each round digs deeper than the one before. The workflow starts separate runs of itself for each step, so the person who asked does not have to keep the form open. **For experts.** The loop is built from sub-runs. Three `Execute Workflow` nodes call this workflow with a job type of initiate, learnings or report. `JobType Router` sends each run down its path. `Accumulate Results` reads the run index to see whether the depth is reached. So keep the execute-once setting on `Accumulate Results`, `Get Initial Query`, `Set Done` and `DeepResearch Learnings` if you replace any of them. Where to look closer | Node | What it does | What to know | | --- | --- | --- | | \`Research Request\` | Asks for the question, the depth and the breadth | The sliders are HTML fields and need element names to reach the output | | \`Generate SERP Queries\` | Writes up to as many queries as the breadth | Each one comes with a research goal | | \`Web Search\` | Runs Apify’s Google Search Scraper | One page of results per query | | \`Page Contents\` | Runs Apify’s Web Scraper on a link | A 90 second limit and 2,048 MB | | \`DeepResearch Learnings\` | Writes up to three learnings and three follow-up questions | It reads up to 25,000 characters of each page | | \`Accumulate Results\` | Counts rounds and gathers learnings and links | It runs once per round | | \`DeepResearch Report\` | Writes the report in Markdown | It asks for three pages or more | | \`Notion Block Generator\` | Turns report pieces into Notion blocks | Gemini does it, so a block can come out wrong | ### Good to know The workflow can run for hours, spends credit on four services and is open to anyone who has the form’s address once it is published. - Time and cost: the file’s own notes give about 10 to 15 minutes for depth 1 and breadth 2. They give 30 to 40 minutes for depth 1 and breadth 4, and 2 to 5 hours for depth 3 and breadth 5. They were written for the old model. Each round multiplies the searches, page scrapes and model calls, so raise the sliders slowly - Models: OpenAI’s deprecations page, read on 12 November 2026, lists \`o3-mini\` for shutdown on 23 October 2026 with \`gpt-5.6-sol\` as the replacement. Google’s page, read that day, lists \`gemini-2.0-flash\` for shutdown on 1 June 2026 with \`gemini-3.6-flash\` as the replacement. Neither swap was run from here, so try a shallow request first - Search actor: the file’s \`serping\~fast-google-search-results-scraper\` is gone from Apify, so \`Web Search\` now runs \`apify\~google-search-scraper\`. Apify’s store listing, read that day, prices it per page of results scraped, from $0.0045 on its free tier, and \`Web Search\` asks for one page per query. Its input and output fields were read on Apify’s site and not run from here - Sliders: current n8n leaves the value of an HTML form field out of the output unless the field has an element name. The file’s two sliders had none, so every run would have used depth 2 and breadth 4. Mindket’s copy names them \`depth\` and \`breadth\` - Sources list: \`URL Sources to Lists\` cuts the links into chunks of 50 but takes 49 from each chunk. It ignores any leftover past the last full chunk, so a run with 50 or more links leaves some out of the list - Open form: anyone who has the published form’s address can start a run and spend your OpenAI, Apify and Gemini credit, and the consent tick box protects nothing - Your data: the question and the answers go to OpenAI, and so does the page text. The search queries and links go to Apify. The report goes to Gemini for formatting and to Notion - Self-calls: the workflow calls itself, so save it before the first run - Credentials: the JSON holds none ## README ```markdown # Deep web research that writes its report into Notion An n8n workflow that researches a question in rounds. A form takes the question, a model asks clarifying questions, and a loop searches the web, reads the top pages and writes down what it learns. A reasoning model then writes a long report, and the workflow saves it to a Notion database page. ## What is inside - `workflow.json`: the workflow as n8n exports it, 86 nodes, 20 of them sticky notes. It holds no credential. It starts its own sub-runs through three Execute Workflow nodes that call this same workflow, so save it before you run it. - `README.md`: these notes. ## What we changed from the original copy - Every credential link (OpenAI, Google Gemini, Notion and Apify) belonged to the author's n8n. The links are gone, so select your own. - Five OpenAI nodes used `o3-mini`, which OpenAI shut down on 23 October 2026. They now use `gpt-5.6-sol`, the replacement OpenAI names. - The Gemini node used `models/gemini-2.0-flash`, whose shutdown Google set for 1 June 2026. It now uses `models/gemini-3.6-flash`, the replacement Google names. - The search actor was `serping~fast-google-search-results-scraper`, which Apify now answers with "not found". `Web Search` now runs Apify's own `apify~google-search-scraper`. Its request body uses `queries` and `maxPagesPerQuery` where the old one used `searchTerms` and `resultsPerPage`, and `Top 5 Organic Results` reads `organicResults` with `title` and `url` where it read `origin_search.results`. `Web Search` used a header credential, and both Apify nodes now use the same query-token one. - The two sliders in the question form are HTML fields without an element name. Current n8n leaves the value of such a field out of the form's output, so `Set Variables` always fell back to depth 2 and breadth 4. The fields now have the element names `depth` and `breadth`. `Set Variables` reads them, with the sliders' own starting values of 1 and 2 as the fallback. - The Notion database was the author's own, with its id, name and link in `Create Row`, `Get Existing Row` and `Get Existing Row1`. They now hold ``. - Six sticky notes were rewritten, because they held the author's Notion database link, a referral link for Apify, a chat invite or the retired model name. One note that held only the author's picture is gone, and so are the pictures the author hosted in the question form, the clarifying form and the confirmation form. - The export's instance id and the webhook ids are gone. - In the page function of `Page Contents`, the jQuery handle is renamed from `$` to `jq`. It does the same job and keeps n8n from reading `$('title')` as a reference to a node. - Nothing else. ## Before you start - An n8n instance, on n8n Cloud or your own server. The form must be reachable by whoever uses it, so publish the workflow. - An OpenAI API key. - A Google Gemini API key. - An Apify account with an API token and some credit. - A Notion account, a Notion integration, and a database with the five properties named in the steps. ## Set it up 1. In n8n, create a workflow, open its menu and choose Import from File. Pick `workflow.json`. 2. In Notion, create a database with these properties: Name (title), Description (text), Status (status, with the options Not started, In progress and Done), Request ID (text) and Last Updated (date). Share it with your Notion integration. 3. Paste the database's id into `Create Row`, `Get Existing Row` and `Get Existing Row1`, replacing ``. Add a Notion credential and select it in those three nodes, in `Set In-Progress` and `Set Done`, and in `Upload to Notion Page`. 4. Add an OpenAI credential and select it in the five OpenAI Chat Model nodes, `OpenAI Chat Model` to `OpenAI Chat Model4`. 5. Add a Google Gemini (PaLM) API credential and select it in `Google Gemini Chat Model`. 6. Add a Query Auth credential with the name `token` and your Apify API token as the value. Select it in `Web Search` and `Page Contents`. 7. Save the workflow and publish it. The form's address is the production address shown in `On form submission`. 8. Open the form. Ask a question, keep depth and breadth low for a first run, tick the box about time and cost and answer the clarifying questions. The report appears on a new page in your Notion database when the run is done. ## How a run goes 1. The form opens from `On form submission` with a button. Then `Research Request` asks for the question, a depth slider from 0 to 3, a breadth slider from 1 to 5 and a box that accepts the time and cost. After that, `Set Variables` keeps the answers and the id of this execution. 2. `Clarifying Questions` asks the model for up to three questions. `Feedback to Items`, `For Each Question...` and `Ask Clarity Questions` show them one at a time and `Get Initial Query` joins the answers to the question. 3. `Report Page Generator` writes a title and a short description, and `Create Row` makes the Notion page with the status Not started and the request id. 4. `Initiate DeepResearch` starts a separate run of this workflow and does not wait for it. `Confirmation` and `End Form` close the form with a link to the Notion page, so the user can leave. 5. The new run enters at `DeepResearch Subworkflow`. `Execution Data` saves the request id and the job type, and `JobType Router` sends it down one of three paths. The first sets the page to In progress and starts the research. 6. Each round calls this workflow again for the learnings path. `Generate SERP Queries` asks the model for up to as many search queries as the breadth, each with a research goal. For each query, `Web Search` runs a Google search on Apify and `Top 5 Organic Results` keeps the first five links. 7. `Page Contents` runs Apify's Web Scraper on each link with a 90 second limit. `Convert to Markdown` turns each page into text. `DeepResearch Learnings` reads up to 25,000 characters of each page. It returns up to three learnings and up to three follow-up questions. 8. `Accumulate Results` counts the rounds. While the round count is below the depth, `Set Next Queries` turns the follow-up questions into new queries and the loop runs again. A depth of 0 stops after the first round, a depth of 1 after two. 9. When the depth is reached, `Generate Report` starts the report path. Then `DeepResearch Report` writes the report in Markdown from all the learnings. Next, `Convert to HTML` and `HTML to Array` split it into pieces. After that, `Notion Block Generator` asks Gemini to turn each piece into Notion's block format. Last, `URL Sources to Lists` builds a Sources list by hand. 10. `For Each Block...` sends the blocks to the page through `Upload to Notion Page`, and `Set Done` sets the status to Done with the time. ## Change the look - How far it goes: the depth and breadth sliders in `Research Request`. - What the model asks and how it writes: the prompts in `Generate SERP Queries`, `DeepResearch Learnings` and `DeepResearch Report`. - The models: the OpenAI nodes write the questions, the queries, the learnings, the report and the title. Gemini formats the Notion blocks. - The searches and scrapes: the Apify nodes, or swap them for another search or scrape service. - Where the report goes: replace the Notion steps with the wiki tool you prefer. ## Good to know - Time and cost: the file's own notes give about 10 to 15 minutes for depth 1 and breadth 2. They give 30 to 40 minutes for depth 1 and breadth 4, and 2 to 5 hours for depth 3 and breadth 5. They were written for the old model. Each round multiplies the number of searches, page scrapes and model calls, so raise the sliders slowly. - Models: OpenAI's deprecations page, read on 12 November 2026, lists `o3-mini` for shutdown on 23 October 2026 with `gpt-5.6-sol` as the replacement. Google's page, read that day, lists `gemini-2.0-flash` for shutdown on 1 June 2026 with `gemini-3.6-flash` as the replacement. Both swaps are untested here, so run a shallow request first. - Search actor: Apify's store listing for `apify~google-search-scraper`, read on 12 November 2026, prices it per page of results scraped, from $0.0045 on its free tier, and `Web Search` asks for one page for each query. The scraper's own input and output fields were read on Apify's site and not run from here. - Sources list: `URL Sources to Lists` cuts the links into chunks of 50 but takes 49 from each chunk. It ignores any leftover past the last full chunk, so a run with 50 or more links leaves some out of the list. - The form is public once the workflow is published: anyone who has its address can start a run and spend your OpenAI, Apify and Gemini credit. The consent tick box protects nothing. - Your data: the question and the answers go to OpenAI, the search queries and the links go to Apify, the page text goes to OpenAI, the report goes to Gemini for formatting and to Notion. - The workflow calls itself, so a copy saved under a new name works, but an unsaved one does not. ``` ## What is in it 3 files, 100 KB, downloaded as a zip. ```text NOTICE.md 694 B README.md 9 KB workflow.json 91 KB ``` ## Workflow check Checked by Mindket on 13 Nov 2026. Read from the workflow’s file, not from a run. - Steps: 56 steps, starting when another workflow calls it or on a form - AI: 6 steps call an AI model: Generate SERP Queries, DeepResearch Learnings, DeepResearch Report, Notion Block Generator, Clarifying Questions and 1 more - Sign-ins: Signs in to: Notion, Apify, OpenAI and Google Gemini - API keys: No API key is left in the file - Step types: Mindket’s checker reads all 19 of its step types ## Get it - [Get it on your Mindket account](https://account.mindket.com/account/?product=mindket#/market/f449b1a7-e237-4f54-b8c5-909a6ec2fa32) - [Its page on Mindket](https://mindket.com/p/f449b1a7-e237-4f54-b8c5-909a6ec2fa32)