Muse Connectors: What Exists, Custom Connectors, MCP, and Live Twitter (X) Data

By TwitterAPI.io Team•16 min read
Diagram of the three ways to connect a service to Meta Muse: built-in connectors in Settings, a custom connector Muse writes itself, and MCP servers in Muse Code, with the TwitterAPI.io MCP server as the X data example
Built-in, custom and Muse Code MCP routes, as documented by Meta. Sources read in 2026.

This page is about Muse connectors, the integrations inside Meta's Muse personal AI agent (the app at muse.ai, on iOS, Android, Mac and in WhatsApp). It is not about Grok's connectors in the Grok chat app, which have a documented field for adding a custom MCP server URL; that is our Grok connectors guide. Muse works differently: its custom connectors are code that the agent writes for you, and its documented MCP support lives in the separate Muse Code CLI.

Everything below comes from Meta's own pages, read this year: the Meta Help Center article on how Muse works with connectors, the Muse Connector Platform guidelines at platform.muse.ai/docs, the Meta Newsroom launch posts, the Muse security write-up, the Muse Code documentation at dev.meta.ai, and the official @Muse, @AIatMeta and @Meta accounts on X. Where Meta does not document something, such as the exact screens of the custom connector flow, we say so instead of guessing.

We also measured how people talk about Muse connectors on X: 236 posts naming Muse connectors or Muse MCP since the launch, 500 recent posts about Meta Muse, and the full post history of the official @Muse account, all collected in 2026 through our own API.

01 — Section

What Muse connectors are

Meta's Help Center defines them in one line: "You can choose to connect Muse to apps and services provided by Meta or third-parties. We call these Connectors." Muse itself is the personal AI agent Meta introduced in September 2026. It runs on Muse Secure VM, a dedicated Linux computer in the cloud with a full browser, and Meta's launch post says the data and credentials for any service a person connects are stored there.

A connector gives Muse a typed, permissioned way into a service instead of clicking through its website. The Muse security write-up (linked from security.muse.ai) explains the plumbing: for each built-in connector Meta "worked closely with the service provider to integrate their API" and wrote SKILL files, detailed instructions on how Muse should use it. Built-in connector logic runs outside the agent's runtime cell, and OAuth tokens sit in a credential store the main agent never sees.

Every action passes a gatekeeper. A separate agent called Sentinel is "the sole permission authority" for connector actions and network egress. Muse proposes; Sentinel decides whether to allow, deny or ask you. The connector platform docs spell out the defaults: reads and non-sensitive writes ask on first use, and you can choose Always allow; sensitive writes such as a purchase or sending an email ask every time and cannot be set to Always allow.

Connecting is per account and revocable. The help page says you tap Connect next to the connector you want, and that you can disconnect any time under Settings, Connectors. "Disconnecting stops Muse from exchanging data with the Connector", though Muse may keep what it already used in its memories and chat history.

02 — Section

Muse connectors list: what Meta has announced

Meta does not publish a public, complete directory on the web. Its small-business announcement says: "You can see the full list of available connectors in your Muse app settings, with more to come." What follows is every connector we could confirm from a Meta page or an official Meta account, so treat it as a floor, not the full list.

ConnectorWhere Meta names itNotes
GmailMeta Help CenterEmail connector filters out one-time codes and reset links (security write-up)
Facebook, Instagram, ThreadsMeta Help CenterConnected automatically
Apple Health, Android SMSMeta Help CenterNamed as examples
Granola, Notion@Muse post, September 2026"Ask Muse or connect in settings"
GitHub@github post reposted by @MuseReview PRs, issues, notifications
Asana, Box, Canva, Dropbox, Figma, HighLevelMeta Newsroom, Muse for Small BusinessBusiness tools
Intuit QuickBooks, Klaviyo, Lovable, Shopify, Slack, Stripe, ZoomMeta Newsroom, Muse for Small BusinessPlus Facebook Pages, Instagram professional and Meta ad accounts
PayPal, Expedia, Instacart@Muse postAnnounced as coming soon

Two more items from the launch post are not connectors in the same sense but often get listed with them: checkout through Link by Stripe, and 1Password support and Shop Pay, both described at launch as coming soon. In our X sample of recent Meta Muse posts, 1Password was the service named most often (22 of 500 posts), ahead of Instagram (14) and Facebook (11).

