facebook-pages-mcp
Provides tools for managing Facebook Pages, including publishing posts, retrieving page insights, analyzing post performance, and moderating comments via the Meta Graph API v25.0.
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., "@facebook-pages-mcpshow me last week's page insights"
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.
facebook-pages-mcp
MCP server for Facebook Pages organic analytics and management, powered by Meta Graph API v25.0.
Built for Claude Code and any MCP-compatible AI tool. Gives your AI assistant direct access to your Facebook Page data — posts, insights, comments, and more.
Part of The SEO Engine toolkit by Rex Jones — AI-powered SEO and social media tooling for agencies and businesses.
Why this exists
No good Facebook Pages MCP server existed. Instagram has several. Facebook Pages had none that worked on a current API version.
Meta deprecated legacy metrics on June 15, 2026.
page_impressions,page_reach, andpage_impressions_uniqueno longer return data. This server uses the replacement metrics from day one.Business Manager support. Most businesses manage Pages through Meta Business Manager, not personal accounts. This server works with both.
Related MCP server: instagram-mcp
Quick start
Option 1: npx (no install)
{
"mcpServers": {
"facebook-pages": {
"command": "npx",
"args": ["-y", "facebook-pages-mcp"],
"env": {
"FB_PAGE_ACCESS_TOKEN": "your_page_access_token",
"FB_PAGE_ID": "your_page_id"
}
}
}
}Option 2: Clone and build
git clone https://github.com/lanternrow/facebook-pages-mcp.git
cd facebook-pages-mcp
npm install
npm run buildThen add to your Claude Code MCP settings:
{
"mcpServers": {
"facebook-pages": {
"command": "node",
"args": ["/path/to/facebook-pages-mcp/dist/index.js"],
"env": {
"FB_PAGE_ACCESS_TOKEN": "your_page_access_token",
"FB_PAGE_ID": "your_page_id"
}
}
}
}Getting your Page Access Token
Step 1: Create a Meta App
Go to Meta for Developers and click Create App
Name your app and choose the "Manage everything on your Page" use case
Connect it to your Business Portfolio
Step 2: Generate a token in the Graph API Explorer
Open the Graph API Explorer
Select your app from the Meta App dropdown
Add permissions:
pages_show_list,pages_read_engagement,business_managementClick Generate Access Token and complete the OAuth flow
When asked about Pages, select "Opt in to all current and future Pages"
Step 3: Get your Page Access Token
If your Pages are managed through Business Manager (most businesses):
# First, find your business ID
GET /me/businesses?fields=id,name
# Then get Page tokens for that business
GET /{business-id}/owned_pages?fields=id,name,access_tokenIf your Pages are on your personal account:
GET /me/accounts?fields=id,name,access_tokenCopy the access_token and id for the Page you want.
Step 4: Exchange for a long-lived token (recommended)
Short-lived tokens expire in ~1 hour. Exchange for a long-lived token (~60 days):
GET /oauth/access_token
?grant_type=fb_exchange_token
&client_id={your-app-id}
&client_secret={your-app-secret}
&fb_exchange_token={short-lived-token}Tip: For Pages you admin, Page tokens derived from a long-lived User Token never expire.
Tools
Read tools
Tool | Description |
| Page metadata: name, category, follower count, contact info, cover photo |
| Page-level analytics with date ranges and period aggregation (day/week/28-day) |
| Paginated list of posts authored by the Page |
| Per-post engagement: impressions, clicks, reactions by type |
| Paginated comments with author info and like/reply counts |
| Video performance: views, watch time, reactions |
| Full feed including visitor posts |
Write tools
Tool | Description |
| Publish text, link, or photo posts to the Page |
Utility tools
Tool | Description |
| Check token validity, expiration, and granted scopes |
Metrics and the June 2026 deprecation
Meta deprecated these page-level metrics on June 15, 2026:
Deprecated | Replacement |
|
|
| Page Viewer metric (rolling out) |
| Media Viewers metric (rolling out) |
This server uses only non-deprecated metrics: page_views_total, page_fans, page_fan_adds, page_fan_removes, page_actions_post_reactions_total.
Architecture
src/
index.ts # MCP server entry point, tool registration
client.ts # Graph API HTTP client (native fetch, no dependencies)
types.ts # TypeScript interfaces for API responses
tools/
pages.ts # get_page_info, get_page_feed
insights.ts # get_page_insights, get_video_insights
posts.ts # get_published_posts, get_post_insights, get_post_comments, create_post
utils.ts # refresh_token_infoZero external HTTP dependencies — uses Node 18+ native
fetchRate limit tracking — captures
x-app-usageandx-page-usageheadersCursor-based pagination — all list endpoints support
aftercursor and configurable limitsZod validation — all tool inputs validated with descriptive error messages
Environment variables
Variable | Required | Description |
| Yes | Long-lived Page Access Token |
| Yes | Default Facebook Page ID (numeric) |
Development
npm run dev # Watch mode — recompiles on save
npm run build # Production build
npm start # Run the serverContributing
Issues and PRs welcome. If Meta changes the API (they will), please open an issue.
License
MIT — see LICENSE.
Built as part of The SEO Engine by Rex Jones.
Available Tools
9 toolscreate_postA
Create a new post on the Facebook Page. Supports text posts, link posts, and photo posts. Returns the new post ID.
| Name | Required | Description | Default |
|---|---|---|---|
| link | No | URL to share as a link post. | |
| message | No | Text content of the post. | |
| page_id | No | Facebook Page ID. Defaults to FB_PAGE_ID env var if omitted. | |
| photo_url | No | Public URL of an image to post as a photo post. The image must be publicly accessible. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations, so description must disclose all behavioral traits. Only mentions post types and return ID. Lacks details on side effects, authorization needs, rate limits, or error handling. Insufficient for a mutation tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, 19 words, front-loaded with action and resource. No wasted 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?
Tool is straightforward with 4 non-required parameters. Output is simple (post ID). Context is mostly complete, but missing behavioral transparency details.
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 4 parameters with 100% description coverage. Description adds grouping by post types (text, link, photo), which is marginal added value over the schema.
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 action (create), resource (post on Facebook Page), supported types (text, link, photo), and return value (new post ID). Distinguishes from read-only sibling 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?
No explicit when-to-use or when-not-to-use guidance. Siblings are all read-only, so usage is intuitive, but no prerequisites or permissions mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_page_feedA
Retrieve the full page feed including visitor posts (unlike published_posts which only returns page-authored posts).
| Name | Required | Description | Default |
|---|---|---|---|
| after | No | Pagination cursor — pass the value from a previous response to get the next page. | |
| limit | No | Number of feed items to return (1-100, default 25). | |
| page_id | No | Facebook Page ID. Defaults to FB_PAGE_ID env var if omitted. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It discloses that the feed includes visitor posts, which is a key behavioral trait. However, it does not explicitly state that the tool is read-only, safe, or mention any authentication or rate-limit considerations, 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?
The description is a single sentence that front-loads the main action ('Retrieve the full page feed') and immediately provides the key differentiator. Every word serves a purpose with no waste.
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 has 3 parameters (all documented) and no output schema, the description is nearly complete. It explains the scope of the feed (visitor posts vs page posts). It does not describe the return format or pagination behavior, but the schema covers the 'after' param. For a simple read tool, this is sufficient.
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 baseline is 3. The description itself does not add parameter details beyond what the schema already provides (e.g., page_id, limit, after). It does not explain parameter semantics further.
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 retrieves the full page feed including visitor posts, and explicitly distinguishes itself from the sibling tool 'published_posts' which only returns page-authored posts. The verb 'retrieve' and resource 'full page feed' are specific.
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 when to use this tool (when you need the full feed including visitor posts) versus the alternative 'published_posts' (which only returns page-authored posts). However, it does not discuss other contexts or exclusions beyond this sibling comparison.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_page_infoA
Retrieve Facebook Page metadata: name, category, follower count, contact info, location, hours, and cover photo.
| Name | Required | Description | Default |
|---|---|---|---|
| page_id | No | Facebook Page ID. Defaults to FB_PAGE_ID env var if omitted. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden of behavioral disclosure. It implies a read operation ('Retrieve'), but does not explicitly state non-destructive nature, authentication requirements, or rate limits. Acceptable but minimal.
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 that efficiently lists key return fields without extraneous words. 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 no output schema, the description helpfully lists major return fields. However, it omits details on error handling or potential limits. For a simple metadata retrieval tool, it is reasonably complete.
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% for the single parameter 'page_id', so baseline is 3. The description adds no extra meaning about the parameter beyond listing return fields, which is about output, not parameter semantics.
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 retrieves Facebook Page metadata and enumerates specific data points: name, category, follower count, contact info, location, hours, and cover photo. This verb+resource phrasing is specific and distinguishes it from sibling 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?
No guidance is provided on when to use this tool versus alternatives like get_page_insights or get_published_posts. The description lacks context about its appropriate use cases or when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_page_insightsB
Retrieve page-level analytics (page_views_total, page_fans, page_fan_adds, page_fan_removes, page_actions_post_reactions_total). Supports day/week/days_28 periods and date ranges. NOTE: Legacy metrics page_impressions and page_reach are deprecated as of June 2026.
| Name | Required | Description | Default |
|---|---|---|---|
| since | No | Start date (YYYY-MM-DD) for the query range. Use with 'until'. | |
| until | No | End date (YYYY-MM-DD) for the query range. Use with 'since'. | |
| period | No | Aggregation period: day, week, or days_28. | day |
| metrics | No | Metrics to retrieve. Defaults to all supported metrics: page_views_total, page_fans, page_fan_adds, page_fan_removes, page_actions_post_reactions_total. NOTE: page_impressions, page_reach, and page_impressions_unique are DEPRECATED (June 2026) and should not be used. | |
| page_id | No | Facebook Page ID. Defaults to FB_PAGE_ID env var if omitted. | |
| date_preset | No | Date preset (e.g. last_7d, last_28d, last_30d, this_month). Mutually exclusive with since/until. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description must disclose behavioral traits. It mentions deprecated metrics but does not state that the operation is read-only, require authentication, or have any side effects. The term 'retrieve' implies non-destructive read, but explicit safety context is missing.
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 with a front-loaded purpose, followed by supported features and a note. No redundant or unclear language. Every sentence 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?
Despite having 6 parameters and no output schema, the description omits key context: it does not explain that date_preset and since/until are mutually exclusive, does not describe the response format or default behavior, and lacks info on required auth. The note on deprecated metrics is helpful but insufficient for full 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?
The description adds a summary of supported metrics and periods (day/week/days_28) that mirrors the schema. Since schema description coverage is 100%, the description does not add new parameter details; it reinforces existing info. 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 it retrieves page-level analytics and lists specific metrics (e.g., page_views_total, page_fans). The verb 'retrieve' and resource 'page-level analytics' are precise, and the scope distinguishes it from sibling tools like get_post_insights (post-level) or get_page_info (page settings).
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 versus alternatives (e.g., get_post_insights) or when not to use it. There are no prerequisites, exclusions, or contextual hints beyond the implicit page-level scope.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_post_commentsA
Retrieve paginated comments on a specific post, including author, timestamp, like count, and reply count.
| Name | Required | Description | Default |
|---|---|---|---|
| after | No | Pagination cursor for the next page of comments. | |
| limit | No | Number of comments to return (1-100, default 25). | |
| post_id | Yes | The Facebook Post ID to retrieve comments for. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must disclose behavior. It mentions pagination but does not elaborate on cursor usage or whether there is a next page indicator. The description does not explicitly state it is read-only, though that is implied.
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 unnecessary words. It efficiently conveys the tool's action and key information.
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 3 parameters, lack of output schema, and no annotations, the description is fairly complete. It explains the purpose and returned fields. However, it could be improved by adding pagination behavior details (e.g., how to get next page).
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%, with parameter descriptions covering syntax. The description adds value by listing returned fields (author, timestamp, like count, reply count), which goes beyond what the 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?
The description clearly states the verb 'Retrieve', the resource 'comments on a specific post', and lists returned fields (author, timestamp, like count, reply count). This distinguishes it from sibling tools like get_published_posts or get_post_insights.
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 explicit guidance on when to use this tool versus alternatives, nor when not to use it. The context is only implied by the tool name and purpose.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_post_insightsA
Retrieve engagement metrics for a specific post: impressions, engaged users, clicks, reactions by type, and activity by action type.
| Name | Required | Description | Default |
|---|---|---|---|
| metrics | No | Metrics to retrieve. Defaults to: post_impressions, post_engaged_users, post_clicks, post_reactions_by_type_total, post_activity_by_action_type. | |
| post_id | Yes | The Facebook Post ID (format: pageId_postId). |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, so the description must fully convey behavioral traits. It only indicates a read operation ('retrieve'), with no mention of side effects, rate limits, authentication needs, or potential errors.
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 efficiently conveys the core purpose and key metrics, with no wasted 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 retrieval tool with two parameters and no output schema, the description covers the input and purpose but omits the response structure or pagination details, leaving some ambiguity about return format.
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%, and the description adds value by listing default metrics (e.g., post_impressions, post_engaged_users) and clarifying the post_id format, which goes beyond the schema's bare 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 states the tool retrieves engagement metrics for a specific post, listing examples like impressions, engaged users, clicks, reactions, and activity. It distinguishes from sibling tools like get_page_insights (page-level) and get_video_insights (video-specific).
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 use for post-level metrics but provides no explicit guidance on when not to use or alternatives. The sibling list suggests differentiation, but the description itself lacks direct usage directions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_published_postsB
Retrieve a paginated list of posts published by the page, including message, image, permalink, shares, and type.
| Name | Required | Description | Default |
|---|---|---|---|
| after | No | Pagination cursor for the next page of results. | |
| limit | No | Number of posts to return (1-100, default 25). | |
| page_id | No | Facebook Page ID. Defaults to FB_PAGE_ID env var if omitted. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden. It discloses pagination behavior and the fields returned, but does not mention rate limits, authentication, or any side effects. It adds some context but lacks depth.
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 of 18 words, immediately states the action and scope. No waste, front-loaded, and 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?
Given no output schema and three simple parameters, the description covers the core functionality. It could mention ordering or that only published posts are included, but overall it is sufficient.
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 need to add much to parameter meanings. It does not add detail beyond the schema, but lists output fields which is helpful. 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?
Description uses a specific verb (Retrieve) and resource (published posts) and lists included fields (message, image, permalink, shares, type). It clearly states what the tool does, though it does not explicitly differentiate from siblings like get_page_feed.
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 on when to use this tool versus alternatives such as get_page_feed or get_post_insights. No exclusions or context about prerequisites are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_video_insightsB
Retrieve performance metrics for a specific video: views, impressions, average watch time, total watch time, and reactions by type.
| Name | Required | Description | Default |
|---|---|---|---|
| metrics | No | Video metrics to retrieve. Defaults to: total_video_views, total_video_impressions, total_video_avg_time_watched, total_video_view_total_time, total_video_reactions_by_type_total. | |
| video_id | Yes | The Facebook Video ID to retrieve insights for. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, so the description must fully disclose behavior. It indicates a read operation but does not mention any permissions, rate limits, side effects, or response format beyond listing metrics.
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 unnecessary words. It is front-loaded with the purpose and efficiently conveys the key metrics.
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 output schema and a simple 2-param tool, the description adequately states what metrics are retrieved but lacks details on response structure or format. It is minimally sufficient.
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 coverage is 100% with both parameters described. The description lists metric names but adds minimal value beyond the schema's default description. 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 retrieves performance metrics for a specific video and lists specific metrics (views, impressions, average watch time, etc.), distinguishing it from siblings like get_post_insights (for posts) and get_page_insights (page-level).
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 on when to use this tool versus alternatives like get_post_insights or get_page_insights. There is no mention of prerequisites, limitations, or when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
refresh_token_infoA
Inspect the current access token to check validity, expiration date, and granted scopes. Useful for diagnosing auth issues.
| Name | Required | Description | Default |
|---|---|---|---|
| token | No | Access token to inspect. Defaults to the FB_PAGE_ACCESS_TOKEN env var. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided; description sufficiently discloses the read-only nature and what information is returned (validity, expiration, scopes). No destructive behavior or side effects implied.
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 concise sentences with front-loaded purpose. No extraneous 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 low-complexity tool with no output schema, the description adequately covers the return information (validity, expiration, scopes) and usage context. Slightly lacks mention of error cases but acceptable.
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%; description adds value by specifying the optional parameter's default (FB_PAGE_ACCESS_TOKEN env var), clarifying behavior beyond the schema.
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 'inspect' and the resource 'access token', listing specific attributes (validity, expiration, scopes). Distinct from sibling tools focused on page data and posts.
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 states usefulness for diagnosing auth issues, implying when to use. No sibling tool overlaps in function, so no need for exclusion criteria.
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.
9 tool updates
v1.0.3- First observed
create_post - First observed
get_page_feed - First observed
get_page_info - First observed
get_page_insights - First observed
get_post_comments - First observed
get_post_insights - First observed
get_published_posts - First observed
get_video_insights - First observed
refresh_token_info
TDQS
Tool purposes are mostly distinct, but 'get_published_posts' and 'get_page_feed' both retrieve posts with the difference being inclusion of visitor posts. While descriptions clarify, they could cause confusion. Similarly, separate insight tools for page, post, and video are clear. Overall minor overlap.
Most tools use 'get_' prefix, but 'create_post' and 'refresh_token_info' use different verbs. Among 'get_', suffixes vary between 'info', 'insights', 'posts', 'comments', 'feed', without a strict pattern. This mixed convention is noticeable but still understandable.
9 tools is appropriate for a Facebook Pages API covering essential operations: page info, insights, post retrieval (two flavors), post interactions, video analytics, post creation, and token management. Neither too few nor too many.
The tool set covers reading page data, posts, comments, and insights, and creating posts. However, it lacks update and delete operations for posts, comment management beyond reading, and other page management features. These gaps are notable for a complete page management surface.
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
- MysocialOAuthio.mysocial
Social media MCP server: your Instagram, TikTok, YouTube, LinkedIn and Threads history for your AI.
MCP server for QPost — lets AI agents publish video and image posts to YouTube, TikTok, Instagram.
Managed LinkedIn MCP server for AI agents: search, connect, message and enrich on accounts you own.
PerfectPost is a LinkedIn content management platform. This MCP server gives AI assistants read and write access to a user's PerfectPost account: published posts with their engagement analytics, drafts lifecycle (create / edit / schedule), and LinkedIn profile data.
Related MCP Servers
- AlicenseAqualityDmaintenanceMCP server to safely publish posts to multiple Facebook Pages via Meta Graph API, with built-in guardrails for brand voice, banned topics, image requirements, and anti-duplication.4MIT
- AlicenseNot gradedqualityCmaintenanceMCP server for organic Instagram analytics via the Meta Graph API, providing read-only tools for profiles, media, insights, audience, and optional 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 gradedqualityCmaintenanceMCP server for Instagram Graph API integration, enabling AI applications to manage Instagram Business accounts: fetch profiles, media, insights, publish content, and handle DMs.MIT
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/lanternrow/facebook-pages-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server