Skip to main content
Glama
danielsimonjr

Substack MCP Server

by danielsimonjr
OverviewSchemaRelated ServersScoreDiscussions
Remote

Substack MCP Server

License: MIT TypeScript

An MCP (Model Context Protocol) server that allows Claude Desktop and Claude Code to interact with your Substack publication. Create posts with cover images, publish notes, manage your content, and more - all through natural conversation with Claude.

Features

  • ✅ Post Management: Create full blog posts with cover images

  • ✅ Notes: Create short-form Substack notes

  • ✅ Profile Access: Get your own profile and other users' profiles

  • ✅ Content Retrieval: Fetch posts, notes, and comments

  • ✅ Image Upload: Native Substack image upload (v2.3.0) - no third-party dependencies

  • ✅ Draft Mode: Create drafts for review before publishing

Version 2.3.0 - What's New

This version replaces Imgur with Substack's native image upload:

  • Native Integration: Direct upload to Substack's CDN (Amazon S3)

  • Data URI Format: Images encoded as base64 data URIs

  • Automatic MIME Detection: Supports PNG, JPG, JPEG, GIF, WEBP

  • Post Association: Images properly linked to posts via postId

  • More Reliable: No third-party API dependencies

Prerequisites

  • Node.js 18+ installed on your system

  • Substack account with publication access

  • Substack API Key (connect.sid cookie value)

Getting Your Substack API Key

The Substack API uses cookie-based authentication:

  1. Login to Substack in your browser

  2. Open Developer Tools (F12 or Right-click → Inspect)

  3. Go to Application/Storage tab → Cookies → https://substack.com

  4. Find the connect.sid cookie and copy its value

  5. This value is your SUBSTACK_API_KEY

⚠️ Important: Keep this cookie value private. Do not commit it to version control.

Cookie Extraction Tools

The tools/ directory contains utility scripts to help extract your Substack cookie:

  • extract-cookie.js - Manual cookie extraction tool

  • extract-cookie-auto.js - Automated cookie extraction

To use these tools, save your cookie value to tools/cookie.txt (this file is git-ignored for security).

Installation

Building the MCP Server

# Clone or download this repository
cd substack-mcp

# Install dependencies
npm install

# Build the TypeScript code
npm run build

For Claude Desktop

  1. Open your Claude Desktop configuration file:

    • Windows: %APPDATA%\Claude\claude_desktop_config.json

    • macOS: ~/Library/Application Support/Claude/claude_desktop_config.json

    • Linux: ~/.config/Claude/claude_desktop_config.json

  2. Add the Substack MCP server configuration:

{
  "mcpServers": {
    "substack": {
      "command": "node",
      "args": ["C:\\mcp-servers\\substack-mcp\\dist\\mcp-server.js"],
      "env": {
        "SUBSTACK_API_KEY": "your-connect-sid-cookie-value-here",
        "SUBSTACK_HOSTNAME": "yoursite.substack.com"
      }
    }
  }
}

  1. Replace your-connect-sid-cookie-value-here with your actual cookie value

  2. Replace yoursite.substack.com with your Substack hostname

  3. Restart Claude Desktop

For Claude Code

Add to your Claude Code MCP configuration or use:

claude mcp add substack-mcp

Available Tools

mcp__substack__create_post

Create a full blog post with optional cover image

Parameters:

  • title (required): Post title

  • body (required): Post content (supports markdown)

  • subtitle (optional): Post subtitle

  • cover_image (optional): Path to cover image file

  • draft (optional): Create as draft (default: true)

Example:

{
  title: "My Amazing Post",
  body: "This is the content of my post...",
  cover_image: "c:/temp/cover-image.png",
  draft: true
}

mcp__substack__create_note

Create a new Substack note (short-form post)

Parameters:

  • text (required): Note content

mcp__substack__create_note_with_link

Create a note with a link attachment

Parameters:

  • text (required): Note content

  • link (required): URL to attach

mcp__substack__get_own_profile

Get your own Substack profile information

Returns: name, slug, handle, bio, follower count, photo URL

mcp__substack__get_profile_posts

Get your recent posts

Parameters:

  • limit (optional): Number of posts to retrieve (default: 10)

mcp__substack__get_post

Get a specific post by ID with full content

Parameters:

  • post_id (required): The post ID

mcp__substack__get_post_comments

Get comments for a specific post

Parameters:

  • post_id (required): The post ID

  • limit (optional): Number of comments (default: 20)

mcp__substack__get_notes

Get your recent notes

Parameters:

  • limit (optional): Number of notes (default: 10)

Usage Examples

With Claude Desktop/Code

Once configured, you can have natural conversations with Claude:

