Connect it in two minutes, then spend your time on the part that matters.

Buffer’s MCP server is refreshingly boring to set up. There’s no plugin to write, no adapter to install, no PHP. You authenticate once and Claude can see your channels, your queue and your analytics. That means the interesting question isn’t how to connect it — it’s what you do with it afterwards, and what you deliberately don’t let it do.

Here’s the whole thing: setup, the workflows that actually pay for themselves, the escape hatch for when the named tools run out, and the governance decisions worth making before you turn it loose.

Connecting

Two paths, depending on where Claude lives.

Claude web or desktop. Go to Customize → Connectors, search for Buffer, and connect. OAuth handles the rest — no API key to copy around, and you approve the scopes at authorisation time.

Claude Code, or any MCP client. Point it at Buffer’s HTTP endpoint:

claude mcp add –transport http buffer https://mcp.buffer.com/mcp

Then run /mcp inside a session and complete the Buffer OAuth flow in your browser.

If your client can’t do OAuth, generate a personal API key under Settings → API in Buffer instead. Either way, you can revoke access from the same screen whenever you want.

Worth knowing: MCP access is available on every Buffer plan, including Free. There’s no premium tier gating it.

Get Your Bearings First

Every Buffer tool needs an organization ID, so the first call in any session is get_account. It returns your organizations with their plan limits and member counts — and two things that quietly matter.

The first is your account timezone, plus the current time in it. Scheduling is where AI assistants embarrass themselves most reliably. If the model doesn’t know your account runs on America/Costa_Rica, “schedule this for Tuesday morning” becomes a coin flip. Confirming the timezone up front removes an entire class of error.

The second is that you may have more than one organization. If you do, name the one you’re using out loud before you start writing to it. Posting a client’s content to your own brand’s channels is not a mistake you make twice, but once is enough.

Then list_channels gives you each connected channel’s ID, service and display name. Everything downstream keys off those IDs.

The Workflows That Earn Their Keep

One source, several native variants

This is the workhorse. You have a page — a blog post, a case study, a product update — and you want it on three networks without it reading like the same sentence pasted three times.

The pattern that works: give Claude the source URL and the channel list, and ask for one variant per channel written to that channel’s conventions. In practice that means something like a terse two-line version with two hashtags for X, a fuller paragraph with context and a “full profile” link for LinkedIn, and something in between for Facebook. Same facts, same link, three genuinely different posts.

Then have it call create_post once per channel with shareMode: addToQueue, which drops each one into that channel’s next open slot rather than making you pick times. The posting schedule you’ve already configured per channel does the work.

The thing to insist on is that the variants are written differently, not truncated differently. If you don’t say so, you’ll get the LinkedIn version with the middle cut out.

The Queue Audit

list_posts with a dueAt range and status: [“scheduled”] gives you the next two weeks in one call. From there the useful questions are the ones nobody sits down to answer manually:

• Are three posts about the same topic landing on the same day?
• Is one channel starved while another is stacked six deep?
• Did anything come out of a batch session with a broken link or a placeholder still in it?
• Are we hitting Friday afternoon with nothing queued for Monday?

This is a five-minute weekly ritual that catches things a human scrolling a calendar view doesn’t.

Analytics, Asked In English

Two tools, and picking the right one matters. get_aggregated_post_metrics gives you sums and averages across a date range — “how did LinkedIn do last month”, “what did the launch-tagged posts pull in”. list_posts with includeMetrics: true gives you per-post numbers, but it’s heavy; with up to 100 posts a page, turning it on casually is how you burn a context window for no reason.

Two caveats to hold onto. Metrics refresh roughly daily, so metricsUpdatedAt can lag the network by up to a day — don’t ask about this morning’s post. And the aggregate returns a baseline trio (post count, reactions, comments) always, but richer metrics like reach and impressions only when every channel in your filter supports them. Mixed-channel queries silently return less. Filter to one service when you want the good numbers.

Idea capture

create_idea is the least glamorous tool and possibly the highest-return one. When something surfaces mid-conversation that isn’t worth writing now — a stat, an angle, a customer quote — parking it on the ideas board takes one call and means it exists somewhere other than your memory. list_idea_groups and list_ideas get it back later, filtered by tag.

Templates

If you post recurring formats — a weekly roundup, a showcase series, a release note — create_post_template stores the skeleton with {{placeholders}}, and Claude can fill and schedule from it. This is better than re-describing the format every session, and it keeps the structure stable across whoever’s running the session.

When The Named Tools Run Out

Buffer’s MCP server ships an escape hatch that most don’t: introspect_schema, execute_query and execute_mutation, straight against the GraphQL API.

The workflow is exactly what it sounds like. Ask Claude to introspect the schema for the type you care about, read what fields exist, then compose a query. Anything the API supports is reachable, whether or not a named tool wraps it.

Use it deliberately, though. The named tools carry descriptions, defaults and validation that a raw query doesn’t — they encode which arguments are safe and what the response costs. Reach for GraphQL when you’ve confirmed the named tool genuinely can’t do the job, not as a first move. And be much more careful with execute_mutation than with execute_query: a read that returns the wrong shape wastes a call, while a write that does is a post on a channel.

Governance: Decide This Before You Need It

Buffer’s own position is that AI-created posts land as drafts or scheduled items and you remain the last step. That’s the right default, and the tool surface backs it up in a way worth understanding.

Status is the control. Posts move through draft, needs_approval, scheduled, sending, sent and error. Creating as draft or needs_approval means nothing reaches an audience without a human clicking. Reserve direct-to-scheduled for content types you’ve already watched the workflow produce correctly a dozen times.

Watch `allowedActions`. Every post returned by list_posts carries a list of what can be done to it, and that list shrinks once the post has sent — a scheduled post allows publishPostNow, updatePost, deletePost and the rest, while a sent one allows viewing, tagging and duplicating only. That’s the API telling you the blast radius. It’s a good instinct to check it rather than assume.

Tag things. Tags are cheap at creation time and the only way to answer “how did that campaign do” later, since aggregate metrics filter by tag. An untagged queue is a queue you can’t measure. This is the most common thing to skip and regret.

Never let it auto-publish reactive content. Evergreen showcases and scheduled announcements on a review queue: fine. Anything responding to news, a customer complaint, or a trend: not without a human reading it in full. The failure mode isn’t the model writing badly, it’s the model writing well about something it has the wrong context on.

Where It Gets Good: Pairing Connectors

Buffer alone is a scheduling tool with a chat interface. Buffer alongside your other connectors is a pipeline.

The obvious pairing is with a CMS. Connect your site — through its own MCP server or a connector — and one instruction covers the whole chain: read the post that just went live, pull the title, the key claim and the URL, write three channel-native variants, queue them. What used to be a twenty-minute context-switch becomes a sentence.

Add an analytics or SEO source and the loop closes: find which pages are actually pulling traffic, then queue social pointing at those rather than at whatever you happened to publish most recently. Add your docs or notes and the ideas board fills itself from material you’ve already written.

The general shape: Buffer is the distribution end. Its value multiplies with whatever sits upstream holding the content and the evidence about what’s working.

The Short Version

Connect via OAuth. Call get_account first and confirm the organization and timezone. Create as drafts until a workflow has earned your trust. Tag everything. Use the named tools until they genuinely don’t cover it, then introspect the schema. And put something upstream of it — a CMS, an analytics source — because the scheduling was never the hard part.