Description
Overview
This deep research automation workflow enables autonomous, recursive investigation of complex topics using a multi-step orchestration pipeline. Designed for analysts and researchers, it leverages a no-code integration of web search, content scraping, AI reasoning models, and Notion for report compilation. The workflow initiates via a form trigger capturing user input and dynamically generates search queries using an OpenAI chat model to expand research depth and breadth.
Key Benefits
- Automates multi-level research by recursively generating and executing web search queries.
- Integrates web scraping and AI content analysis for precise, information-dense learnings.
- Delivers structured, multi-page reports formatted as Notion blocks for seamless documentation.
- Supports asynchronous execution allowing users to initiate research without waiting for completion.
- Utilizes configurable depth and breadth parameters to control research scope and detail.
Product Overview
This deep research automation workflow starts with a form trigger node capturing user-defined research topics and parameters for depth and breadth. Upon submission, variables are set to define the research scope, and an AI-powered Notion page placeholder is created to store the final report. The core logic revolves around a recursive loop where OpenAI’s chat model generates SERP queries tailored by accumulated learnings and follow-up questions. Each query triggers calls to Apify’s Google search scraper API, retrieving top organic results which are then scraped for page content excluding media and scripts. Extracted HTML is converted to markdown and processed by OpenAI to generate concise learnings and next-step research questions. This loop iterates until the user-specified depth is reached, accumulating learnings and URLs. The final step compiles all learnings into a detailed markdown report via the AI reasoning model, converts it to HTML, then to Notion-compatible JSON blocks, and uploads the content sequentially to the prepared Notion page. Error handling uses default continuation on failed HTTP requests, and authentication relies on API keys for Apify and OpenAI. This design ensures data is processed transiently without persistent storage outside Notion.
Features and Outcomes
Core Automation
This automation workflow uses a recursive event-driven analysis pipeline that accepts user input and iteratively expands research queries using AI-generated follow-up questions and learnings. The workflow executes conditional branching based on depth parameters and accumulates results deterministically.
- Single-pass evaluation of each query’s content to generate unique learnings.
- Controlled recursion using depth and breadth thresholds for scalable research.
- Deterministic aggregation of findings and URLs across iterations.
Integrations and Intake
The workflow connects to Apify’s Google search and web scraper APIs for content retrieval and uses OpenAI’s chat models for query generation and reasoning. Authentication is handled through API keys, and inputs are structured as JSON objects containing search queries and contextual learnings.
- Apify integration for efficient web search and page content extraction.
- OpenAI chat model (o3-mini) for generating SERP queries and summarization.
- Notion API for report storage using structured page creation and block uploads.
Outputs and Consumption
Outputs include a detailed research report formatted in markdown, converted to HTML, then parsed into Notion block JSON for structured storage. The delivery model is asynchronous, with the final report uploaded to a designated Notion database page. Key output fields include report title, description, learnings array, and source URLs.
- Markdown report generation supporting headings, lists, and tables.
- HTML to Notion JSON block conversion preserving semantic structure.
- Asynchronous upload to Notion for persistent and accessible documentation.
Workflow — End-to-End Execution
Step 1: Trigger
The workflow initiates with an n8n form trigger node that collects user input including the research topic, and numerical depth and breadth parameters. The trigger waits for a form submission event and ignores bot activity to ensure valid requests.
Step 2: Processing
Input data is assigned to variables representing the research prompt, recursion depth, breadth, and a unique request ID. Basic presence validation is performed to ensure required fields are populated before proceeding.
Step 3: Analysis
The recursive research loop begins by generating SERP queries using OpenAI’s chat model, informed by previous learnings. Each query triggers a web search via Apify’s Google scraper API, limiting results to exclude PDFs. Top organic results are filtered, and each page URL is scraped for content excluding media and scripts. The HTML content is converted to markdown and analyzed by OpenAI to extract up to three learnings and follow-up questions. These outputs feed into the next recursion cycle until the depth parameter is met.
Step 4: Delivery
Once recursion completes, the accumulated learnings are passed to OpenAI’s reasoning model to generate a comprehensive markdown research report. This markdown is converted to HTML and parsed into Notion block JSON using AI assistance. Blocks are uploaded sequentially to the previously created Notion page, finalizing the report asynchronously.
Use Cases
Scenario 1
An analyst requires a detailed report on emerging market trends. Using this automation workflow, they submit a research query with a defined depth and breadth. The system recursively generates search queries, scrapes relevant data, and compiles a structured report, providing a thorough analysis without manual intervention.
Scenario 2
A researcher needs to investigate recent advancements in renewable energy technology. By leveraging the recursive orchestration pipeline, the workflow autonomously explores multiple search queries, extracts content from credible sources, and synthesizes key learnings and follow-up questions, producing a comprehensive report stored in Notion.
Scenario 3
A corporate knowledge manager wants to automate competitor research. This workflow uses AI to formulate relevant search queries, scrape web content, and generate detailed insights. The final report is asynchronously uploaded to a centralized Notion database, enabling easy access and ongoing updates.
How to use
To deploy this deep research automation workflow in n8n, import the provided template and configure API credentials for Apify (web search and scraping), OpenAI (chat and reasoning models), and Notion (report storage). Publish the workflow and ensure the form trigger endpoint is publicly accessible. Users submit research topics via the form, specifying recursion depth and breadth. The workflow then runs asynchronously, recursively gathering data and generating a structured report in Notion. Users can monitor progress or retrieve the final output from the linked Notion page.
Comparison — Manual Process vs. Automation Workflow
| Attribute | Manual/Alternative | This Workflow |
|---|---|---|
| Steps required | Multiple manual searches, content extraction, note-taking, report writing. | Single form submission initiates full recursive research and report generation. |
| Consistency | Varies by researcher skill and diligence; prone to oversight. | Consistent AI-driven query generation and content synthesis with structured output. |
| Scalability | Limited by human time and effort; scaling increases cost and time exponentially. | Scales via configurable depth and breadth parameters; runs asynchronously without user monitoring. |
| Maintenance | Requires manual updates to research methods and tools. | Centralized workflow with configurable nodes; requires API key updates and occasional tuning. |
Technical Specifications
| Environment | n8n automation platform |
|---|---|
| Tools / APIs | OpenAI chat and reasoning models, Apify web search and scraper, Notion API |
| Execution Model | Asynchronous, event-driven recursive workflow |
| Input Formats | Form submission JSON with text and numeric parameters |
| Output Formats | Markdown report converted to HTML and Notion block JSON |
| Data Handling | Transient data processing with final report persisted in Notion |
| Known Constraints | Dependent on external API availability and rate limits (Apify, OpenAI, Notion) |
| Credentials | API keys for Apify, OpenAI, and Notion required |
Implementation Requirements
- Valid API credentials for Apify (web search and scraping), OpenAI (chat and reasoning), and Notion (report storage).
- Publicly accessible n8n instance or webhook endpoint for form submission trigger.
- User must configure research depth and breadth parameters understanding associated time and cost implications.
Configuration & Validation
- Configure and test API credentials in n8n for Apify, OpenAI, and Notion nodes.
- Validate form trigger endpoint by submitting test research queries with depth and breadth inputs.
- Verify Notion page creation and asynchronous report generation completes without errors.
Data Provenance
- Triggered by the “On form submission” n8n node capturing user input.
- Query generation and reasoning via OpenAI Chat Model nodes using the o3-mini model.
- Web search and scraping through Apify API accessed by HTTP Request nodes.
- Report storage and updates managed via Notion nodes with authenticated API calls.
- Data fields used include research queries, learnings array, follow-up questions, and source URLs.
FAQ
How is the deep research automation workflow triggered?
The workflow is triggered by an n8n form submission capturing the research prompt, depth, and breadth parameters, initiating the recursive research process asynchronously.
Which tools or models does the orchestration pipeline use?
It uses OpenAI chat models (o3-mini) for generating search queries and reasoning, Apify APIs for web search and page scraping, and Notion API for report storage and updates.
What does the response look like for client consumption?
The final output is a detailed research report formatted in markdown, converted to Notion-compatible JSON blocks, and uploaded asynchronously to a Notion page specified at workflow initiation.
Is any data persisted by the workflow?
Only the final compiled research report and source URLs are persisted in a Notion database page. Intermediate data is transient and handled within the workflow execution.
How are errors handled in this integration flow?
HTTP request nodes for web scraping are configured to continue on error by default, allowing the workflow to proceed despite occasional failures. No explicit retry or backoff mechanisms are configured.
Conclusion
This deep research automation workflow provides a structured, recursive mechanism to perform autonomous, in-depth investigations on user-defined topics. By combining web scraping, AI-generated search queries, and reasoning models, it produces detailed, multi-page reports asynchronously stored in Notion. The approach reduces manual effort and ensures consistent, scalable research outcomes. A key constraint is its reliance on external APIs (Apify, OpenAI, Notion), which may affect availability and throughput. Overall, this workflow offers a deterministic, extensible solution for complex research tasks within the n8n platform.
Reviews
There are no reviews yet.