"Create a new blog post titled 'Why I Love Programming' with this content..."

"Create a draft post with the article from article.md and use cover.png as the cover image"

"Get my recent posts from the last week"

"Create a note saying 'New post just published!'"

Claude will automatically use the appropriate MCP tools to fulfill your requests.

Environment Variables

  • SUBSTACK_API_KEY (required): Your connect.sid cookie value

  • SUBSTACK_HOSTNAME (required): Your Substack hostname (e.g., "yourname.substack.com")

Workflow Example

Here's a typical workflow for creating a post with cover image:

  1. Write your article in markdown format

  2. Create or generate a cover image

  3. Tell Claude: "Create a draft post with article.md and cover.png"

  4. Claude will:

    • Read the markdown file

    • Upload the cover image to Substack's CDN

    • Create the draft post with both

    • Return the draft URL for review

Documentation

  • CLAUDE.md - Development guidelines for Claude Code

Troubleshooting

"SUBSTACK_API_KEY environment variable is required"

Make sure you've added the SUBSTACK_API_KEY to the env section of your MCP configuration.

"Failed to connect"

  1. Verify your connect.sid cookie value is correct and hasn't expired

  2. Check that you're logged into Substack in your browser

  3. Try getting a fresh cookie value by logging out and back in

MCP server not appearing in Claude Desktop

  1. Check that the path to mcp-server.js is correct

  2. Ensure Node.js 18+ is installed: node --version

  3. Run npm run build to compile the TypeScript

  4. Restart Claude Desktop after configuration changes

Image upload fails

  1. Ensure the image file exists and is readable

  2. Check that the file format is supported (PNG, JPG, JPEG, GIF, WEBP)

  3. Verify your Substack API key is valid

Development

To extend the MCP server:

  1. Edit src/mcp-server.ts to add new tools

  2. Run npm run build to compile TypeScript

  3. Restart Claude Desktop/Code to load changes

Testing

npm test              # Run all tests
npm run test:unit     # Unit tests only
npm run lint          # Check code style
npm run format        # Format code

Security Notes

  • Never commit your connect.sid cookie value to version control

  • Store your API key securely using environment variables

  • The cookie value gives full access to your Substack account

  • Regularly refresh your cookie value for security

Version History

  • v2.3.0 (Nov 2025): Native Substack image upload, replaces Imgur

  • v2.2.0: Added Imgur-based cover image upload

  • v2.1.0: Added create_post tool with ProseMirror support

  • v2.0.0: Initial MCP server implementation

License

MIT - See LICENSE file for details

Credits

Built on top of the substack-api TypeScript client.

MCP server and image upload implementation by Daniel Simon Jr.

Available Tools

8 tools
create_noteC

Create a new Substack note (short-form post)

ParametersJSON Schema
NameRequiredDescriptionDefault
textYesThe text content of the note

TDQS

C2.9/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states this is a creation operation but doesn't mention permissions needed, whether it's idempotent, rate limits, or what happens on success/failure. For a mutation tool with zero annotation coverage, this is a significant gap.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence with zero waste. It's appropriately sized for a simple creation tool and front-loads the essential information.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a mutation tool with no annotations and no output schema, the description is inadequate. It doesn't explain what happens after creation (e.g., returns a note ID), error conditions, or how this differs behaviorally from similar tools. Given the complexity and lack of structured data, more context is needed.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema already documents the single 'text' parameter. The description adds no additional parameter semantics beyond what's in the schema, such as format constraints or examples. Baseline 3 is appropriate when the schema does the heavy lifting.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the verb 'Create' and resource 'Substack note (short-form post)', making the purpose unambiguous. It distinguishes from siblings like 'create_post' by specifying 'note' versus 'post', though it doesn't explicitly contrast with 'create_note_with_link' beyond the name difference.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives like 'create_post' or 'create_note_with_link'. It doesn't mention prerequisites, context, or exclusions, leaving the agent to infer usage from tool names alone.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

create_postC

Create and publish a full Substack blog post with optional cover image

ParametersJSON Schema
NameRequiredDescriptionDefault
titleYesThe title of the post
subtitleNoThe subtitle of the post (optional)
bodyYesThe body content of the post (HTML or markdown)
cover_imageNoPath to cover image file (optional, will be uploaded to Substack)
draftNoSave as draft instead of publishing (default: true)

TDQS