Is there an X (Twitter) connector? Not in anything Meta has published. None of the lists above names X, and in the full post history of the @Muse account none of the 9 posts about connectors mentions X or Twitter. If you need live posts, search results, timelines or replies from X in Muse, you have to bring that data in yourself, which is what the rest of this page covers.

03 — Section

Can you add a custom connector or an MCP server to Muse?

Yes for custom connectors, with a caveat; and MCP only in Muse Code. Here is what each Meta source says, side by side.

RouteWho it is forHow a service gets inReviewed by Meta?
Built-in connectorEvery Muse userSettings, Connectors, tap ConnectYes, platform review
Custom connectorAny Muse userAsk Muse to create one; it writes code against the API or CLINo (Help Center)
Muse Code MCP serverDevelopers in the terminalmcp_servers in ~/.config/muse/settings.jsonNo; you choose servers
Muse Connector PlatformCompaniesSubmission form at muse.ai/platformYes, three stages

Custom connectors in the Muse app. The Help Center: "If you want to connect to a service not yet available in the Connector list, you can ask Muse to create a Custom Connector." Muse guides you through it, which "can involve retrieving API information from the service", and the credentials go into its Secure Credentials Store. The security write-up adds the mechanism: "Muse can also write its own custom connectors for other services you care about if they have their own APIs or CLIs." The Help Center also warns: "Meta doesn't review custom connectors or how they use your information", so grant access with care.

What Meta does not document for the app. The Help Center article has no step-by-step menu path for custom connectors and no field for a remote MCP server URL, an MCP transport, or OAuth settings. Some third-party guides describe one; we could not find it on any Meta page, so we do not repeat it here. In practice the documented interface is a conversation: you tell Muse which service, give it the API documentation and a key when it asks, and it builds the integration in its VM.

MCP in Muse Code. Muse Code, Meta's coding agent CLI, is the one Muse product with documented MCP support. Its docs say: "Connect external tools through the Model Context Protocol (MCP). Declare servers in the mcp_servers block of your settings file." Each server uses stdio (with command, args, env) or streamable_http (with url and headers), configs support ${VAR} interpolation, remote servers can require an OAuth 2.1 sign-in through muse mcp login <server>, and /mcp lists connected servers and tools. Muse Code is a developer tool, not the consumer Muse app, so an MCP server added there does not show up under the app's Settings, Connectors.

Meta AI Connectors is a different program. dev.meta.ai/products/connectors describes Meta AI Connectors for the Meta AI assistant and AI glasses: a developer preview with MCP onboarding, selected in waves, where "publishing and discovery are coming in a later phase". It is separate from Muse connectors, which the same page links out to.

04 — Section

How the Muse Connector Platform review works

On September 18, 2026 the @Muse account posted "Attention developers! You can now build your own Muse connectors." On October 2, 2026 it announced a new developer portal with "Here's to the next 3,000 submissions!" The guidelines at platform.muse.ai/docs describe what a submission needs and how it is judged.

What you submit. A connector overview (intended users, supported tasks, how it beats the browser); business verification and acceptance of the Muse developer terms; a data processing questionnaire; the endpoint, authentication setup, scopes and credentials (for example OAuth client credentials or an API key) with "API or MCP documentation" covering inputs, outputs, read/write classes, side effects, errors and rate limits; and a dedicated test account for reviewers.

The three review stages. A risk assessment of security, privacy and integrity; a tool review that classifies every tool as read, write or sensitive write and approves only compliant tools; and end-to-end QA, including manual testing that sensitive writes always ask for approval. Approved connectors appear in Settings, Connectors and are discoverable by the agent; featuring is a separate editorial decision.

The bar for a data connector. The guidelines say Muse "can already browse websites", so a connector must add value beyond the browser. "A read-only connector can qualify when the information is the outcome, such as an account report or live inventory analysis. A wrapper around public pages or a list of links alone is not enough." For an X data connector that means returning structured results (posts, metrics, timelines, replies) rather than links to x.com.

Data rules. Connectors may use the data only to fulfill the user's request: no selling it, no unrelated advertising, no profiles, no model training, and deletion once access is revoked. Security incidents must be reported to Meta within 48 hours. Financial connectors may read data, but Meta is not currently approving money-movement or trading tools.

