Skip to main content
Glama
N-Graves

meta-mcp-server

by N-Graves

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-mcp

Related 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

pages_read_engagement granted

fails, demanding pages_read_engagement

Writing a comment

pages_manage_engagement absent

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_comment is 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 ERROR or EXPIRED;

  • 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_code never 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

meta_get_page

A Page's details.

meta_create_page_post

Post to a Page. Immediately public.

meta_create_post_comment

Comment — the link-in-first-comment pattern.

meta_get_instagram_account

The linked Instagram Business account.

meta_create_instagram_post

Publish a photo or Reel.

meta_call

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 caller

Testing

npm test                                                # 11 tests
SMOKE_ENV='{"META_PAGE_ACCESS_TOKEN":"x"}' npm run smoke    # real MCP over stdio

Built on

@nasdigitaluk/mcp-server-core.

Licence

MIT.

Available Tools

6 tools
meta_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.

ParametersJSON Schema
NameRequiredDescriptionDefault
asNoWhich token to use. They are different tokens with different reach.page
pathYese.g. /me/accounts
queryNo
methodNoGET

TDQS

A3.9/5.0
Behavior3/5

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.

Conciseness5/5

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.

Completeness3/5

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.

Parameters3/5

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.

Purpose5/5

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.

Usage Guidelines4/5

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.

ParametersJSON Schema
NameRequiredDescriptionDefault
captionNo
image_urlNoPublic http(s) URL to a photo.
video_urlNoPublic http(s) URL to a video. Posted as a Reel.
ig_user_idNo
wait_secondsNoProcessing budget. Default 30 for a photo, 120 for video.

TDQS

A4.5/5.0
Behavior5/5

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.

Conciseness5/5

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.

Completeness3/5

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.

Parameters4/5

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.

Purpose5/5

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.

Usage Guidelines4/5

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.

ParametersJSON Schema
NameRequiredDescriptionDefault
linkNoA link to attach.
messageYesPost text.
page_idNo

TDQS

A4.2/5.0
Behavior5/5

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.

Conciseness5/5

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.

Completeness4/5

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.

Parameters3/5

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.

Purpose5/5

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.

Usage Guidelines3/5

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.

ParametersJSON Schema
NameRequiredDescriptionDefault
messageYes
post_idYes

TDQS

A4.2/5.0
Behavior4/5

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.

Conciseness5/5

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.

Completeness4/5

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.

Parameters3/5

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.

Purpose5/5

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.

Usage Guidelines4/5

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.

ParametersJSON Schema
NameRequiredDescriptionDefault
fieldsNo
ig_user_idNo

TDQS

D1.5/5.0
Behavior1/5

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.

Conciseness2/5

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.

Completeness1/5

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.

Parameters1/5

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.

Purpose2/5

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.

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, 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.

ParametersJSON Schema
NameRequiredDescriptionDefault
fieldsNoComma-separated. Defaults to id,name,fan_count.
page_idNo

TDQS

C2.4/5.0
Behavior2/5

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.

Conciseness4/5

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.

Completeness2/5

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.

Parameters2/5

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.

Purpose3/5

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.

Usage Guidelines2/5

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.

  1. 6 tool updatesv1.0.0
    • First observedmeta_call
    • First observedmeta_create_instagram_post
    • First observedmeta_create_page_post
    • First observedmeta_create_post_comment
    • First observedmeta_get_instagram_account
    • First observedmeta_get_page

TDQS

B3.3/5.0

Scored across 6 tools

Disambiguation5/5

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.

Naming Consistency5/5

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.

Tool Count5/5

Six tools is within the typical well-scoped range (3-15). It covers the core interactions without being overwhelming or excessively sparse.

Completeness4/5

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

ActivityMaintained
ResponsivenessNo issues

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

Related MCP Servers

  • A
    license
    Not graded
    quality
    C
    maintenance
    Enables analytics and management of Facebook Pages through the Meta Graph API, including posts, insights, audience, and publishing.
    GPL 3.0
  • A
    license
    A
    quality
    A
    maintenance
    A TypeScript MCP server for the Meta Graph API focused on Facebook Pages, enabling publishing, reading, insights, and moderation tasks.
    30
    134
    1
    MIT
  • A
    license
    Not graded
    quality
    C
    maintenance
    Enables authentication with Facebook and provides tools to list pages, post text/images, upload videos, and create Reels on Facebook Pages.
    6
    ISC

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/N-Graves/meta-mcp-server'

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