C2.9/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions 'publish' and 'draft' options, but fails to cover critical aspects like authentication requirements, rate limits, error handling, or whether the operation is idempotent. This leaves significant gaps for a mutation tool.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence that front-loads the core action ('Create and publish') and includes key optional features. There is no wasted verbiage, making it highly concise and well-structured.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the complexity of a mutation tool with no annotations and no output schema, the description is insufficient. It lacks details on return values, error conditions, and behavioral traits like side effects or permissions, leaving the agent with incomplete context for safe and effective use.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has 100% description coverage, so parameters are well-documented there. The description adds minimal value by mentioning 'optional cover image', which aligns with the schema but doesn't provide additional semantics beyond what's already covered. This meets the baseline for high schema coverage.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('Create and publish') and resource ('a full Substack blog post'), making the purpose evident. However, it doesn't explicitly differentiate from sibling tools like 'create_note' or 'create_note_with_link', which likely create different types of content, so it's not a perfect 5.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives like 'create_note' or 'create_note_with_link', nor does it mention prerequisites such as authentication or context. It only hints at optional features like cover images, but lacks explicit usage context.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_notesC

Get your recent Substack notes (short-form posts)

ParametersJSON Schema
NameRequiredDescriptionDefault
limitNoNumber of notes to retrieve (default: 10)

TDQS

C2.9/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool retrieves 'recent' notes, implying recency-based ordering, but doesn't specify authentication needs, rate limits, pagination, or what 'recent' means (e.g., time frame). This leaves gaps for a read operation that could have hidden constraints.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence that front-loads the core purpose. The parenthetical 'short-form posts' adds useful clarification without redundancy. It could be slightly more structured by explicitly contrasting with siblings, but it's appropriately sized with zero waste.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's low complexity (1 optional parameter, no output schema, no annotations), the description is minimally adequate. It covers the basic purpose but lacks details on behavioral traits like ordering or authentication. With no output schema, it doesn't explain return values, which is a gap, but the simplicity of the tool keeps it from being severely incomplete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has 100% description coverage, with the 'limit' parameter clearly documented. The description adds no additional parameter semantics beyond implying 'recent' notes, which doesn't directly map to a documented parameter. Since schema coverage is high, the baseline score of 3 is appropriate, as the description doesn't compensate but doesn't need to heavily.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('Get') and resource ('your recent Substack notes'), with the parenthetical clarifying that notes are short-form posts. It distinguishes from siblings like get_post (for long-form posts) and get_profile_posts (for others' posts), though not explicitly. However, it doesn't fully differentiate from all siblings like get_own_profile, which might also return user data.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention siblings like get_post (for specific posts) or get_profile_posts (for posts from other users), nor does it specify prerequisites or contexts for retrieving notes versus other content types.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_own_profileB

Get your own Substack profile information

ParametersJSON Schema
NameRequiredDescriptionDefault

No parameters

TDQS

B3.2/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. It implies a read operation ('Get'), but doesn't specify authentication requirements, rate limits, error conditions, or what data is returned (e.g., public vs. private fields). For a tool with zero annotation coverage, this leaves significant gaps in understanding its behavior.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence that front-loads the core purpose without any wasted words. It's appropriately sized for a simple, parameterless tool, making it easy for an agent to parse and understand quickly.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's simplicity (0 parameters, no output schema, no annotations), the description is minimally adequate. It states what the tool does but lacks details on return values, authentication, or error handling. Without an output schema, the agent must infer the response structure, making this description incomplete for full contextual understanding.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool has 0 parameters, and the schema description coverage is 100% (since there are no parameters to describe). In such cases, the baseline score is 4, as there's no need for the description to compensate for missing parameter documentation. The description doesn't add parameter details, but none are required.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the verb ('Get') and resource ('your own Substack profile information'), making the purpose immediately understandable. It distinguishes itself from sibling tools like 'get_profile_posts' by focusing on profile metadata rather than content. However, it doesn't explicitly contrast with all siblings, keeping it at a 4 rather than a perfect 5.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives like 'get_profile_posts' or other profile-related operations. It lacks any mention of prerequisites, context, or exclusions, leaving the agent to infer usage based on the tool name alone. This minimal guidance scores a 2.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_postB

Get a specific Substack post by ID with full content

ParametersJSON Schema
NameRequiredDescriptionDefault
post_idYesThe ID of the post to retrieve

TDQS

B3.4/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries full burden. It states it retrieves a post with full content, but doesn't disclose behavioral traits like authentication requirements, rate limits, error conditions, or whether it's a read-only operation. The description is minimal and lacks necessary context for safe invocation.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence with zero waste. It's front-loaded with the core purpose and includes essential scope details. Every word earns its place.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given no annotations and no output schema, the description is incomplete for a tool that retrieves data. It doesn't explain what 'full content' includes, the return format, error handling, or authentication needs. For a read operation with zero structured coverage, this leaves significant gaps.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema already documents the post_id parameter. The description adds no additional meaning beyond what the schema provides (e.g., format examples, constraints, or context about valid IDs). Baseline 3 is appropriate when schema does the heavy lifting.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the specific action ('Get'), resource ('Substack post'), and scope ('by ID with full content'). It distinguishes from siblings like get_notes (list) and get_post_comments (different resource) by specifying retrieval of a single post with full content.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage when needing a specific post by ID with full content, but doesn't explicitly state when to use alternatives like get_profile_posts (for lists) or get_post_comments (for comments). No exclusions or prerequisites are mentioned.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_post_commentsB