05 — Section

What people on X say about Muse connectors (our data)

We searched X for posts naming "Muse connector(s)" or "Muse MCP" and kept the 236 posts published since the Muse launch, over 44.6 days, 5.3 a day on average. The curve is a launch spike: weeks 2 and 3, when Meta opened the developer platform and announced the small-business connectors, hold 164 of them (69.5%).

Theme (keyword rule)PostsShare of 236
Submission or review status4418.6%
Mentions MCP208.5%
A builder says its connector is live145.9%
Region or availability problem83.4%
Asks for a connector31.3%
Mentions X or Twitter data20.8%

The review queue is the story. Nearly one connector post in five is about submitting, waiting or getting approved; builders post their status the way app developers once posted App Store review times. MCP comes up in about one post in twelve, mostly from developers comparing an MCP server with an API spec as the thing to submit.

X data is almost absent. Only 2 posts mention X or Twitter as a data source. In the wider Meta Muse conversation (500 recent posts, about 414 a day), just 1.2% mention connectors at all, and 0.4% mention MCP. Most Muse talk is about the product and the models, not integrations.

Official accounts. The @Muse account published 156 posts of its own since launch; 9 of them (5.8%) are about connectors, and those drew a median of 58,591 views against 33,773 for all its posts. Its biggest connector post, "dozens of new connectors just dropped. Slack, Notion, Figma, Canva, Shopify, Zoom + more", passed 1.6 million views. Neither @Muse, @AIatMeta nor @Meta mentioned MCP or custom connectors in the posts we collected.

Bar chart of X posts naming Muse connectors or Muse MCP per week after the Muse launch: 1, 81, 83, 29, 11, 12 and 19 posts in weeks 1 to 7
Posts naming Muse connectors or Muse MCP per week after launch. TwitterAPI.io advanced_search, collected in 2026.
06 — Section

Give Muse live X (Twitter) data with an MCP server in Muse Code

If you work in Muse Code, the TwitterAPI.io MCP server is a single settings block. It is a hosted Streamable HTTP server at https://mcp.twitterapi.io/mcp with 12 tools, all marked readOnlyHint: true: search_tweets, get_user_info, get_user_about, get_user_followers, get_user_followings, get_user_last_tweets, get_user_mentions, get_tweets_by_ids, get_tweet_replies, get_tweet_quotes, get_tweet_retweeters and get_trends. We confirmed the list with a live tools/list call.

Step 1: get a key. Sign up at TwitterAPI.io; new accounts that pass the automatic bot check get up to $1 of free credits (at most 100,000 credits, no card, one per person or network, expiring after 31 days). No X account is needed for reads.

