# Hashnode MCP

> Hashnode MCP lets you manage your entire blog from within your AI agent conversation. You can fetch user profiles, read full articles, list posts from any publication feed, and publish or update content without leaving your writing environment.

## Overview
- **Category:** productivity
- **Price:** Free
- **Tags:** blogging, technical-writing, content-creation, developer-community, graphql, publishing

## Description

Got a technical article idea? Instead of opening the Hashnode dashboard, drafting in one tool, then copying everything over to another editor, you just tell your AI agent what you want. This connector handles it all. You can ask for details about any user profile using their handle, or list out recent posts from an entire publication feed before writing a follow-up piece. Need to publish? You write the Markdown right in the chat, and this MCP publishes the post directly. If you spot an old article that needs tweaking, you don't need to jump through three sets of admin menus; you just tell your agent to update it. It’s all about keeping the focus on writing, not context switching. Connect Hashnode via Vinkius and keep your publishing workflow inside your preferred AI client.

## Tools

### create_post
Publishes a brand new blog post with Markdown content directly to your Hashnode site.

### get_post
Fetches the full text and metadata of a single article using its slug.

### get_publication_posts
Lists recent articles published by an entire blog publication feed.

### get_user
Retrieves profile details for a specific Hashnode user using their unique handle.

### update_post
Modifies the title or body of an existing published article on your Hashnode account.

## Prompt Examples

**Prompt:** 
```
Get details for Hashnode user 'johndoe'.
```

**Response:** 
```
I've retrieved the profile for 'johndoe'. They are a Technical Writer with 1,200 followers and their blog is located at johndoe.hashnode.dev.
```

**Prompt:** 
```
List all posts from the publication 'blog.hashnode.com'.
```

**Response:** 
```
I found 10 recent posts on 'blog.hashnode.com'. The latest titles include 'Announcing New Features' and 'Markdown Guide for Developers'. Would you like to read the content of any of these?
```

**Prompt:** 
```
Create a new post in publication '642f...' titled 'My MCP Guide' with content '# Introduction...'.
```

**Response:** 
```
Successfully published your post 'My MCP Guide'! You can view it at your publication URL. The post ID is 65a2b...
```

## Capabilities

### Retrieve User Profiles
Fetch specific details and follower counts for any user on the Hashnode platform.

### List Publication Feeds
Get a list of recent posts from an entire blog publication, using only its domain name.

### Read Full Post Content
Fetch the complete text and metadata for any single post by providing its unique slug.

### Draft and Publish New Posts
Write a new blog article in Markdown format, and then publish it directly to your Hashnode site.

### Revise Existing Content
Update the title or body content of an already published article without logging into the admin panel.

## Use Cases

### Need to reference a contributor's stats?
A technical writer needs to cite a specific developer. Instead of searching Hashnode manually, they tell their agent to use `get_user` for that developer’s handle. The agent returns the profile details instantly, letting the writer include accurate follower counts in the draft.

### The content feed is stale.
A content manager needs an overview of what's been published recently on a major site. They instruct their agent to run `get_publication_posts` for that domain, getting a list of titles and dates in minutes, not hours.

### I just finished the draft and it needs to go live.
The developer writes the final Markdown section. They prompt their agent: 'Publish this as a new post.' The agent executes `create_post`, and the article is immediately available on Hashnode.

### I need to correct a typo in an old guide.
A developer realizes they messed up a key detail in a published piece. They ask their agent to run `update_post` on the specific article slug, providing the corrected text. The fix goes live instantly.

## Benefits

- Drafting is faster. You can write new articles using the `create_post` tool, bypassing the entire web interface just to hit 'submit.'
- Stop context switching. If you need to revise an old article, simply ask to run `update_post`; your agent handles fetching and modifying the content behind the scenes.
- Keep track of who's writing what. Use `get_user` to quickly pull profile details on any contributor so you can reference them in your current draft.
- Monitor entire sites at a glance. The `get_publication_posts` tool lets you see all recent activity from one feed without clicking through dozens of article pages.
- Get the full story. When you need to read an existing piece, `get_post` retrieves the complete content and metadata in one call.

## How It Works

The bottom line is that your AI agent handles the API calls and content deployment for you.

1. Subscribe to this MCP and provide your Hashnode Personal Access Token.
2. Connect your agent client (like Claude or Cursor) through Vinkius.
3. Tell your agent what you need done—whether it’s fetching user data, listing posts, or publishing a new draft.

## Frequently Asked Questions

**How do I use get_user to find a person's profile?**
Just ask your agent for the user’s handle. The tool uses that unique identifier to fetch their details instantly, saving you from having to guess their full name or blog URL.

**Can I use get_publication_posts to see a feed?**
Yes. You provide the domain of the publication feed, and the MCP runs `get_publication_posts`. It returns a list of recent articles so you know what content is already out there.

**What's the difference between create_post and update_post?**
Think of it this way: `create_post` makes something brand new. `update_post` only modifies a piece that already exists, so you need to know its slug or ID.

**Does get_post give me the whole article?**
Yes, it fetches the entire post content and all associated metadata for a specific article when you provide the correct slug. You don't get partial data; you get everything.

**What do I need to set up my connection before running a tool like `create_post`?**
You must provide your Hashnode Personal Access Token when subscribing this MCP. This token authorizes your AI client to write and modify content on your behalf.

**When I use `get_post`, does the output include metadata beyond just the article text?**
Yes, `get_post` returns structured data that includes not only the full content but also important metadata like publication details and creation slugs.

**If I run `update_post` on a post ID that doesn't exist, how does the MCP handle it?**
The MCP catches API errors. If you reference an invalid slug or non-existent ID, your agent will report a clear error message instead of failing silently.

**Is the data retrieved by `get_user` restricted to public information only?**
The MCP pulls standard profile details available through the Hashnode API. It provides publicly visible metrics and user handles, but it won't access private account data.

**Can I fetch profile details for any Hashnode user?**
Yes! Use the `get_user` tool with the specific username handle. The agent will return their profile information, bio, and social links.

**Does the publishing tool support Markdown formatting?**
Absolutely. Both `create_post` and `update_post` accept `contentMarkdown`, allowing you to publish rich technical content with code blocks, headers, and links.

**How do I list posts from a specific blog domain?**
Use the `get_publication_posts` tool and provide the `host` domain (e.g., 'engineering.hashnode.dev' or your custom domain). It will return a list of recent posts from that publication.