Get comments for a specific Substack post

ParametersJSON Schema
NameRequiredDescriptionDefault
post_idYesThe ID of the post
limitNoNumber of comments to retrieve (default: 20)

TDQS

B3.1/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states what the tool does but lacks critical details like whether it's read-only, requires authentication, has rate limits, or how comments are returned (e.g., pagination, sorting). This is a significant gap for a tool with potential behavioral implications.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence that directly states the tool's purpose with zero waste. It's appropriately sized and front-loaded, making it easy for an agent to parse quickly.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's low complexity (2 parameters, no output schema, no annotations), the description is minimally adequate. It covers the basic purpose but lacks behavioral context and usage guidelines, which are important for an agent to operate effectively in this domain with sibling tools.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema description coverage is 100%, so the input schema already documents both parameters ('post_id' and 'limit') with clear descriptions. The description adds no additional meaning beyond what's in the schema, such as format details or usage examples, but this is acceptable given the high schema coverage.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose with a specific verb ('Get') and resource ('comments for a specific Substack post'), making it immediately understandable. However, it doesn't differentiate from sibling tools like 'get_post' or 'get_notes', which might retrieve related content, so it doesn't reach the highest score.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools like 'get_post' or 'get_notes', nor does it specify prerequisites or exclusions, leaving the agent to infer usage from context alone.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_profile_postsC

Get your recent Substack posts

ParametersJSON Schema
NameRequiredDescriptionDefault
limitNoNumber of posts to retrieve (default: 10)

TDQS

C2.9/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool retrieves posts but doesn't mention whether it's read-only, requires authentication, has rate limits, or what the return format looks like. This leaves significant gaps in understanding the tool's behavior and safety profile.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence that directly states the tool's purpose without any wasted words. It's appropriately sized and front-loaded, making it easy to parse quickly, which is ideal for conciseness.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the lack of annotations and output schema, the description is incomplete. It doesn't address key contextual elements like authentication requirements, return format, or error handling. For a tool that retrieves data, more information is needed to ensure the agent can use it effectively and safely.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has 100% description coverage, with the 'limit' parameter clearly documented. The description doesn't add any additional meaning beyond the schema, such as explaining what 'recent' means or default behavior details. Since the schema does the heavy lifting, the baseline score of 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('Get') and resource ('your recent Substack posts'), making the tool's purpose understandable. However, it doesn't differentiate from sibling tools like 'get_post' or 'get_notes', which appear to retrieve similar content, so it doesn't fully distinguish itself from alternatives.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives like 'get_post' or 'get_notes'. It lacks context about prerequisites, such as authentication needs, and doesn't specify any exclusions or when-not-to-use scenarios, leaving the agent with minimal usage direction.

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. Dates show when Glama detected each change.

  1. 8 tool updatesv1.0.0
    • First observedcreate_note
    • First observedcreate_note_with_link
    • First observedcreate_post
    • First observedget_notes
    • First observedget_own_profile
    • First observedget_post
    • First observedget_post_comments
    • First observedget_profile_posts
Install Server
RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

B3.4/5.0
Disambiguation4/5

Most tools are clearly distinct, focusing on specific resources like notes, posts, profiles, and comments. However, there is some potential overlap between 'create_note' and 'create_note_with_link', as the latter could be seen as a variant of the former, which might cause minor confusion in selection.

Naming Consistency5/5

All tool names follow a consistent verb_noun pattern using snake_case, such as 'create_note', 'get_notes', and 'get_post_comments'. This predictability makes it easy for agents to understand and use the tool set without naming confusion.

Tool Count5/5

With 8 tools, the server is well-scoped for managing Substack content, covering creation and retrieval of notes, posts, profiles, and comments. This count is appropriate, providing essential operations without being overwhelming or too sparse for the domain.

Completeness4/5

The tool set offers good coverage for core Substack operations, including CRUD-like actions for notes and posts, and retrieval of profiles and comments. A minor gap is the lack of update or delete tools for posts and notes, which agents might need to work around, but the surface supports key workflows effectively.

Resources

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/danielsimonjr/substack-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server