Reddit Q&A to Notion MCP Server
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Reddit Q&A to Notion MCP ServerSearch Reddit for 'React hooks best practices' and save to Notion"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Reddit Q&A to Notion MCP Server
A simple MCP server that searches Reddit for answers to questions and saves Q&A sessions to Notion.
Features
🔍 Search across all Reddit or specific subreddits
📊 Get top posts with comments for context
🤖 Perfect for LLM-powered Q&A workflows
💾 Save complete Q&A sessions to Notion
🔐 Secure HTTP transport with authentication
📱 Built with PRAW for reliable Reddit access
Related MCP server: AI-Notion Integration MCP Server
Quick Start
1. Environment Setup
Create a .env file:
# MCP Authentication
MCP_API_KEY=your-secret-api-key-here
# Reddit API (get from https://www.reddit.com/prefs/apps)
CLIENT_ID=your-reddit-client-id
CLIENT_SECRET=your-reddit-client-secret
USER_AGENT=your-app-name/1.0
# Notion Integration
NOTION_API_TOKEN=your-notion-integration-token
NOTION_QA_DATABASE_ID=your-notion-database-id
# Optional: Proxy for cloud deployments (required for Render, AWS, etc.)
HTTP_PROXY=http://username:password@proxy-server:port
HTTPS_PROXY=http://username:password@proxy-server:port⚠️ Cloud Platform Note: Reddit blocks most cloud provider IPs (AWS, Google Cloud, Render, etc.). You need a proxy service for reliable operation.
2. Reddit API Setup
Create a new app (script type)
Copy Client ID and Secret to your
.envSet User Agent to something descriptive like
MyBot/1.0
🆓 Free Proxy Setup (Webshare)
For cloud deployments (Render, Railway, AWS, etc.):
Sign up at Webshare: https://www.webshare.io/
Get 10 free proxies (no credit card required)
Find your proxy details in their dashboard
Your webshare proxyurl:
http://username:password@proxy-endpoint:portAdd to your
.env:HTTP_PROXY=your-webshare-proxy-urlandHTTPS_PROXY=your-webshare-proxy-url
3. Notion Database Setup
Create a Notion database with these properties:
Question (Title)
Answer (Text)
Search Query (Text)
Reddit Sources (Text)
Created (Date)
4. Run the Server
Option A: With Docker (Recommended)
# Build the image
docker build -t reddit-qa-notion-mcp .
# Run the server
docker run -p 8000:8000 -v $(pwd)/.env:/app/.env reddit-qa-notion-mcpThe server will be available at http://localhost:8000
Option B: Local Development
# Install dependencies
uv sync
# Run with HTTP transport (recommended)
uv run reddit_qa_to_notion_mcp.py --transport http --port 8000
# Or run with stdio transport
uv run reddit_qa_to_notion_mcp.py --transport stdio5. Configure MCP Client
Add to your MCP client configuration (e.g., .cursor/mcp.json):
{
"mcpServers": {
"reddit-qa-to-notion-server": {
"type": "streamable-http",
"url": "http://localhost:8000/mcp",
"headers": {
"Authorization": "Bearer your-secret-api-key-here"
}
}
}
}Available Tools
search_reddit(query, limit, sort)- Search across all Reddit subredditssearch_posts(subreddits, query, limit, sort)- Search specific subredditsget_top_subreddit_posts(subreddits, limit, time_filter)- Get top posts from subredditssave_reddit_qa_to_notion(question, answer, search_query, reddit_sources)- Save Q&A session to Notion
Example Workflow
Ask a question: "How do I optimize Python performance?"
Search Reddit: Use
search_reddit()to find relevant discussionsGenerate answer: Use Reddit context to inform your LLM response
Save to Notion: Use
save_reddit_qa_to_notion()to create a knowledge base entry
Development
# Install dependencies
uv sync
# Run locally
uv run reddit_qa_to_notion_mcp.py --transport httpThe server will be available at http://localhost:8000
Available Tools
4 toolsget_top_subreddit_postsB
Get top posts from specified subreddits.
Args:
subreddits (str): Subreddit name(s) separated by '+' (e.g., "redditdev+learnpython")
limit (int): Number of posts to retrieve (default: 10)
comment_limit (int): Number of comments to retrieve for each post (default: 5)
time_filter (str): One of: "all", "day", "hour", "month", "week", "year" (default: "week")
Returns:
List[Dict[str, Any]]: List of dictionaries containing post information
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | ||
| subreddits | Yes | ||
| time_filter | No | week | |
| comment_limit | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full behavioral burden. It does disclose that comments are fetched per post via comment_limit and that the return is a list of dicts, but it says nothing about Reddit API auth requirements, rate limits, error behavior, or pagination — significant gaps for a network-backed read tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Google-style docstring with the purpose front-loaded and parameters grouped compactly; no filler sentences. The Returns block is somewhat redundant given an output schema exists, but it is brief.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
An output schema exists so return-value explanation is not required, and all four parameters are at least named. Still, the limit default mismatch and the absence of any guidance on how 'top' is ranked relative to time_filter leave the definition only minimally complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the Args block is doing real work: it documents the '+' separator syntax for subreddits and enumerates the valid time_filter values. It is docked one point because the stated default for limit ('10') conflicts with the schema default of 5, which can mislead an agent.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The first sentence gives a specific verb and resource ('Get top posts from specified subreddits'), so the core action is unambiguous. However, it never distinguishes itself from siblings like search_posts or search_reddit, leaving the agent to infer that this is a ranking-based (rather than query-based) retrieval.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no when-to-use guidance, no when-not-to-use, and no mention of alternatives. An agent cannot tell from the text whether to reach for this tool or search_posts/search_reddit for a given request.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
save_reddit_qa_to_notionB
Save a Q&A session with Reddit context to Notion database.
Args:
question (str): The original question asked
answer (str): The LLM-generated answer
search_query (str): The Reddit search query used
reddit_sources (List[Dict[str, str]]): List of Reddit posts with 'title' and 'url' keys
Returns:
dict: Success/error response
| Name | Required | Description | Default |
|---|---|---|---|
| answer | Yes | ||
| question | Yes | ||
| search_query | Yes | ||
| reddit_sources | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full behavioral burden. It discloses that this is a write operation to a Notion database and that it returns a success/error dict, which is useful. However it omits auth/permission requirements, duplicate handling, and side effects on existing entries.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The purpose sentence is front-loaded, and the Args/Returns block is compact and readable. No wasted prose, though the Args section mostly restates the schema field names.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a four-required-parameter write tool with no annotations and no output schema, the description covers parameters and return shape but leaves out permissions, failure modes, and whether saving is idempotent or creates duplicates. Adequate but with clear gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate, and it does: it names all four parameters with types and even documents the nested structure of reddit_sources ('title' and 'url' keys), which the schema only expresses as a generic string map.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The opening sentence gives a specific verb (Save), resource (a Q&A session with Reddit context) and destination (Notion database), which clearly separates it from the read-oriented siblings search_reddit, search_posts, and get_top_subreddit_posts. It is clear, though it does not explicitly name those siblings.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description states what gets saved but offers no when-to-use guidance, no prerequisites, and no mention of when to prefer the sibling search tools first. Usage is only implied by the tool name and destination.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_postsB
Search for posts in specified subreddits.
Args:
subreddits (str): Subreddit name(s) separated by '+' (e.g., "redditdev+learnpython")
query (str): Search query
limit (int): Number of posts to retrieve (default: 5)
comment_limit (int): Number of comments to retrieve for each post (default: 5)
sort (str): One of: "relevance", "hot", "top", "new", "comments" (default: "relevance")
Returns:
List[Dict[str, Any]]: List of dictionaries containing post information
| Name | Required | Description | Default |
|---|---|---|---|
| sort | No | relevance | |
| limit | No | ||
| query | Yes | ||
| subreddits | Yes | ||
| comment_limit | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full behavioral burden, and it discloses very little: it does not say the operation is read-only, whether results are paginated, whether there are rate limits, or how failures surface. The 'Returns: List[Dict[str, Any]]' line is generic and adds nothing beyond the already-present output schema.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The purpose sentence is front-loaded and the Args/Returns block is compact and scannable. It is slightly over-formatted for such a simple tool, but no sentence is wasted or misleading.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
An output schema exists, so the description need not explain return contents, and the parameter-level detail is thorough. The remaining gap is routing context against sibling search tools, which a search-heavy toolset genuinely needs.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description fully compensates: it documents all five parameters with types, defaults (limit=5, comment_limit=5, sort='relevance'), the subreddit delimiter convention with a concrete example ('redditdev+learnpython'), and the complete set of allowed sort values. This is exactly the information the bare schema omits.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb and resource ('Search for posts in specified subreddits') with scoping to subreddits, which is clear on its own. It does not, however, distinguish itself from siblings like search_reddit or get_top_subreddit_posts, leaving the agent to guess which search tool applies.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no guidance on when to use this tool versus search_reddit or get_top_subreddit_posts, nor on required permissions or prerequisites. The only usage-adjacent detail is the '+' separator convention for subreddits, which is parameter syntax rather than tool selection guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_redditB
Search for posts across all subreddits (site-wide search).
Args:
query (str): Search query
limit (int): Number of posts to retrieve (default: 5)
comment_limit (int): Number of comments to retrieve for each post (default: 5)
sort (str): One of: "relevance", "hot", "top", "new", "comments" (default: "relevance")
Returns:
List[Dict[str, Any]]: List of dictionaries containing post information
| Name | Required | Description | Default |
|---|---|---|---|
| sort | No | relevance | |
| limit | No | ||
| query | Yes | ||
| comment_limit | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It implies a read/search operation and notes that comment_limit controls comments fetched per post, but says nothing about rate limits, auth requirements, pagination, or how results are ordered/truncated.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Front-loaded one-line purpose followed by a compact Args block; every line earns its place. Slightly boilerplate docstring formatting but nothing wasteful.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a 4-parameter search tool with an output schema, the parameter documentation is sufficient and the return value need not be re-explained. It lacks usage context and any behavioral caveats, so it is adequate but not complete for choosing between siblings.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, so the description must compensate and largely does: it documents query, limit, comment_limit, and sort with meanings, defaults, and the full enum list for sort ('relevance','hot','top','new','comments') that the schema omits. Only minor gaps remain (e.g., interaction between limit and comment_limit).
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a clear verb (search) and resource (posts across all subreddits), and the parenthetical 'site-wide search' scopes it against subreddit-specific siblings like get_top_subreddit_posts. However, it never distinguishes itself from the similarly named sibling search_posts, leaving an ambiguity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description says what it does but gives no when-to-use guidance, no prerequisites, and no mention of the sibling search_posts that an agent must choose between. Usage is only implied by the name.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
4 tool updates
v0.1.0- First observed
get_top_subreddit_posts - First observed
save_reddit_qa_to_notion - First observed
search_posts - First observed
search_reddit
TDQS
Scored across 4 tools
The three retrieval tools are mostly distinct: get_top_subreddit_posts fetches top posts, search_posts searches within specified subreddits, and search_reddit searches site-wide. However, search_posts and search_reddit are very similar in name and function, differing only by scope, which could cause occasional misselection.
All names use snake_case with a verb-first pattern, which is largely consistent. The minor inconsistency is that search_posts uses 'posts' while search_reddit uses the platform name, but the overall convention is predictable.
With four tools, the server is well-scoped for its purpose: three Reddit retrieval tools and one Notion save tool. Each tool has a clear role, and the count is neither too thin nor excessive.
The core workflow of fetching Reddit content and saving a Q&A to Notion is covered, but there are notable gaps: no tool to fetch a specific post by ID, no way to list or manage Notion databases, and no update/delete operations. These omissions could limit more advanced use cases.
Maintenance
Related MCP Connectors
Search, organize, and chat with your saved Reddit posts from Claude, Cursor, and any MCP client.
Reddit data for AI agents: posts, comments, subreddits, search. Community + sentiment research.
Read-only Reddit search API for AI agents: posts, comments, comment trees, subreddit rules.
Search Stack Exchange questions, fetch Q&A threads as markdown, look up tag FAQs and user profiles.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceEnables interaction with Notion workspaces through the Notion API, allowing users to search, read, comment on, and create pages and databases using natural language commands.122,532 npmMIT
- AlicenseNot gradedqualityBmaintenanceEnables AI assistants to save and manage question-and-answer pairs within a structured Notion database. It provides tools for database setup, entry creation, and querying existing conversation history.2 npm1MIT
- FlicenseNot gradedqualityDmaintenanceEnables interaction with Notion databases and pages via the Notion API. Allows searching, reading, and writing to Notion through natural language.-
- AlicenseAqualityDmaintenanceEnables semantic search of Reddit posts, subreddit details, and trend discovery through natural language queries.49 npm1MIT