postfast-mcp
Manage and schedule social media posts across multiple platforms via the PostFast API.
List social accounts – Retrieve all connected social media accounts
List posts – Browse posts with filters for platform, status (DRAFT, SCHEDULED, PUBLISHED, FAILED), and date range
Create & schedule posts – Batch create up to 15 posts with platform-specific controls (e.g., X community ID, Instagram publish type, YouTube privacy, Pinterest board selection)
Delete posts – Remove a post by ID
Upload media – Upload images/videos (JPEG, PNG, GIF, WebP, MP4, WebM, MOV) directly or via signed URLs (up to 8 at a time)
Get post analytics – Fetch performance metrics (impressions, reach, likes, comments, shares) for Instagram, Facebook, TikTok, Threads, YouTube, and LinkedIn
List Pinterest boards – Retrieve boards for a connected Pinterest account
List YouTube playlists – Retrieve playlists for a connected YouTube account
List Google Business Profile locations – Get GBP locations for a connected account
Generate connect link – Create a shareable link for clients to connect their social accounts, with optional email delivery and configurable expiry
Supported platforms: Facebook, Instagram, X (Twitter), TikTok, LinkedIn, YouTube, BlueSky, Threads, Pinterest, Telegram, Google Business Profile
Provides tools for scheduling and managing posts on BlueSky, including account listing, media uploads, and batch post creation.
Provides tools for scheduling posts, reels, and stories with controls for content type, privacy settings, comments, and collaborators. Supports retrieval of post analytics and performance metrics.
Provides tools for scheduling posts, stories, and reels with options for publish type (timeline/story/reel), grid posting, and collaborator tagging. Supports retrieval of post analytics and performance metrics.
Provides tools for scheduling pins to specific boards with support for link attachments and required board selection.
Provides tools for scheduling and managing posts on Telegram with media upload capabilities.
Provides tools for scheduling and managing posts on Threads with support for retrieving post analytics and performance metrics.
Provides tools for scheduling videos with privacy controls, comment/duet/stitch permissions, music auto-add, brand content flags, and draft status. Supports retrieval of post analytics and performance metrics.
Provides tools for scheduling videos and Shorts with title, tags, category ID, privacy settings, playlist assignment, and thumbnail management. Supports retrieval of post analytics and performance metrics.
PostFast MCP Server
MCP server for the PostFast API — schedule and manage social media posts via AI tools like Claude, Cursor, VS Code, and more.
Hosted connector (no install)
Prefer not to run anything locally? Connect to the hosted endpoint and authenticate with OAuth — no npx, no API key to manage:
https://mcp.postfa.st/mcpAdd it as a remote/streamable-HTTP MCP server in any client that supports OAuth (e.g. ChatGPT, Claude). You'll be prompted to sign in to PostFast and authorize access on first use.
Want to run the server yourself instead? Use the npx + API-key setup in Quick Start below.
Related MCP server: so-easy-mcp
Quick Start
1. Get your API key
Log in to PostFast, go to API in the sidebar, and generate a key.
2. Install
Choose your preferred method:
Claude Desktop (recommended)
Download the extension from the Claude Desktop extension directory or install manually:
Add to
claude_desktop_config.json:
{
"mcpServers": {
"postfast": {
"command": "npx",
"args": ["-y", "postfast-mcp"],
"env": {
"POSTFAST_API_KEY": "your-api-key-here"
}
}
}
}Restart Claude Desktop.
Claude Code
Via plugin (pending marketplace approval):
/plugin install postfast@claude-plugins-officialAfter installing, set your API key — pick one of these:
# Option A: Add to your shell profile (~/.zshrc or ~/.bashrc)
export POSTFAST_API_KEY="your-api-key-here"
# Option B: Add to ~/.claude/settings.local.json
# { "env": { "POSTFAST_API_KEY": "your-api-key-here" } }Then restart Claude Code.
Via manual config:
Add to your project's .mcp.json or ~/.claude/.mcp.json (global):
{
"mcpServers": {
"postfast": {
"type": "stdio",
"command": "npx",
"args": ["-y", "postfast-mcp"],
"env": {
"POSTFAST_API_KEY": "your-api-key-here"
}
}
}
}Cursor / VS Code / Windsurf / Other MCP clients
Add to your MCP config (.mcp.json, mcp.json, or the tool's settings UI):
{
"mcpServers": {
"postfast": {
"type": "stdio",
"command": "npx",
"args": ["-y", "postfast-mcp"],
"env": {
"POSTFAST_API_KEY": "your-api-key-here"
}
}
}
}3. Use it
Ask your AI assistant things like:
"List my connected social accounts"
"Schedule a post to Instagram for tomorrow at 9am"
"Show me all scheduled posts for this week"
"Upload this image and create a LinkedIn post with it"
"Create a Facebook reel with this video"
"Show me analytics for my Instagram posts this month"
Available Tools
Tool | Description |
| List connected social media accounts (each with |
| List posts with filters (specific IDs, platform, status, date range) |
| Create and schedule posts (batch, up to 15) |
| Delete a post from PostFast by ID (does not remove an already-published post from the platform) |
| Upload a local file and get a media key (handles the full flow) |
| Get signed URLs to upload media files |
| Get Pinterest boards for an account |
| Get YouTube playlists for an account |
| Get Google Business Profile locations for an account |
| Find a place to tag posts (the |
| Generate a link for clients to connect accounts — optionally scoped to specific platforms, with a |
| Fetch published posts with performance metrics — Instagram, Facebook, TikTok, Threads, YouTube, LinkedIn (company pages), Pinterest (Business accounts) |
| Daily follower-count history for an account (current count + |
| Trending pre-cleared Commercial Music Library tracks for a TikTok account (attach via |
Social Inbox (comments)
Comments on your posts — TikTok, Instagram, Facebook Pages, and Threads — in one inbox (an account's inboxCapable flag says what is live today). Comments only (no direct messages), from connect onward (no history backfill). Reply capability is always server-computed per conversation (canReply, maxReplyLength, windowState, disabledReason) — render from those fields, never platform assumptions.
Tool | Description |
| List comment conversations (filters: platforms, accounts, statuses, unread-only, assignee) |
| Fetch one conversation with its reply-capability fields |
| List a conversation's comments and replies (with |
| Total unread comment count across the workspace |
| Reply publicly under a specific comment |
| Instagram only: one private reply per comment, within 7 days |
| HIDE / UNHIDE / DELETE a comment on the platform (DELETE cannot be undone) |
| Zero a conversation's unread count |
| Triage: OPEN / SNOOZED / CLOSED |
| Assign a conversation to a workspace member (or unassign) |
Supported Platforms
Facebook, Instagram, X (Twitter), TikTok, LinkedIn, YouTube, BlueSky, Threads, Pinterest, Telegram, Google Business Profile
Platform-Specific Controls
When creating posts, you can pass platform-specific settings via the controls parameter:
Platform | Controls |
X (Twitter) |
|
| |
| |
TikTok |
|
YouTube |
|
| |
| |
Google Business Profile |
|
Media Upload
The upload_media tool handles the full flow in a single call:
Detects content type from file extension
Gets a signed upload URL from PostFast
Uploads the file
Returns a
keyandtypeready to use increate_posts
Supported formats: JPEG, PNG, GIF, WebP, MP4, WebM, MOV
You can also use get_upload_urls directly if you need more control over the upload process.
Environment Variables
Variable | Required | Description |
| Yes | Your workspace API key |
| No | API base URL (default: |
Testing
Verify everything works with the MCP Inspector:
POSTFAST_API_KEY=your-key npx @modelcontextprotocol/inspector npx postfast-mcpAPI Docs
Full REST API documentation: postfa.st/docs
Development
npm install
npm run build
node dist/stdio/index.jsTools are authored once in src/core (the catalog — schemas, descriptions,
annotations, per-binding availability) and exposed to consumers as
postfast-mcp/core; src/stdio binds the catalog to the public REST API.
Releases: PRs add a .changeset/*.md; npm run version folds them into the
bump + changelog, and pushing the vX.Y.Z tag publishes npm + MCP Registry +
the MCPB release from CI (OIDC — no tokens anywhere).
Badges
License
MIT
Available Tools
11 toolscreate_postsB
Create and schedule social media posts. Supports batch creation (up to 15 posts). Each post targets a specific social account.
| Name | Required | Description | Default |
|---|---|---|---|
| posts | Yes | Array of posts to create | |
| status | No | Post status. SCHEDULED requires scheduledAt on all posts. | SCHEDULED |
| approvalStatus | No | Approval workflow status | APPROVED |
| controls | Yes | Platform-specific controls (shared across all posts in the batch) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must fully disclose behavior. It only says 'create and schedule' but omits side effects, permission requirements, rate limits, or what happens on failure. The mutation nature is implied but not detailed.
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?
Two sentences, no redundancy, front-loaded with key information. Every word earns its place.
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?
Given the tool's complexity (many nested controls, no output schema), the description is insufficient. It fails to explain workflow dependencies (e.g., media upload via get_upload_urls), the role of status/approval, or the return value. Much needed context is missing.
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 100%, so the schema documents all parameters. The description adds no meaningful value beyond the schema; it restates batch limits already present. Thus baseline 3 is appropriate.
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 clearly states the tool creates and schedules social media posts, specifies batch support (up to 15), and notes each post targets a specific account. It effectively distinguishes from listing and deletion 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 implies usage for creating posts but does not explicitly state when to use versus alternatives, nor provides exclusionary hints. No guidance on prerequisites like needing to upload media first.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
delete_postB
Delete a social media post by ID
| Name | Required | Description | Default |
|---|---|---|---|
| id | Yes | Post ID to delete |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description explicitly states 'Delete', indicating a destructive action. However, no additional behavioral details are provided, such as whether the deletion is permanent, reversible, or requires specific permissions. As annotations are absent, this is minimal but not misleading.
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?
Single sentence, no unnecessary words. However, it could be slightly expanded to include key behavioral notes without sacrificing conciseness.
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 simple delete operation with one parameter, the description covers the basic purpose. However, it lacks information about what happens after deletion (e.g., return value, success confirmation). The absence of output schema increases the need for such context.
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?
The only parameter 'id' is fully described in the schema (100% coverage). The description adds no additional meaning beyond the schema, so baseline of 3 is appropriate.
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?
Clearly states the action (delete) and resource (social media post by ID). Specific verb and resource but does not differentiate from siblings; however, no other delete tool is present, so it's clear.
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?
No guidance on when to use this tool compared to alternatives. The description does not mention prerequisites, confirmations, or when not to use it (e.g., if the user likely wants to archive instead).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
generate_connect_linkB
Generate a shareable link for external clients to connect their social accounts to the workspace
| Name | Required | Description | Default |
|---|---|---|---|
| expiryDays | No | Link expiry in days (1-30, default 7) | |
| sendEmail | No | Send the link via email | |
| No | Recipient email (required if sendEmail is true) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must disclose behavioral traits. It only states the tool generates a link but does not mention whether this action is destructive (e.g., invalidates previous links), requires specific permissions, or has rate limits. The safety profile is unclear.
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 description is a single sentence with no extraneous words. It is front-loaded with the purpose and immediately understandable. Every part contributes meaning.
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?
Given no annotations and no output schema, the description is adequate for a simple link generation tool. However, it lacks information about the generated link (e.g., expiration, access scope) and usage context. The agent might need more detail to handle edge cases.
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 100%, so the description does not add much beyond what the schema already provides. The description could have explained the relationship between sendEmail and email, but the schema already indicates email is required when sendEmail is true. The baseline of 3 is appropriate.
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 clearly states the action 'Generate', the output 'shareable link', and the purpose 'for external clients to connect their social accounts to the workspace'. It is distinct from sibling tools like create_posts or list_accounts, which handle different resources.
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 provides no guidance on when to use this tool versus alternatives. It does not mention prerequisites, typical scenarios, or cases where other tools might be more appropriate. Sibling tools like list_accounts or create_posts have different purposes, but the description does not help the agent decide.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_post_analyticsA
Fetch published posts with their latest performance metrics (impressions, reach, likes, comments, shares). Only returns published posts that have a platform post ID. LinkedIn personal accounts are excluded. Supported: Instagram, Facebook, TikTok, Threads, YouTube, LinkedIn (company pages), Pinterest (Business accounts). Pinterest extras include pin_clicks, outbound_clicks, saves_90d, save_rate_90d (saves are 90-day rolling because Pinterest API does not expose lifetime totals); video pins additionally surface mrc_views, views_10s, avg_watch_time, v50_watch_time, video_starts, quartile_95_views.
| Name | Required | Description | Default |
|---|---|---|---|
| startDate | Yes | Start of date range (ISO 8601, e.g. 2026-01-01T00:00:00.000Z) | |
| endDate | Yes | End of date range (ISO 8601, e.g. 2026-01-31T23:59:59.999Z) | |
| platforms | No | Filter by platforms | |
| socialMediaIds | No | Filter by specific social media account IDs |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden. It discloses that it returns only published posts with platform post IDs and excludes certain accounts. It details Pinterest-specific metrics and rolling window behavior. No contradictions are present, though rate limits or authentication are not mentioned.
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 description is efficiently front-loaded with the main purpose and essential details. It is structured with clear sections for supported platforms and Pinterest extras, every sentence adds value without redundancy.
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?
Given the complexity (multiple platforms, varied metrics), the description is thorough. It explains what metrics are returned for each platform, highlights special cases (Pinterest 90-day rolling), and specifies exclusion rules. No output schema exists, so the description compensates well.
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?
Input schema has 100% coverage, so the baseline is 3. The description adds value by explaining the meaning of return metrics and how platforms affect results, which indirectly informs parameter usage. It provides context beyond the schema descriptions.
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 clearly identifies the tool's function: fetching published posts with performance metrics. It specifies supported platforms and exclusions, differentiating it from sibling tools like list_posts which only list posts without analytics.
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 explicitly states constraints (only published posts with platform post ID, excludes LinkedIn personal accounts) and lists supported platforms. Although it doesn't directly compare to alternatives, the context is sufficient for an agent to decide when to use this tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_upload_urlsA
Get signed upload URLs for media files. Upload your file to the returned URL via PUT, then use the key in create_posts mediaItems.
| Name | Required | Description | Default |
|---|---|---|---|
| contentType | Yes | MIME type of the file. Supported: image/jpeg, image/png, image/gif, image/webp, video/mp4, video/webm, video/quicktime | |
| count | No | Number of upload URLs (1-8 for images, 1 for videos) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden. It explains that URLs are signed, that you upload via PUT, and that the key is used in create_posts. However, it does not disclose URL expiration, file size limits, or authentication requirements, leaving some behavioral gaps.
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?
Two sentences, zero fluff. Every word adds value—purpose, upload method, and integration with create_posts are all included efficiently.
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 simple tool with 2 parameters and no output schema, the description covers purpose and workflow but lacks details about the return format (e.g., structure of URLs, keys) and potential failure modes (e.g., rate limits, expiration). At 100% schema coverage and no output schema, additional context on return values would improve completeness.
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 100% (both contentType and count are described). The description adds no new semantic details about parameters beyond what the schema provides, though it does add workflow context (key usage). Baseline 3 is appropriate.
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 clearly states the verb 'Get' and the resource 'signed upload URLs for media files', making the purpose immediately obvious. It also mentions the subsequent use of the key in create_posts, which adds context.
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 implies a workflow (upload via PUT, then use key in create_posts) but does not explicitly state when to use or when not to use this tool compared to siblings like upload_media. No alternatives or exclusions are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_accountsA
List all social media accounts connected to the workspace
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description accurately states a read-only operation. It does not detail authentication needs or rate limits, but for a simple list tool, the transparency is adequate.
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 description is a single, front-loaded sentence with no extraneous words. Every part is necessary and clear.
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?
The description fails to specify the return format or fields of the listed accounts, and there is no output schema. Information on pagination or sorting is also absent, leaving the agent uncertain about the tool's output.
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?
There are no parameters, so schema coverage is 100%. The description adds no parameter info, which is appropriate since none exist. Baseline 4 for zero-parameter tools.
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 clearly states the tool lists all social media accounts connected to the workspace, using a specific verb and resource. It is distinct from sibling tools like list_posts or list_gbp_locations.
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?
No explicit when-to-use or when-not-to-use guidance is provided. The description implies the tool is for retrieving all accounts, but there is no mention of alternatives or prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_gbp_locationsA
List Google Business Profile locations for a connected GBP account
| Name | Required | Description | Default |
|---|---|---|---|
| socialMediaId | Yes | GBP account ID (from list_accounts) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description only indicates a read operation ('List'), but provides no details about pagination, rate limits, or output format.
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?
A single, front-loaded sentence with no wasted words; highly efficient.
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 simple list tool, the description is adequate but omits the prerequisite of needing a connected account from list_accounts, which is important for correct usage.
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?
The input schema is fully described (100% coverage), so the description adds no extra meaning beyond what the parameter description already provides.
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 explicitly states the action 'List' and the resource 'Google Business Profile locations', clearly distinguishing it from sibling tools like list_accounts or list_pinterest_boards.
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?
No guidance on when to use this tool vs alternatives; it does not mention that a preceding call to list_accounts is needed to obtain the socialMediaId parameter.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_pinterest_boardsA
List Pinterest boards for a connected Pinterest account
| Name | Required | Description | Default |
|---|---|---|---|
| socialMediaId | Yes | Pinterest account ID (from list_accounts) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, and the description does not disclose behavioral traits such as read-only status, rate limits, or authentication requirements. The description carries the full burden and fails to add such context.
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 description is a single, efficient sentence with no unnecessary words, achieving high conciseness.
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 simple list tool with one parameter and no output schema, the description is adequate but lacks details on return format, pagination, or any behavioral constraints that would help an agent use it correctly.
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?
The input schema has 100% coverage with a clear description for socialMediaId. The tool description adds no additional meaning beyond the schema, so baseline 3 is appropriate.
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 clearly states the verb 'list' and resource 'Pinterest boards', and specifies 'for a connected Pinterest account', distinguishing it from sibling tools like list_posts or list_accounts.
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 implies usage for listing boards but provides no explicit guidance on when to use versus alternatives or prerequisites like having a connected account.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_postsA
List social media posts with optional filters for platform, status, and date range
| Name | Required | Description | Default |
|---|---|---|---|
| page | No | Page number (0-based) | |
| limit | No | Posts per page (max 50) | |
| platforms | No | Filter by platforms | |
| statuses | No | Filter by post statuses | |
| from | No | Start date filter (ISO 8601, e.g. 2025-01-01T00:00:00.000Z) | |
| to | No | End date filter (ISO 8601, e.g. 2025-01-31T23:59:59.999Z) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden. It indicates a read operation via 'list,' but does not disclose pagination behavior, sorting, authentication needs, or any side effects. Minimal but not misleading.
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?
One efficient sentence with no wasted words. Clear and direct, front-loading the core action and key options.
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?
Lacks output schema and does not describe return values or pagination behavior. For a list operation, this is a noticeable gap, though the parameters hint at pagination.
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 100%, so the schema already documents parameters. The description only restates filter categories without adding new semantics, meeting baseline but not exceeding.
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 clearly states the action (list) and resource (social media posts), and mentions key filters (platform, status, date range). It effectively distinguishes from sibling tools like create_posts or delete_post.
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?
No explicit guidance on when to use this tool versus alternatives (e.g., get_post_analytics for counts). The description only implies usage for simple listing but lacks exclusions or context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_youtube_playlistsB
List YouTube playlists for a connected YouTube account
| Name | Required | Description | Default |
|---|---|---|---|
| socialMediaId | Yes | YouTube account ID (from list_accounts) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, and the description does not disclose any behavioral traits (e.g., authentication requirements, rate limits, whether it returns all playlists or paginated). It only states the basic action.
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 description is one short sentence, which is concise but lacks substantive detail. It is not overly verbose, but it could be more informative without sacrificing brevity.
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?
Given the tool's simplicity (one parameter, no output schema), the description is incomplete. It does not specify what the output contains (e.g., list of playlist objects) or any constraints like 'all playlists for the account'. Important context is missing.
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?
The input schema covers the sole parameter (socialMediaId) with 100% description coverage (referencing list_accounts). The tool description adds no additional meaning beyond the schema, so it meets the baseline of 3.
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 clearly states the action (List), resource (YouTube playlists), and context (for a connected YouTube account). It distinguishes itself from sibling tools like create_posts or delete_post by specifying the resource type.
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 provides no guidance on when to use this tool versus alternatives. There is no mention of prerequisites, conditions, or comparisons to other list tools like list_accounts or list_posts.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
upload_mediaA
Upload a local file to PostFast and get back a media key for use in create_posts. Handles the full flow: detects content type, gets a signed URL, uploads the file, and returns the key and type.
| Name | Required | Description | Default |
|---|---|---|---|
| filePath | Yes | Absolute path to the local file (e.g. /Users/me/photo.jpg) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Discloses full internal flow: content type detection, signed URL acquisition, file upload, and return of key/type. No annotations provided, so description carries burden well.
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?
Two sentences, no wasted words. First sentence states purpose, second explains process. Efficient and front-loaded.
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?
Covers purpose, flow, and output for a simple single-parameter tool. Lacks security/error details but sufficient for typical usage given no output schema needed.
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 has 100% coverage for 'filePath'. Tool description adds behavioral context but not additional parameter details beyond what schema provides.
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?
Clearly states verb 'Upload', resource 'local file to PostFast', and purpose 'get back a media key for use in create_posts'. Distinguishes from sibling 'get_upload_urls' by describing the full upload flow.
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?
Explicitly connects to 'create_posts' workflow, indicating when to use. Lacks explicit exclusions or alternatives, but context is clear enough for typical use.
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.9- Changed
create_posts14 fields changed- added
Input schema / properties / controls / properties / gbpCallToActionTypeAdded value: +{ + "enum": [ + "BOOK", + "ORDER", + "LEARN_MORE", + "SIGN_UP", + "CALL", + "SHOP" + ], + "type": "string" +} - added
Input schema / properties / controls / properties / gbpCallToActionUrlAdded value: +{ + "description": "CTA button URL (not needed for CALL, ignored for OFFER)", + "type": "string" +} - added
Input schema / properties / controls / properties / gbpEventEndDateAdded value: +{ + "description": "End date for EVENT/OFFER (ISO 8601)", + "type": "string" +} - added
Input schema / properties / controls / properties / gbpEventStartDateAdded value: +{ + "description": "Start date for EVENT/OFFER (ISO 8601)", + "type": "string" +} - added
Input schema / properties / controls / properties / gbpEventTitleAdded value: +{ + "description": "Title for EVENT/OFFER posts (max 58 chars)", + "type": "string" +} - added
Input schema / properties / controls / properties / gbpLocationIdAdded value: +{ + "description": "GBP location resource name (from list_gbp_locations)", + "type": "string" +} - added
Input schema / properties / controls / properties / gbpOfferCouponCodeAdded value: +{ + "description": "Coupon code (OFFER only)", + "type": "string" +} - added
Input schema / properties / controls / properties / gbpOfferRedeemUrlAdded value: +{ + "description": "Redemption URL (OFFER only)", + "type": "string" +} - added
Input schema / properties / controls / properties / gbpOfferTermsAdded value: +{ + "description": "Terms and conditions (OFFER only)", + "type": "string" +} - added
Input schema / properties / controls / properties / gbpTopicTypeAdded value: +{ + "description": "Post type", + "enum": [ + "STANDARD", + "EVENT", + "OFFER" + ], + "type": "string" +} - removed
Input schema / properties / controls / properties / xCommunityIdRemoved value: -{ - "type": "string" -} - removed
Input schema / properties / controls / properties / xQuoteTweetUrlRemoved value: -{ - "type": "string" -} - added
Input schema / properties / posts / items / properties / mediaItems / items / properties / coverImageKeyAdded value: +{ + "description": "S3 key of a custom cover/thumbnail image for video posts (upload via get_upload_urls first). Supported on Instagram Reels, Facebook Reels, Pinterest video pins.", + "type": "string" +} - changed
Input schema / properties / posts / items / properties / mediaItems / items / properties / coverTimestamp / descriptionPrevious value: -"Video cover timestamp"New value: +"Video cover timestamp in milliseconds (e.g. \"5000\" = 5s). Fallback when coverImageKey is also provided."
- Changed
get_post_analytics1 field changed- changed
Input schema / properties / platforms / items / enumPrevious value: -[ - "FACEBOOK", - "INSTAGRAM", - "X", - "TIKTOK", - "LINKEDIN", - "YOUTUBE", - "BLUESKY", - "THREADS", - "PINTEREST", - "TELEGRAM" -]New value: +[ + "FACEBOOK", + "INSTAGRAM", + "X", + "TIKTOK", + "LINKEDIN", + "YOUTUBE", + "BLUESKY", + "THREADS", + "PINTEREST", + "TELEGRAM", + "GOOGLE_BUSINESS_PROFILE" +]
- Added
list_gbp_locations - Changed
list_posts1 field changed- changed
Input schema / properties / platforms / items / enumPrevious value: -[ - "FACEBOOK", - "INSTAGRAM", - "X", - "TIKTOK", - "LINKEDIN", - "YOUTUBE", - "BLUESKY", - "THREADS", - "PINTEREST", - "TELEGRAM" -]New value: +[ + "FACEBOOK", + "INSTAGRAM", + "X", + "TIKTOK", + "LINKEDIN", + "YOUTUBE", + "BLUESKY", + "THREADS", + "PINTEREST", + "TELEGRAM", + "GOOGLE_BUSINESS_PROFILE" +]
10 tool updates
v0.1.0- First observed
create_posts - First observed
delete_post - First observed
generate_connect_link - First observed
get_post_analytics - First observed
get_upload_urls - First observed
list_accounts - First observed
list_pinterest_boards - First observed
list_posts - First observed
list_youtube_playlists - First observed
upload_media
TDQS
Scored across 11 tools
Each tool has a clearly distinct purpose: create, delete, list posts; upload media; get analytics; list accounts and platform-specific resources (GBP, Pinterest, YouTube). No overlapping functionality.
All tools follow a consistent verb_noun pattern in snake_case (e.g., create_posts, list_accounts, get_upload_urls), with no mixing of conventions.
11 tools is well-scoped for a social media posting server, covering account listing, post management, media upload, analytics, and platform-specific queries without unnecessary bloat.
Missing essential operations: no update_post tool to modify existing posts, and no get_post by ID (only list). This creates a significant gap for agents needing to edit posts.
Maintenance
Related MCP Connectors
Schedule and publish social posts across 9 platforms (Instagram, LinkedIn, X, TikTok, Facebook, Threads, Pinterest, Bluesky, Mastodon) straight from Claude, ChatGPT, Cursor, or any MCP client. Create, edit, and reschedule posts, upload media, and pull account and post analytics, follower demographics, and best-time windows. 20 tools, free on every plan.
Social media MCP: publish, schedule & analyze posts on TikTok, Instagram, YouTube, LinkedIn & X
Connect any AI agent to 11+ social platforms: schedule, publish & track posts via hosted MCP.
Schedule and publish social media posts to 10 platforms from your AI agent
Related MCP Servers
- AlicenseAqualityBmaintenanceEnables AI assistants to schedule and publish social media posts to platforms like Instagram, TikTok, YouTube, LinkedIn, Facebook, X, Threads, and Pinterest using natural language.3399 npm3MIT
- AlicenseNot gradedqualityCmaintenanceA full social media management MCP server enabling post, read, schedule, and analyze across Facebook, Instagram, LinkedIn, X/Twitter, Pinterest, and YouTube from any MCP-compatible AI client.MIT
- AlicenseAqualityAmaintenanceSchedule, manage, generate, and analyze social posts across 11 networks (Instagram, TikTok, X, LinkedIn, YouTube, Facebook, Pinterest, Threads, Bluesky, Mastodon, Telegram) from any AI agent — 13 tools covering scheduling, media upload, AI caption generation, best-times, analytics, listening, and comments.1337 npmMIT
- AlicenseNot gradedqualityCmaintenanceEnables AI agents to schedule and manage social media posts across 25 platforms via a simple 3-tool MCP interface, including listing connected accounts and recent posts.AGPL 3.0