Step 2: add the server. Put the mcp_servers block from the code below in ~/.config/muse/settings.json (it must contain "schema_version": 1, per Meta's configuration docs) and export TWITTERAPI_IO_API_KEY in your shell. The server's own instructions say to send the API key as the Bearer token, and Muse Code interpolates ${VAR} in server configs.

Step 3 (alternative): OAuth instead of a header. The server also implements MCP OAuth (PKCE with S256, refresh tokens, dynamic client registration at api.twitterapi.io). Leave out headers and run muse mcp login twitterapi; Muse Code keeps and refreshes the tokens.

Step 4: check it. Start muse, type /mcp and look for the twelve tools, then ask a normal question such as "Search Latest posts about Muse connectors from the last day, excluding retweets, and list the five most viewed with links." Because every tool declares itself read-only, Meta's docs say it runs without an approval prompt under on-request approvals.

Probe first. The three curl requests in the code below are what we ran against mcp.twitterapi.io while writing this page. The first two need no key; the third proves your key works. An unauthenticated tool call returns HTTP 401 with a www-authenticate: Bearer header naming the scope twitter.read, which is how an MCP client discovers the OAuth flow. Tool results are plain JSON that the model reads into its context, and tweet objects are large (our Grok connectors guide measured a 20-post search page at roughly 138 KB), so ask for narrow queries and small pages.

We built this config from Meta's documented schema and probed the server directly; we did not run it inside a Muse Code session, because Muse Code needs a Meta developer login. mode: optional keeps a session alive if the server is unreachable; the default, required, aborts the run. Meta also warns that MCP tools are not sandboxed, so add only servers you trust.

bash
# 1. Add the server (this creates the file; if you already have
#    ~/.config/muse/settings.json, merge the mcp_servers block instead)
mkdir -p ~/.config/muse
cat > ~/.config/muse/settings.json <<'EOF'
{
  "schema_version": 1,
  "mcp_servers": {
    "twitterapi": {
      "transport": "streamable_http",
      "url": "https://mcp.twitterapi.io/mcp",
      "headers": {
        "Authorization": "Bearer ${TWITTERAPI_IO_API_KEY}"
      },
      "enabled": true,
      "mode": "optional"
    }
  }
}
EOF
export TWITTERAPI_IO_API_KEY=your_key_here

# 2. Probe the server before you trust it
URL=https://mcp.twitterapi.io/mcp
H1='Content-Type: application/json'
H2='Accept: application/json, text/event-stream'

# initialize: reachable? (no key needed)
curl -s -X POST "$URL" -H "$H1" -H "$H2" \
  -d '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-06-18","capabilities":{},"clientInfo":{"name":"probe","version":"0"}}}'

# tools/list: 12 tools, all readOnlyHint true (no key needed)
curl -s -X POST "$URL" -H "$H1" -H "$H2" -d '{"jsonrpc":"2.0","id":2,"method":"tools/list"}'

# tools/call: needs the key as a Bearer token (HTTP 401 without it)
curl -s -X POST "$URL" -H "$H1" -H "$H2" -H "Authorization: Bearer $TWITTERAPI_IO_API_KEY" \
  -d '{"jsonrpc":"2.0","id":3,"method":"tools/call","params":{"name":"search_tweets","arguments":{"query":"muse connectors -filter:retweets"}}}'

# 3. Start Muse Code, then type /mcp to list connected servers and tools
muse
07 — Section

In the Muse app: a custom connector, or the X step outside Muse

In the consumer app there is no documented MCP field, so you have two honest options.

Option 1: ask Muse to build a custom connector. Tell Muse you want a connector for TwitterAPI.io, point it at docs.twitterapi.io, and give it your API key when it asks; per Meta it stores credentials in the Secure Credentials Store. The endpoints it needs are ordinary HTTPS GETs with an X-API-Key header, for example /twitter/tweet/advanced_search for search and /twitter/user/last_tweets for a timeline, both paginated with has_next_page and next_cursor. Meta does not review custom connectors, so you are trusting the code Muse writes; check what it built in the activity log before you set any permission to Always allow.

Option 2: do the X step outside Muse. Run the Python script on this page (or our hosted MCP server from any MCP client), then give Muse the resulting digest. Muse can work with files and build artifacts such as dashboards, so a compact Markdown or JSON digest of the posts you care about is enough for summaries, competitor tracking or a weekly report. This keeps your key out of Muse entirely.

Option 3, for companies: submit a connector. If you run a product that should be in the directory, the route is the Muse Connector Platform. Remember the guideline that a wrapper around public pages is not enough; a submitted X data connector would need to return structured, useful results and pass the three review stages.

Whichever route you use, any write action on X (posting, replying, following) is a different matter from reading. Muse treats sending and publishing as sensitive writes that ask every time, and on TwitterAPI.io writes run through an authenticated session for that account (one /twitter/user_login_v2 login at $0.10 with a proxy you supply, then $0.002 per action, billed per HTTP 200 call). The call acts as that account, X can rate-limit, lock or suspend it, the session can need a re-login, and you should keep a human pace. For a read-only Muse workflow you need none of that.

08 — Section

What it costs: X data vs the official X API, and Muse models on the Meta Model API

Muse itself is free for most use, with subscription plans for more, according to Meta's launch post. The X data you pull in is billed by whoever serves it.

SourcePrice for 1,000 posts readNotes
TwitterAPI.io (REST or MCP)$0.1515 credits per post returned; minimum 15 credits per request
X API pay-per-usage rate card$5.00$0.005 per post read; capped at 3M post reads a month

That is about 33x per 1,000 posts. One full 20-post page costs $0.003 on TwitterAPI.io; a check that finds nothing costs the $0.00015 minimum, so a Muse task polling a keyword every 5 minutes for a month has a floor of about $1.30. Profiles are $0.18 per 1,000. Before the first payment the rate limit is 0.2 requests per second, which is fine for an agent that reads a page at a time; paid accounts get 20. Subscriptions start at $29 a month (Starter) if you prefer a plan; see the pricing page for all tiers.

Our own study for this page made 61 requests and returned 1,186 posts plus one profile, about $0.18 in data.

Muse Spark on the Meta Model API. Searches for "meta muse api" usually mean the models, not the agent. Meta's developer site lists the Muse model family (Muse Spark, Muse Spark Open, Muse Wonder, Muse Glimmer and others) on the Meta Model API, and its Muse Code launch post says Muse Spark 1.2 is available across Muse Code, the Meta Model API and OpenRouter.

Model ID (dev.meta.ai)Input per 1M tokensCached inputOutput
muse-spark-1.3$1.25$0.15$4.25
muse-spark-1.3-contributor$0.10$0.002$0.20

The contributor IDs are, in Meta's words, "used to improve our products". If you build your own agent on a Muse model instead of using the Muse app, you wire X data in the same way as with any other model: call the REST endpoints from your tool code, or point an MCP-capable harness at https://mcp.twitterapi.io/mcp.

Horizontal bar chart of themes in X posts about Muse connectors: submission or review status 18.6 percent, MCP 8.5, builder says live 5.9, region problem 3.4, asks for a connector 1.3, mentions X or Twitter data 0.8
Themes in posts naming Muse connectors since launch; one post can match several themes. Collected in 2026.
09 — Section

How we collected this

Question. How is Meta Muse discussed on X, how much of that is about connectors, and what did Meta's official accounts say about connectors?

Queries and accounts. /twitter/tweet/advanced_search (Latest) for "meta muse" -filter:retweets (25 pages) and for ("muse connectors" OR "muse connector" OR "muse mcp") -filter:retweets (12 pages); /twitter/user/last_tweets for the organization accounts @Muse (10 pages), @AIatMeta and @Meta (5 pages each); one search for Muse posts from @AIatMeta and @Meta; one profile lookup for @Muse.

Window and size. The Meta Muse sample is the latest 500 posts, covering 29.0 hours. The connector sample is every post the search returned since the Muse launch, 236 posts over 44.6 days. The @Muse timeline covers its whole history since launch. In total 61 requests, collected in 2026.

Method. Themes are case-insensitive keyword rules on post text, listed in analyze.py; a post can match several. The analysis code, results and charts live in data/studies/muse-connectors.

What the sample cannot show. It cannot see the in-app connector directory, how many connectors Meta has approved, or how many people use custom connectors. Keyword rules miss posts that discuss connectors without the word, and the search index does not return every post. The 1Password count reflects news in the window, not long-run interest.

Privacy. Results are aggregates. Only organization accounts (@Muse, @AIatMeta, @Meta and brands they reposted) are named; no private individual is profiled, and raw search pages were not kept in the repository.

python
"""x_digest.py: the X (Twitter) step for Meta Muse, done outside Muse.

Pulls the latest posts for a search query from TwitterAPI.io, follows
next_cursor, and writes a compact digest (Markdown + JSON) you can hand to
Muse, attach in a chat, or let a Muse custom connector run on a schedule.
Usage:  TWITTERAPI_IO_API_KEY=... python3 x_digest.py '"muse connectors" -filter:retweets' 3
"""
import json
import os
import sys

import requests

BASE = "https://api.twitterapi.io"
HEADERS = {"X-API-Key": os.environ["TWITTERAPI_IO_API_KEY"]}


def search(query, max_pages=3):
    """Latest posts for an X advanced-search query, up to max_pages x 20."""
    tweets, cursor = [], ""
    for _ in range(max_pages):
        r = requests.get(
            f"{BASE}/twitter/tweet/advanced_search",
            headers=HEADERS,
            params={"query": query, "queryType": "Latest", "cursor": cursor},
            timeout=30,
        )
        r.raise_for_status()
        data = r.json()
        tweets.extend(data.get("tweets", []))
        if not data.get("has_next_page"):
            break
        cursor = data.get("next_cursor", "")
    return tweets


def compact(t):
    """Keep only what an agent needs; the full tweet object is much larger."""
    a = t.get("author") or {}
    return {
        "url": t.get("url"),
        "created_at": t.get("createdAt"),
        "author": a.get("userName"),
        "followers": a.get("followers"),
        "text": t.get("text"),
        "likes": t.get("likeCount"),
        "reposts": t.get("retweetCount"),
        "replies": t.get("replyCount"),
        "views": t.get("viewCount"),
        "lang": t.get("lang"),
    }


def main():
    query = sys.argv[1] if len(sys.argv) > 1 else '"meta muse" -filter:retweets'
    pages = int(sys.argv[2]) if len(sys.argv) > 2 else 3
    rows = [compact(t) for t in search(query, pages)]
    rows.sort(key=lambda r: r["views"] or 0, reverse=True)

    with open("x_digest.json", "w") as f:
        json.dump({"query": query, "count": len(rows), "posts": rows}, f, indent=1)

    lines = [f"# X digest: {query}", f"{len(rows)} posts, most viewed first", ""]
    for r in rows[:25]:
        text = (r["text"] or "").replace("\n", " ")[:200]
        lines.append(f"- @{r['author']} ({r['views']} views, {r['likes']} likes): {text} {r['url']}")
    with open("x_digest.md", "w") as f:
        f.write("\n".join(lines) + "\n")

    # Billing: 15 credits per tweet returned ($0.15 per 1,000), minimum 15 per request.
    print(f"wrote x_digest.md and x_digest.json ({len(rows)} posts, about ${len(rows) * 0.00015:.4f} in data)")


if __name__ == "__main__":
    main()
10 — Questions

Questions readers ask

What are Muse connectors?

Connectors are how Meta's Muse agent links to other apps and services, from Meta's own (Facebook, Instagram, Threads) to third parties such as Gmail, Slack, Notion and Shopify. You connect them under Settings, Connectors, and Muse asks for approval before sensitive actions such as sending an email or buying something.

Where is the full list of Muse connectors?

Inside the app. Meta says the full list of available connectors is in your Muse app settings, with more to come. Publicly, Meta's posts and help pages name Gmail, Facebook, Instagram, Threads, Apple Health, Android SMS, Granola, Notion, GitHub, Asana, Box, Canva, Dropbox, Figma, HighLevel, QuickBooks, Klaviyo, Lovable, Shopify, Slack, Stripe and Zoom, with PayPal, Expedia and Instacart announced as coming soon.

Can I add a custom connector to Muse?

Yes. Meta's Help Center says you can ask Muse to create a custom connector for a service that is not in the list; Muse builds it against the service's API or CLI and stores your credentials in its Secure Credentials Store. Meta does not review custom connectors, so only connect services you trust.

Does Muse support MCP servers?

Muse Code does: you declare servers in the mcp_servers block of ~/.config/muse/settings.json, over stdio or streamable_http, with OAuth sign-in through muse mcp login. Meta's help article for the Muse app does not document adding a remote MCP server URL, so we cannot confirm an MCP field in the consumer app.

How do developers submit a Muse connector?

Through the Muse Connector Platform at muse.ai/platform. You describe the connector, verify your business, answer a data processing questionnaire, provide the endpoint, auth setup and API or MCP documentation, and give reviewers a test account. Meta then runs a risk assessment, a tool review and end-to-end QA; approval is not guaranteed.

Can Muse read Twitter (X) posts?

Not through any connector Meta has announced. You can bring X data in with a custom connector that calls a data API, with the TwitterAPI.io MCP server in Muse Code, or by fetching posts outside Muse and giving it the digest. On TwitterAPI.io that costs $0.15 per 1,000 posts returned.

Are Muse connectors the same as Meta AI Connectors?

No. Meta AI Connectors at dev.meta.ai is a developer preview for the Meta AI assistant and AI glasses, with MCP onboarding and publishing planned for a later phase. Muse connectors belong to the Muse agent and are submitted through muse.ai/platform.

Is Muse free?

Meta's launch post says Muse is free for most of what people need, with subscription plans for people who want to do more. Data you pull in from paid services, such as X data from an API, is billed by that provider.

11 — Further reading

Continue

Sources & further reading
More from this series
Build it

Stop reading. Start building.

Starter credits cover real testing on real data. Google sign-in, no card, no application queue.

Get an API key

Already building with TwitterAPI.io? Publish an honest tutorial or build log about it and earn up to $200 a month in API credits.