meta-mcp-server
Provides tools for interacting with Facebook Pages, such as retrieving page details, creating page posts, and adding comments to posts.
Allows publishing photos and Reels to a linked Instagram Business account using Meta's Content Publishing API.
Integrates with the Meta Graph API to manage Facebook Pages and linked Instagram Business accounts, including posting content, commenting, and reading account details.
Click on "Install 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., "@meta-mcp-server@meta-mcp-server publish a photo to my Instagram business account"
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.
meta-mcp-server
A Model Context Protocol server for the Meta Graph API — Facebook Pages and linked Instagram Business accounts.
MIT licensed.
Install
npm install -g @nasdigitaluk/meta-mcpRelated MCP server: facebook-mcp
Configuration
{
"env": {
"META_PAGE_ACCESS_TOKEN": "your-page-token",
"META_PAGE_ID": "1234567890",
"META_IG_USER_ID": "17841400000000000"
}
}META_IG_ACCESS_TOKEN is optional — it defaults to the Page token, which is correct when the Instagram account is linked to that Page. The ids are optional too; they just default the arguments.
A long-lived Page token can be obtained through the Graph API Explorer and then exchanged, which is far less work than a full OAuth flow for a single account.
⚠️ Do not reason from the token's scope list
This is the finding worth carrying away, because it is wrong in both directions:
scope list says | reality | |
Reading Page content |
| fails, demanding |
Writing a comment |
| works |
Verified live. Every Page read endpoint (/{page}/feed, /me/feed, and by extension /{post}/comments) returns:
(#10) This endpoint requires the 'pages_read_engagement' permission or the 'Page Public Content Access' feature
…while debug_token lists that permission among the token's scopes. Granted but not effective, which points at App Review rather than at re-authorising.
Meanwhile a probe against POST /{post}/comments returned (#100) Invalid post_id parameter — it cleared the permission check and failed only on the deliberately fake id.
Writing works; reading it back does not. Trusting the scope list would have shipped the read tool and skipped the write — exactly backwards.
Two consequences here:
there is no read-comments tool, because it would always fail;
a successful
meta_create_post_commentis your only confirmation, and the tool says so.
⚠️ Tokens go in a header, not the URL
Meta's own examples put access_token=... in the query string. That puts the credential in access logs, proxy logs and browser history on every request. Here they are Authorization: Bearer headers, and there is a test asserting no request URL contains access_token.
Instagram publishing waits properly
Publishing to Instagram is two calls: create a media container, then publish it. Meta fetches and processes your media server-side, so publishing immediately is a race — and video loses it far more often than a photo.
The server this replaces published straight away with no wait at all. This one polls the container's status_code:
publishes as soon as it reports
FINISHED;refuses to publish one reporting
ERRORorEXPIRED;is bounded by attempts as well as by the clock, so a fast status endpoint cannot become a request storm;
falls back to publishing after the budget if
status_codenever appears, so a container type that does not report status is no worse off than before.
Instagram's Content Publishing API takes a public http(s) URL that Meta fetches, not a file upload. A local path can never work, so it is rejected at validation rather than sixty seconds later.
Tools
Tool | |
| A Page's details. |
| Post to a Page. Immediately public. |
| Comment — the link-in-first-comment pattern. |
| The linked Instagram Business account. |
| Publish a photo or Reel. |
| Anything else, with either token. |
The Page and Instagram tokens are kept apart — they are different tokens with different reach, and using the wrong one fails in a way that reads like a missing permission. meta_call takes an as argument so you can pick.
What is NOT covered
Meta publishes no machine-readable spec for the Graph API, and much of it is gated behind App Review in ways the scope list does not reflect. So this server does not claim complete coverage: it wraps what is verified working and offers meta_call as a documented passthrough for the rest.
Read-only and no-destructive modes
MCP_READ_ONLY=1 refuse anything that changes state
MCP_NO_DESTRUCTIVE=1 allow posting, refuse the generic callerTesting
npm test # 11 tests
SMOKE_ENV='{"META_PAGE_ACCESS_TOKEN":"x"}' npm run smoke # real MCP over stdioBuilt on
@nasdigitaluk/mcp-server-core.
Licence
MIT.
Available Tools
6 toolsmeta_callA
Call any Graph API endpoint directly, with the Page token by default. Meta publishes no machine-readable spec for the Graph API, so this server does not claim a complete catalogue — this is how you reach the rest of it. Paths are relative to the Graph host and version.
| Name | Required | Description | Default |
|---|---|---|---|
| as | No | Which token to use. They are different tokens with different reach. | page |
| path | Yes | e.g. /me/accounts | |
| query | No | ||
| method | No | GET |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description discloses that the Page token is used by default and that the 'as' parameter can switch to the Instagram token, which is useful context. It does not warn about the potential side effects of using POST or DELETE methods, nor does it mention response formats or error handling, which is a gap for a generic endpoint caller.
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 compact, two sentences, with the core purpose front-loaded and the caveat about the lack of a complete catalogue following logically. It avoids redundancy and uses precise language, making it easy to parse quickly.
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 generic tool with no output schema, it covers the essential how (path relative, token default) and when (catch-all for uncovered endpoints). It omits important contextual cautions regarding destructive methods (POST/DELETE) and the expected shape of the query parameter, which an agent invoking a raw endpoint would benefit from knowing.
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 50% (path and as have descriptions; query and method do not). The description adds meaning by clarifying that paths are relative to the Graph host and version, and by touching on token selection, but it does not elaborate on the 'query' object structure or the implications of the method parameter, leaving some parameter behavior under-explained.
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 calls any Graph API endpoint directly, with the Page token by default, positioning it as the generic fallback. It distinguishes itself from the specific sibling tools by noting it is the way to 'reach the rest' of the API, making its purpose unmistakable.
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?
It implicitly indicates usage when no dedicated tool is available by stating 'this is how you reach the rest of it', given the siblings cover common endpoints. However, it does not explicitly say 'prefer specific tools when available' or provide examples of when to choose this over a sibling, leaving some ambiguity.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
meta_create_instagram_postA
Publish to Instagram. Immediately public, no draft state.
Instagram's Content Publishing API does not accept a direct file upload: the media must be at a publicly reachable http(s) URL that Meta fetches server-side. A local path can never work.
| Name | Required | Description | Default |
|---|---|---|---|
| caption | No | ||
| image_url | No | Public http(s) URL to a photo. | |
| video_url | No | Public http(s) URL to a video. Posted as a Reel. | |
| ig_user_id | No | ||
| wait_seconds | No | Processing budget. Default 30 for a photo, 120 for video. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations to carry safety or behavioral context, the description discloses the most important behaviors: the post is immediately public, there is no draft state, and Meta fetches media server-side from a public URL. The explicit warning that a local path can never work prevents a common and costly invocation error.
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 two short sentences with no filler. The first sentence states the core action, and the second sentence front-loads the critical technical constraint. The line break cleanly separates the behavioral summary from the upload limitation.
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 covers the central gotcha and privacy behavior, but it does not explain the role of ig_user_id, whether one of image_url or video_url must be supplied, or how wait_seconds interacts with the request. With no output schema and no annotations, an agent still has meaningful gaps for executing the tool 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 description adds significant meaning to image_url and video_url by explaining why the URL must be public and why local files are impossible. However, caption and ig_user_id receive no semantic guidance, and with 60% schema coverage the description only partially compensates for undocumented parameters.
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, "Publish to Instagram," names a specific verb and resource, and the phrase "Immediately public, no draft state" clarifies that this is a live publishing action. This clearly distinguishes it from siblings like meta_create_page_post and meta_create_post_comment.
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 makes the intended use clear: publish media to Instagram, with no draft or preview state. It also provides a key prerequisite (media must be publicly reachable via http(s)), but it does not explicitly name alternatives or state when-not-to-use cases, so it stops short of a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
meta_create_page_postA
Post to a Facebook Page. Immediately public — there is no draft state here, and the only undo is deleting it.
| Name | Required | Description | Default |
|---|---|---|---|
| link | No | A link to attach. | |
| message | Yes | Post text. | |
| page_id | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description discloses critical side effects: 'Immediately public — there is no draft state here, and the only undo is deleting it.' This informs the agent that the action is irreversible and has immediate visibility consequences, which is exactly the kind of behavioral transparency needed.
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 two sentences, concise and free of extraneous detail. The key information—the action and its consequences—is presented efficiently 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?
The description covers the essential outcome (public post, no draft, deletion only undo) and the primary inputs (message, link, page). It does not mention any required permissions or return values, but given the simple tool and absence of output schema, this is acceptable. A slight deduction for not clarifying the purpose of page_id.
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 schema includes descriptions for link and message, but page_id has no description. The overall coverage is 67%, which is not high enough to assume all parameters are self-explanatory. While link and message are clearly defined, page_id's omission leaves ambiguity about its purpose and format.
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: 'Post to a Facebook Page,' which is a specific verb and object. This distinguishes it from sibling tools like meta_get_page (read) or meta_create_post_comment (comment).
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 does not provide explicit guidance on when to use this tool versus alternatives. It implies the purpose for creating a post but lacks direct 'use this when' or 'instead of' instructions. The reader must infer the appropriate context from the action name and description.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
meta_create_post_commentA
Comment on a Page post — how you put an outbound link in the first comment rather than the post body.
⚠️ A successful call here is your ONLY confirmation. Reading comments back is not possible with a standard app (see the README), so if this succeeds, believe it; there is nothing to verify against.
| Name | Required | Description | Default |
|---|---|---|---|
| message | Yes | ||
| post_id | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the behavioral transparency burden and does so well by warning that a successful call is the only confirmation and that reading comments back is not possible with a standard app. This is significant non-obvious behavior. It does not mention permissions or other side effects, but the key verification limitation is disclosed.
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 two sentences with no filler. The primary purpose is stated immediately, and the critical no-verification warning earns its place. Every word adds value.
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 two-parameter create tool with no output schema and no annotations, the description provides the essential behavioral context including the unverifiable-success caveat. It is complete enough for selection and invocation, though explicit parameter descriptions and auth prerequisites would make it fully robust.
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 for the two undocumented parameters. It does provide meaningful context: 'Page post' clarifies post_id, and 'outbound link in the first comment' implies message content. However, it does not explicitly map parameters or explain their formats, leaving some inference required.
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: 'Comment on a Page post'. It also clearly distinguishes the tool from the post-body workflow by emphasizing 'first comment rather than the post body', which separates it from sibling tools like meta_create_page_post and the Instagram tools.
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 gives clear context for when to use this tool: when you want to place an outbound link in the first comment rather than the post body. It does not explicitly name an alternative tool or provide a when-not-to-use statement, but the context is strong enough that an agent can infer the intended use case.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
meta_get_instagram_accountD
The linked Instagram Business account.
| Name | Required | Description | Default |
|---|---|---|---|
| fields | No | ||
| ig_user_id | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure, but it only describes an object, not an action. It does not mention whether the operation is read-only, what it returns, whether authentication is needed, or any side effects. This leaves the agent completely uninformed.
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 extremely short, but it is under-specified rather than appropriately concise. The single fragment adds no actionable information and does not earn its place, similar to a bare placeholder.
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 tool has two undocumented parameters, no annotations, and no output schema. The description is a vague fragment that does not explain return values, parameter usage, or the linked-account context. It is wholly inadequate for an agent to select and invoke this tool 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?
Schema description coverage is 0% for the two parameters ('fields', 'ig_user_id'), and the description does not mention either parameter. It offers no compensation for the missing schema documentation, so an agent cannot infer how to fill the parameters correctly.
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 is a noun phrase ('The linked Instagram Business account') with no explicit verb. It identifies the resource but does not state what the tool does with it, though the tool name implies retrieval. It fails to distinguish itself from siblings like meta_get_page or meta_create_instagram_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?
The description provides no guidance on when to use this tool, what prerequisites apply, or how it relates to alternatives. There is no mention of linked account requirements or when another sibling would be more appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
meta_get_pageC
A Facebook Page's own details.
| Name | Required | Description | Default |
|---|---|---|---|
| fields | No | Comma-separated. Defaults to id,name,fan_count. | |
| page_id | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
There are no annotations to describe side effects or read-only behavior. The phrase 'details' weakly implies a read operation, but the description does not disclose response format, errors, authentication, or whether any state changes occur.
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 extremely short and free of irrelevant detail, making it easy to parse. It could be slightly more informative by adding a verb and scope, but it does not waste words.
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 getter, the description gives a general idea but omits critical context such as what details are returned, how fields affects output, and any prerequisites. An agent would need to infer too much from the tool name and schema.
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?
Only 'fields' has a minimal schema description ('Comma-separated. Defaults to id,name,fan_count.'), while 'page_id' has no description. The tool description adds no explanation of page_id or how the parameters interact, leaving an agent to guess from the parameter name.
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 indicates the resource is a Facebook Page's details, and the tool name includes 'get', so an agent can infer retrieval. However, it is a noun phrase without an explicit verb, and it does not clearly distinguish the scope from related tools like meta_create_page_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 guidance is provided about when to use this tool versus alternative tools. Sibling names imply this is for reading Page details while others create posts/comments or fetch Instagram accounts, but the description itself does not state this.
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.
6 tool updates
v1.0.0- First observed
meta_call - First observed
meta_create_instagram_post - First observed
meta_create_page_post - First observed
meta_create_post_comment - First observed
meta_get_instagram_account - First observed
meta_get_page
TDQS
Scored across 6 tools
Each tool has a distinct purpose: page retrieval, post creation, comment creation, Instagram account retrieval, Instagram post creation, and a generic API caller. No overlaps or ambiguous boundaries.
All tools follow a consistent 'meta_verb_noun' pattern (e.g., meta_get_page, meta_create_page_post, meta_create_post_comment). Even the catch-all meta_call fits the naming convention.
Six tools is within the typical well-scoped range (3-15). It covers the core interactions without being overwhelming or excessively sparse.
The surface covers page and Instagram posting, plus a generic API caller that can fill gaps. However, it lacks dedicated operations like reading page posts or managing comments, which would be expected in full CRUD coverage. The catch-all mitigates this but doesn't fully replace dedicated tools.
Maintenance
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
Create, schedule, and publish social posts, manage accounts, and read analytics as MCP tools.
Hosted MCP for Instagram, Facebook, X, LinkedIn, Pinterest, and Ghost. OAuth 2.1, 38 tools.
Hosted Meta ads MCP with OAuth, bounded reads, and prepare/confirm writes.
- cloziqOAuthcom.cloziq
Create your offers and launch AI Instagram DM sales agents from any MCP client, over OAuth.
Related MCP Servers
- -licenseNot gradedqualityNot gradedmaintenanceEnables posting text messages to Facebook business pages through MCP. Supports OAuth authentication and manual connection methods for managing Facebook page content.-
- AlicenseNot gradedqualityCmaintenanceEnables analytics and management of Facebook Pages through the Meta Graph API, including posts, insights, audience, and publishing.GPL 3.0
- AlicenseAqualityAmaintenanceA TypeScript MCP server for the Meta Graph API focused on Facebook Pages, enabling publishing, reading, insights, and moderation tasks.301341MIT
- AlicenseNot gradedqualityCmaintenanceEnables authentication with Facebook and provides tools to list pages, post text/images, upload videos, and create Reels on Facebook Pages.6ISC
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
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/N-Graves/meta-mcp-server'
If you have feedback or need assistance with the MCP directory API, please join our Discord server