Facebook Pages MCP Server
Provides tools for interacting with Facebook Pages through the Graph API, enabling AI agents to list managed Pages, read Page details, posts, comments, photos, videos, events, insights, and Messenger conversations; with write/delete permissions, it can also publish posts, comments, photos, and videos, and delete posts or comments.
Click on "Deploy 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 MCP Server list the Facebook Pages I manage and show their latest posts"
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 Server
An MCP (Model Context Protocol) server that lets AI agents work with Facebook Pages through the Graph API.
An agent can list the Pages a person manages, read Page details, posts, comments, photos, videos, events, Messenger conversations and Page Insights. If you allow it, it can also publish posts, comment, upload media, and delete content.
Built on the MCP Python SDK (v2, MCPServer).
Targets Graph API v27.0, the current version; any version can be selected with
FB_GRAPH_VERSION.
Disclaimer
This is an unofficial, fan-made contribution. It is not associated with, endorsed by, or affiliated with Meta Platforms, Inc. or Facebook in any way.
This project was written with the assistance of a large language model (LLM). Please review the code before relying on it, especially for anything security-sensitive.
Related MCP server: Facebook MCP Server
Graph API coverage
Tools are grouped by what the underlying Graph API call does. The group decides whether a tool is registered at all. See Tool permissions.
Tool | Graph API | Group |
|
| read |
|
| read |
|
| read |
|
| read |
|
| read |
|
| read |
|
| read |
|
| read |
| (metric name reference) | read |
|
| read |
|
| read |
|
| read |
|
| read |
|
| read |
|
| read |
|
| read |
|
| read (POST/DELETE entries need write/delete) |
|
| read |
|
| write |
|
| write |
|
| write |
|
| write |
|
| write |
|
| delete |
|
| delete |
Four tools are always available. They describe this server, and only
facebook_pages_status, token_debug, and facebook_pages_refresh_token touch
Facebook data:
facebook_pages_status: configuration, readiness, and the token's expiry.facebook_pages_set_token: use a pasted access token for the rest of the session, which is how an expired token is replaced without a restart.facebook_pages_refresh_token: mint a Page token that does not expire, using the app credentials. See A Page token that never expires.facebook_pages_list_tools: the tools currently enabled.
Reading Page Insights
Insights need explicit metric names, and Meta deprecates them by API version.
Call page_insights_metrics to get a grouped list of names worth trying
(audience, engagement, followers, posts, reactions, video, media,
monetization), then pass them to page_insights with a period or
date_preset. When a metric is unavailable the Graph error names it.
Meta deprecated a large group of Page Insights metrics for every API version, in waves dated 2025-06-15 and 2025-11-15, and states a further wave for 2026-06-15. Two families matter here:
Reach:
page_impressions,post_impressionsand their paid, organic, viral, fan and non-viral breakdowns. Usepage_media_viewandpost_media_viewfor impressions, or the*_total_media_view_uniquemetrics for unique reach. The paid breakdown is available as a breakdown on the media-view metrics.Page likes:
page_fans,page_fans_city,page_fans_countryandpage_fan_adds. Use the follower metrics instead:page_follows,page_follows_city,page_follows_country,page_daily_followsandpage_daily_unfollows_unique.
The reference tables still print the deprecated names, so they are not a reliable
guide. The list the API enforces is
Deprecated Facebook Page Insights Metrics.
One rejected metric fails the whole Insights request with error 100, which is why
the tools never offer them. page_insights_metrics lists every name the API
refuses under retired_metrics, with the replacement, and an Insights request
that names one is answered with that replacement instead of being sent to the
API. That list is Meta's published list plus names a live Page has been seen
rejecting: page_post_engagements is absent from Meta's page, yet v27.0 answers
it as invalid, so it is treated the same way. A metric outside both is still sent
to the API and reported as Graph states it.
Three constraints worth knowing before you build a report: Page Insights are only
available for Pages with 100 or more likes, most metrics update once per day, and
a since/until range covers at most 90 days.
Choosing fields
The Graph API returns only the id of a node unless you ask for fields. Each
read tool therefore ships a default field set taken from the current reference.
Pass fields to replace that set outright, or extra_fields to add to it.
Two behaviours to plan around:
A field the API does not recognise fails the whole request with error 100 rather than returning nothing. The error names the field, so drop it and retry.
Some fields are accepted on one endpoint and rejected on another. The Post field
linkfails any post request with error 12 and a message aboutdeprecate_post_aggregated_fields_for_attachement. The message names attachments, which are accepted;linkis the field at fault. Usepermalink_url, which answers the same need, and the defaults omitlink.attachmentsis accepted on a post node and on the/{page-id}/postsedge, so it is included forpost_getand left out of list responses to keep them small.
The tools never send one field name twice. Graph reports a syntax error (2500)
when fields and extra_fields name the same field, so a name already present
is not repeated.
Pagination
Read tools that return an edge add more_available and next_url to the
response. Pass that URL to graph_follow to get the next page; Graph pagination
links already carry the cursor and token. limit and after work too.
Tool permissions
MCP_TOOL_PERMISSIONS decides which tools the AI can see and call. It is
grouped by what the underlying call does to Facebook data:
Level | What it allows | Effect |
| list and fetch data | Nothing changes. Safe. |
|
| The AI publishes publicly under your Page name. |
|
| Content is removed for good. |
Levels do not imply one another. List everything you want:
MCP_TOOL_PERMISSIONS=read # AI can only look at data
MCP_TOOL_PERMISSIONS=read,write # AI can look at AND publish
MCP_TOOL_PERMISSIONS=read,write,delete # AI has full control (dangerous)Unset means read-only. An unknown value makes the server refuse to start, so a
typo can never silently widen access. A disabled tool is not registered, so it
never appears in tools/list and cannot be called.
Quick start
1. Get a Page access token
Create (or open) an app in the Meta for Developers dashboard.
Open the Graph API Explorer, pick your app, and request the Pages permissions you need:
read tools:
pages_show_list,pages_read_engagement,read_insightswrite tools:
pages_manage_posts,pages_manage_engagement
Pick the Page and copy the token.
Exchange it for a long-lived user token (60 days), then call
GET /me/accounts?fields=id,name,access_tokenwith it and copy theaccess_tokenreturned for your Page. Short-lived tokens expire in about two hours, and a Page token taken from a short-lived user token expires within a day. A Page token taken from a long-lived user token has no expiry. That is the valueFB_PAGE_TOKENshould hold. The access token debugging tool shows what you have and when it expires.
check reports the same thing before you start the server:
facebook-pages-mcp-server check
# OK: type=PAGE app='1234567890' scopes=4
# Expiry: none (this token does not expire)Using a token for one call
Every tool also accepts an access_token argument that applies to that call
alone. Use it when the token you hold was never put in the server's environment,
or when the configured token has expired and nothing has been restarted:
{"tool": "page_posts_list", "arguments": {"page_id": "846466585206528", "access_token": "EAAG..."}}The configured token is a default, not the only credential a request may use. A
token given with a request is used for that request's Authorization header and
is never forwarded to Graph as a parameter. Nothing in the server changes: the
next call without one goes back to the configured value. token_debug and
facebook_pages_status inspect the token given with the call, so a token can be
checked before anything else is attempted.
Replacing an expired token without a restart
A token can expire while the server runs. Rather than editing .env and
restarting, pass the new token to facebook_pages_set_token:
{"tool": "facebook_pages_set_token", "arguments": {"access_token": "EAAG..."}}The token is checked with debug_token first. A token that Graph rejects, or
that is already expired, is not applied, so a typo cannot leave every later call
failing. A token that is accepted is used by every later call in that process.
It is not written to the environment, so a restart goes back to the configured
value; set FB_PAGE_TOKEN to keep it permanently.
The same tool replaces the optional FB_USER_TOKEN when called with
"scope": "user".
The parameter may also be named token, page_token, accessToken, or
fb_access_token, and a value may carry a Bearer prefix or surrounding
quotes. An AI client often writes the call that way, and a request naming an
unrecognised parameter is rejected before any handler runs, which looks exactly
like a bad token. A token copied from an HTTP header or a config file is used as
written.
A Page token that never expires
A Page token inherits the lifetime of the user token it was read with. Read with a short-lived user token, it dies within a day. Read with a long-lived user token, it has no expiry at all. The difference is one extra call, and doing it once ends the cycle of minting tokens.
Set the app credentials once, then call facebook_pages_refresh_token:
{"tool": "facebook_pages_refresh_token", "arguments": {"user_token": "EAAG..."}}It performs the three steps in order: exchange the user token for a long-lived
one with GET /oauth/access_token?grant_type=fb_exchange_token, read
me/accounts?fields=id,name,category,access_token with that result, and use the
Page token that returns. The response includes page_token, so the value can be
stored as FB_PAGE_TOKEN and survive a restart. never_expires: true confirms
the result is the permanent kind.
What it needs:
FB_APP_IDandFB_APP_SECRET, orapp_idandapp_secretwith the call. The exchange authenticates as the app, so no access token can stand in for them. They are in the app dashboard under Settings > Basic.A user token that has not expired, passed as
user_tokenor held inFB_USER_TOKEN. A Page token cannot be exchanged: with one,meis the Page, and a Page has noaccountsedge. Graph also refuses an exchange for a token that has already expired, so an expired user token must be re-issued first.page_idwhen the user token manages more than one Page. The tool names the Pages it can see rather than guessing.
Nothing is applied until every step has succeeded. A Page token that
debug_token rejects, or that is already past its expiry, is not installed, so a
failed refresh leaves the working token in place.
The same flow is available before the server runs:
facebook-pages-mcp-server refresh-token --page 846466585206528
# Page: 846466585206528 (Prime Time It)
# Expiry: none (this token does not expire)
#
# Set this as FB_PAGE_TOKEN:
#
# EAQ...long value...The App Secret is sent only to the token exchange. No Page call carries it.
An app in Development Mode can only reach test users and Pages you own. That is fine for trying this out; it is the safest way to run it.
A new app is created on the current Graph API version, and Meta issues its
access tokens for that version. The default FB_GRAPH_VERSION matches it. If you
pin an older version, set it to the one your app was created on; an app cannot
issue tokens for a version older than itself.
2. Install
cd facebook-pages-mcp-server
pip install -e .3. Configure
cp .env.example .env
# edit .env:
# FB_PAGE_TOKEN=... (required)
# FB_USER_TOKEN=... (optional, only for pages_list / pages_find)
# FB_APP_ID=... (optional, only to mint a token that never expires)
# FB_APP_SECRET=... (optional, same)
# MCP_API_KEY=... (only needed for serve-http)Generate the MCP server's own Bearer token:
facebook-pages-mcp-server gen-keyVerify the configuration and the token:
facebook-pages-mcp-server checkThat runs one live debug_token call and prints the issuing app, the granted
scopes and the expiry.
4. Run
stdio (the default, for local MCP clients):
facebook-pages-mcp-server
# or: facebook-pages-mcp-server servestreamable HTTP (for remote access, protected by a Bearer token):
facebook-pages-mcp-server serve-http
# → http://127.0.0.1:8900/mcp (clients send: Authorization: Bearer <MCP_API_KEY>)
# http://127.0.0.1:8900/health (unauthenticated liveness probe)Environment variables
Variable | Required | Description |
| yes | Facebook Page access token. Every Page tool acts with it. Never a tool parameter. |
| no | User access token for |
| no | Meta app ID. Used only by |
| no | Meta app secret. Sent only to the token exchange, never with a Page call. |
| no | Graph API version (default |
| no | Graph API base URL (default |
| for | Bearer token(s) clients must present to use this MCP server. Comma-separated list supported. |
| no | Bind host for |
| no | Bind port for |
| no | Comma-separated |
| no | Comma-separated browser |
| no |
|
| no |
|
| no | HTTP timeout in seconds (default |
| no | Extra retries on transient Graph failures (default |
| no |
|
A .env file in the working directory (or the project root) is loaded
automatically if python-dotenv is installed; real environment variables always
win.
DNS rebinding protection: when serve-http binds to a loopback host the SDK
enables DNS-rebinding protection and only allows 127.0.0.1/localhost Host
headers. Serving from a real hostname? Bind to that interface (e.g.
MCP_HTTP_HOST=0.0.0.0) and set MCP_ALLOWED_HOSTS/MCP_ALLOWED_ORIGINS.
MCP client configuration
Claude Desktop / any stdio client
{
"mcpServers": {
"facebook-pages": {
"command": "facebook-pages-mcp-server",
"env": {
"FB_PAGE_TOKEN": "your-page-access-token",
"MCP_TOOL_PERMISSIONS": "read"
}
}
}
}(Or point command at python with args: ["-m", "facebook_pages_mcp_server"]
and put the config in a .env file.)
Streamable HTTP client
URL:
http://<host>:8900/mcpHeader:
Authorization: Bearer <MCP_API_KEY>
Docker
A production Dockerfile (multi-stage, non-root, slim) and docker-compose.yml
are included. The container serves streamable HTTP on port 8900 by default.
# 1. configure
cp .env.example .env # fill in FB_PAGE_TOKEN and MCP_API_KEY
# 2. build and run
docker compose up -d --build
# 3. verify
curl http://localhost:8900/health
# → {"status": "ok", "server": "facebook-pages-mcp-server", "version": "1.6.1"}MCP clients connect to http://<host>:8900/mcp with
Authorization: Bearer <MCP_API_KEY>.
docker-compose.yml passes every environment variable through from .env
(required ones fail fast with a clear message if unset) and applies container
hardening: non-root user, cap_drop: ALL, no-new-privileges, read-only root
filesystem, bounded log files, and a /health-based healthcheck.
Running without compose:
docker build -t facebook-pages-mcp-server .
docker run --rm -d --name fb-pages-mcp -p 8900:8900 --env-file .env \
-e MCP_HTTP_HOST=0.0.0.0 facebook-pages-mcp-serverServing behind a real hostname: DNS-rebinding protection auto-enables for
loopback binds. For a public hostname, set MCP_ALLOWED_HOSTS (and
MCP_ALLOWED_ORIGINS for browser clients) in .env. Terminate TLS at a reverse
proxy (Caddy/Traefik/nginx) in front of the container; the server itself speaks
plain HTTP.
stdio in a container (for MCP clients that spawn processes):
docker run --rm -i --env-file .env facebook-pages-mcp-server serveTroubleshooting
The server reports an unexpected Graph API version. A process keeps the
configuration it read at start, so a server that is still running after you
changed .env or reinstalled the package keeps answering with the old values.
Restart it. The startup line and facebook_pages_status both name the version in
use, so compare them with FB_GRAPH_VERSION. If you installed with pip install .
rather than pip install -e ., a later source edit is not picked up until you
install again.
A tool you added is missing, or behaves as it did before the change. The
process you are calling is not the build you edited. A rebuild on disk changes
nothing until the running process is replaced, and an MCP client can stay attached
to an older process across a rebuild. facebook_pages_list_tools lists the tools
the serving process registered, so a tool that is absent there is not in that
process regardless of what the source says. Confirm the version the same way:
curl http://<host>:<port>/health prints the version the process was built
from. Compare it with --version for the package you intend to run.
The token exchange answers Error validating client secret (code 1). The App
ID was accepted and the secret was not, which is what a half-set pair looks like:
Graph receives an empty client_secret and reports it as invalid rather than as
missing. check and facebook_pages_status name the variable that is unset as
missing_app_credential. Set both FB_APP_ID and FB_APP_SECRET, or neither.
Insights return an invalid-metric error (code 100). One unsupported metric
fails the whole request. A metric the server knows the API refuses is caught
before the request and answered with its replacement, so this error now means a
name that is not on that list. Call page_insights_metrics and read
retired_metrics for the replacement. The list Meta enforces is linked under
"Reading Page Insights" above; the reference tables still print deprecated
names.
A read fails on a field you did not ask for. Drop the field named in the
error, or pass your own fields. Some fields are valid on one endpoint and not
another, as described under "Choosing fields".
pages_list answers (#100) Tried accessing nonexisting field (accounts).
The token in use is a Page token. With one, me is the Page itself, and a Page
has no accounts edge. That tool needs a user token, which is what lists the
Pages a person manages. A token supplied with a call is used exactly as given, so
this error is Graph naming the token's kind rather than a fault in the request.
Every call fails with code 190. The Facebook token is the problem, not the
code. An expired token says so and quotes the date Graph gave, for example
Session has expired on Friday, 13-Nov-26 14:00:00 PST. Pass a new one to
facebook_pages_set_token to use it from now on, or name it as access_token
with a single call to use it once. facebook_pages_status reports the expiry of
the token in use, and check prints it before the server starts.
A token that dies on a schedule is not fixed by replacing it again. Set
FB_APP_ID and FB_APP_SECRET and call facebook_pages_refresh_token: it
mints a Page token with no expiry. See
A Page token that never expires.
Development
pip install -e ".[dev]"
pytest # unit tests (mocked Graph API) + end-to-end testsThe end-to-end suite starts the real server (stdio and streamable HTTP) against a
bundled mock Graph API (tests/mock_graph.py) that implements the documented
request and response shapes, so no live Facebook token is needed. The mock also
records the requests the server made, so the tests assert on the paths and
parameters, not only on the results.
Project layout
facebook_pages_mcp_server/
├── __init__.py # package metadata
├── __main__.py # CLI: serve, serve-http, gen-key, check, refresh-token
├── config.py # environment variable handling
├── graph.py # async Graph API client (httpx) + error handling
├── refresh.py # minting a Page token that does not expire
├── server.py # MCPServer + tool registration + HTTP auth
├── specs.py # catalog of every tool: tier, description, endpoint
└── tokens.py # token expiry and token-failure messages
tests/
├── mock_graph.py # mock Graph API for tests
├── test_graph.py # client and configuration unit tests
├── test_tokens.py # token diagnostics unit tests
└── test_e2e.py # full server tests (stdio + HTTP)Security notes
The MCP Bearer token is read only from the environment and is never logged.
The Facebook token is read from the environment, except when you pass a replacement to
facebook_pages_set_token. It is never logged, never written to the environment by the server, and never included in a tool response. Only the token's type, scopes and expiry are reported.The Facebook token is sent in the
Authorization: Bearerheader, so it never appears in a URL, an access log, or a Graph pagination link.MCP_API_KEYcomparison is constant-time (hmac.compare_digest).Facebook access tokens expire.
facebook_pages_statusreports the type, scopes and expiry of the token in use, and an expired token makes it reportready: false. A Page token from a long-lived user token has no expiry, which is the state to aim for;facebook_pages_set_tokenreplaces a dead token without a restart.Use HTTPS for anything beyond localhost, and rotate the MCP token regularly.
Keep the app in Development Mode, or scope the token to one test Page, before enabling
writeordelete.MCP_TOOL_PERMISSIONSis the first line of defense: the AI only ever sees the tools you allow (read-only by default). It complements, not replaces, the scopes on the Facebook token. Use both.
License
Distributed under the MIT License. See the LICENSE file for full
terms.
Available Tools
22 toolsconversation_messages_listBRead-onlyIdempotent
List messages in a conversation Read the messages of one Page conversation, newest first. Graph API: GET {conversation_id}/messages.
Inputs: conversation_id (required), after, limit, fields, +2 more. Returns: object
facebook_pages_list_toolsA
List the tools this server exposes List every tool the AI may call, grouped by tier, with the Graph API endpoint behind each. Use this to discover what is available. Graph API: (local).
Inputs: access_token. Returns: object
facebook_pages_refresh_tokenA
Mint a Page access token that does not expire, and use it now Exchange a User access token for a long-lived one with the app's credentials, read me/accounts with it, and use the Page token that returns for every later call in this process. A Page token taken from a long-lived User token has no expiry, so this is how to stop the token expiring. Needs FB_APP_ID and FB_APP_SECRET, and a User token that has not expired: pass user_token, or have FB_USER_TOKEN set. The token is not written to the environment, so set FB_PAGE_TOKEN to keep it after a restart. Graph API: GET /oauth/access_token then GET me/accounts. A User token cannot be exchanged after it has expired; a new one must be obtained from the Graph API Explorer. The App Secret is sent only to the token exchange, never with a Page call.
Inputs: app_id, page_id, app_secret, user_token. Returns: object
facebook_pages_set_tokenA
Use a different Facebook access token for the rest of this session Verify a pasted access token with debug_token, then use it for every later call in this process. Use it when the configured token has expired and a new one has just been minted: no restart is needed. scope 'page' replaces FB_PAGE_TOKEN, scope 'user' replaces FB_USER_TOKEN. The token is not written to the environment, so a restart goes back to the configured value. A token that debug_token rejects is not applied. Graph API: (local) after GET /debug_token.
Inputs: access_token (required), scope. Returns: object
facebook_pages_statusA
Report this server's configuration, readiness, and token expiry Report the configured Graph API version, the enabled tool permissions, and the Facebook token's type, scopes and expiry. The token is checked live with debug_token, so an expired token is reported as expired rather than shown as configured. Set ping=false to skip the live call. Graph API: (local) plus GET /debug_token.
Inputs: ping, access_token. Returns: object
graph_batchBRead-onlyIdempotent
Run several Graph API calls in one request Run a batch of Graph API requests in one call to save round trips. Each entry is {method, relative_url, name}, where relative_url is a Graph path such as '1001/posts'. GET entries are always allowed; POST and DELETE entries need the write permission. Graph API: POST batch. A batch entry without relative_url has no target, and Graph answers it as a request on the version root: 'Unsupported get request'.
Inputs: requests (required), access_token.
graph_followARead-onlyIdempotent
Follow a Graph API pagination link Fetch the next page of an edge from the next_url a previous read returned. Graph pagination links already carry the cursor and token, so this is the reliable way to page through a long edge. Graph API: GET .
Inputs: url (required), access_token. Returns: object
page_albums_listCRead-onlyIdempotent
List a Page's photo albums List a Page's photo albums with names, counts and links. Graph API: GET {page_id}/albums.
Inputs: page_id (required), after, limit, fields, +2 more. Returns: object
page_conversations_listBRead-onlyIdempotent
List a Page's message conversations List Messenger conversations a Page has with people, with the last snippet, participants and unread count. Needs a token with pages_messaging. Graph API: GET {page_id}/conversations.
Inputs: page_id (required), after, limit, fields, +2 more. Returns: object
page_events_listCRead-onlyIdempotent
List a Page's events List events created by a Page with start and end times, place and attendee counts. Graph API: GET {page_id}/events.
Inputs: page_id (required), time, after, limit, +3 more. Returns: object
page_getARead-onlyIdempotent
Read a Page's fields Read one Page's details: name, category, about, follower and like counts, contact info, opening hours, location, picture, verification status. Pass fields to choose exactly what you need, or extra_fields to add to the defaults. Graph API: GET {page_id}.
Inputs: page_id (required), fields, access_token, extra_fields. Returns: object
page_insightsARead-onlyIdempotent
Read Page metrics Read Page-level metrics (reach, engagements, follower growth, video views, reactions, demographics). Pass one or more metric names, a period (day, week, days_28, lifetime) and either date_preset or since/until. Call page_insights_metrics for a list of metric names to try. Graph API: GET {page_id}/insights. Requires a token that can perform the ANALYZE task, and Pages with fewer than 100 likes return no insights. Some metrics are deprecated in newer API versions; an invalid-metric error names the metric that failed.
Inputs: metrics (required), page_id (required), since, total, +5 more. Returns: object
page_insights_metricsBRead-onlyIdempotent
List Page Insights metric names to try List common Page and post Insights metric names grouped by purpose, plus the periods and date presets the API accepts. Retired metrics are listed separately with their replacements, because one retired metric fails the whole Insights request. Meta changes this list often, so treat it as a starting point and let the API tell you when a metric is unavailable. Graph API: (static reference).
Inputs: group, access_token. Returns: object
page_photos_listCRead-onlyIdempotent
List a Page's photos List photos posted to a Page, with image URLs, captions and comment counts. Graph API: GET {page_id}/photos.
Inputs: page_id (required), after, limit, since, +4 more. Returns: object
page_posts_listARead-onlyIdempotent
List a Page's posts List posts published by a Page, newest first, with message, timestamp, engagement counts and attachment metadata. Filter by date with since/until (Unix timestamps), paginate with limit and after. Graph API: GET {page_id}/posts.
Inputs: page_id (required), after, limit, since, +5 more. Returns: object
pages_findARead-onlyIdempotent
Find a Page by name among the managed Pages Search the Pages the token manages by a case-insensitive substring of the Page name or username. Returns matching page ids and names. Cheaper than listing every Page when you only need one. Graph API: GET me/accounts (filtered locally).
Inputs: query (required), limit, access_token. Returns: object
pages_listBRead-onlyIdempotent
List the Pages the token's person manages List the Facebook Pages the access token's person can perform tasks on, with the tasks (ADVERTISE, MODERATE, CREATE_CONTENT, ANALYZE, ...) they hold on each. Use this first to find a page_id. Graph API: GET me/accounts. Needs a User access token with pages_show_list. Set FB_USER_TOKEN for a dedicated user token, or use a Page token issued through a person.
Inputs: after, limit, fields, access_token, +1 more. Returns: object
page_videos_listCRead-onlyIdempotent
List a Page's videos List videos published by a Page, with length, permalinks, thumbnail and publish status. Graph API: GET {page_id}/videos.
Inputs: page_id (required), after, limit, fields, +2 more. Returns: object
post_comments_listBRead-onlyIdempotent
List comments on a post List comments on a post. Defaults to top-level comments; set filter=stream for the full threaded stream, order=chronological_ascending to read oldest first. Graph API: GET {post_id}/comments.
Inputs: post_id (required), after, limit, order, +4 more. Returns: object
post_getBRead-onlyIdempotent
Read one post Read a single post by id (PageID_RecipientID). Returns the message, timestamps, link, picture, share and reaction summaries. Graph API: GET {post_id}.
Inputs: post_id (required), fields, access_token, extra_fields. Returns: object
post_insightsBRead-onlyIdempotent
Read one post's metrics Read metrics for a single post: reach, clicks, media views, reactions by type, video views. Pass one or more metric names. Graph API: GET {post_id}/insights.
Inputs: metrics (required), post_id (required), period, breakdown, +1 more. Returns: object
token_debugARead-onlyIdempotent
Inspect an access token's app, scopes and expiry Debug a Facebook access token: which app issued it, the granted scopes, the Page or user it belongs to, and when it expires. Omit input_token to inspect the token this server is configured with. Graph API: GET debug_token. Needs an app access token to see other apps' tokens; a Page token can debug itself.
Inputs: input_token, access_token. Returns: object
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 22 tools
Most tools map to a single resource+action (page_get, post_get, page_photos_list), so an agent can pick correctly. A few pairs overlap: pages_list vs pages_find, page_insights vs page_insights_metrics, and token_debug vs facebook_pages_status all answer similar questions, and set_token vs refresh_token both change the session token, but descriptions distinguish them.
All names are snake_case and follow a resource-first pattern (page_*, post_*, graph_*), which is readable and predictable. Minor deviations: the collection prefix is plural 'pages_' for two tools, admin/utility tools use a different 'facebook_pages_' prefix, and page_insights_metrics lacks an action verb.
22 tools is on the heavy side but each maps to a distinct Graph API edge or utility (posts, comments, insights, photos, videos, albums, events, messaging, auth, pagination, batch). Some listing tools could be collapsed into a generic edge reader, but nothing is clearly redundant.
The surface is almost entirely read-only: there are no direct tools to publish a post, reply to or moderate a comment, send a Messenger message, upload media, or create an event, which are core Facebook Pages workflows. graph_batch is an escape hatch for writes, but only if the agent already knows the raw Graph paths and has the write permission.
Maintenance
Related MCP Connectors
Instagram and Facebook Pages for AI agents: publish, comments, DM by keyword, inbox, insights.
Facebook & Instagram data for AI agents: pages, posts, groups, ads, Marketplace, profiles, reels.
Social media API for AI agents: publish, DMs, comments, Meta ads and leads.
Persistent memory, hybrid search and a goal graph for AI agents, over stdio or remote HTTP.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceAutomates Facebook Page management via Graph API, enabling posting, comment moderation, and analytics through AI agents.1MIT
- AlicenseNot gradedqualityDmaintenanceEnables AI agents to automate Facebook Page management including posting, commenting, and analytics via the Facebook Graph API.MIT
- AlicenseAqualityBmaintenanceA Facebook/Messenger MCP server that lets AI agents read and engage with profiles, pages, posts, comments, groups, Messenger conversations, notifications, and events using the user's existing browser session cookies — no Graph API app, tokens, or browser automation required. It supports multi-account and Page switching, write operations (posting, commenting, messaging) with per-identity limits and cooldowns, and honest error reporting where Meta has decommissioned cookie-era endpoints.411MIT
- AlicenseAqualityBmaintenanceEnables AI agents to manage Facebook Pages through Meta's Graph API, including posting, scheduling, drafts, reading insights, and moderating comments.1556 npm2MIT