Guide · By PostBoost team · · Markdown
Buffer retires its legacy REST API on 1 February 2027. After that date, calls to https://api.bufferapp.com/1/ stop returning data, and a second planned brownout hits on 9 December 2026. If a script, an n8n workflow, a Make scenario or a Zapier webhook step calls those endpoints, you have two ways forward: move it to Buffer's new GraphQL API, or move it to another REST API. Either way the work is the same three jobs for most people: list channels, upload an image, schedule a post. This guide maps each one and ends with a tested script.
Only the old API is ending. Buffer itself is not shutting down, and its new API is, by its own account, on every current plan.
What Buffer announced, with dates
Everything in this table comes from Buffer's own announcement (27 July 2026) and its migration guide.
| Date | What happens |
|---|---|
| 27 July 2026 | Retirement announced; creating new clients on the legacy API is already closed |
| 11 November 2026 | First brownout (planned outage of the legacy API) |
| 9 December 2026 | Second brownout |
| 1 February 2027 | Legacy REST API retired; requests to legacy endpoints stop returning data |
Buffer says legacy endpoints send Deprecation and Sunset headers plus a Link header pointing to the migration guide, and that clients still on the old API get a notice before each brownout. If one of your automations failed for no clear reason on 11 November, check it first.
Find out if you are affected
The legacy API has a recognisable shape: the host api.bufferapp.com, a /1/ version prefix, paths ending in .json, and the token passed as an access_token query parameter. Look for it in:
- Scripts and cron jobs:
grep -rn "api.bufferapp.com" .in each repository. - n8n: HTTP Request nodes whose URL starts with
https://api.bufferapp.com/1/. - Make: HTTP modules with the same URL.
- Zapier: Webhooks by Zapier steps that call Buffer. A ready-made app step is the app maker's job to migrate; ask them if you are unsure.
- Plugins (WordPress, CMS) that post to Buffer: check the plugin's changelog for a move to the new API.
Buffer's new API lives at a different host (api.buffer.com) and uses GraphQL, so anything still on api.bufferapp.com needs changing.
What changes in Buffer's new API
Buffer's replacement is a GraphQL API at https://api.buffer.com. Every request is a POST with a JSON body holding a query. The main differences from the legacy API, per Buffer's migration guide:
- Auth: an API key from Buffer's Settings > API sent as
Authorization: Bearer, or OAuth 2.0 with PKCE for apps acting for other Buffer users. Legacy tokens went in the query string. - Names: profiles are now channels, and updates are now posts.
- One channel per post:
createPosttakes a singlechannelId; to post to several channels you send one mutation per channel. Buffer also documentscreateContentItem, which creates posts for several channels in one call and validates them all or none. - Scheduling per post: a
modeofaddToQueue,shareNoworcustomScheduled(with adueAtUTC timestamp) replaces the recurring time slots you managed with/profiles/:id/schedules. - Errors in the body: GraphQL answers HTTP 200 and returns typed error results (
MutationError,InvalidInputError,LimitReachedError) next toPostActionSuccess, so your code checks the body, not the status. Buffer's API limits page adds that an exceeded rate limit returns HTTP 429 withRATE_LIMIT_EXCEEDEDand aRetry-Afterheader. - Pagination by cursor (
first,after,pageInfo.endCursor) instead of pages, and sent posts older than two years are not returned. - Gone:
move_to_topand queue shuffling,/links/shares.json(Buffer points to dashboard analytics) and/info/configuration.json.
A scheduled post in the new API looks like this (field names from Buffer's example):
mutation {
createPost(input: {
channelId: "your_channel_id"
text: "Our winter menu starts today."
schedulingType: automatic
mode: customScheduled
dueAt: "2026-12-01T09:30:00Z"
}) {
... on PostActionSuccess { post { id status } }
... on MutationError { message }
}
}
Buffer's limits are shared by all your API keys and MCP connections, so a second key adds no requests:
| Buffer plan | API keys | Per 15 min | Per 24 h | Per 30 days |
|---|---|---|---|---|
| Free | 1 | 150 | 600 | 1,000 per channel, up to 3,000 |
| Essentials | 3 | 450 | 1,800 | 3,000 per channel, up to 30,000 |
| Team | 5 | 1,500 | 6,000 | 10,000 per channel, up to 100,000 |
Source: Buffer developer docs, API limits, checked 15 November 2026.
If your posts already live in Buffer's app and your team works there every day, migrating to the GraphQL API is the natural path. If you were mostly using Buffer as a pipe for an automation, this is also a good moment to choose the API you would pick today. The free social media tool picker shows which of nine tools, Buffer and PostBoost included, offer a REST API with an OpenAPI spec, an official SDK, webhooks or an MCP server.
The endpoint map: legacy, Buffer GraphQL, REST
The common jobs side by side. The PostBoost column is a REST API with an OpenAPI spec; every path sits under https://postboost.co/app/api/{workspaceUuid}.
| Job | Buffer legacy REST | Buffer GraphQL | PostBoost REST |
|---|---|---|---|
| Sign in | ?access_token= query parameter |
Authorization: Bearer API key |
Authorization: Bearer access token |
| Who am I / organisation | GET /user.json |
account query |
Workspace UUID from the dashboard URL |
| List channels | GET /profiles.json |
channels(input: { organizationId }) |
GET /accounts |
| One channel | GET /profiles/:id.json |
channel(input: { id }) |
GET /accounts/{accountUuid} |
| Create a post | POST /updates/create.json with profile_ids[] |
createPost, one channelId per call |
POST /posts with an accounts array |
| Schedule for a time | scheduled_at |
mode: customScheduled + dueAt (UTC) |
schedule: true + date, time, timezone |
| Post now | /updates/:id/share.json |
mode: shareNow |
schedule_now: true |
| Add to the queue | default on create | mode: addToQueue |
queue: true (each account gets its own slot) |
| Attach an image | media[photo] |
assets list with an image URL |
POST /media/remote/initiate, then the media id in content[].media |
| Pending posts | /profiles/:id/updates/pending.json |
posts with status: [scheduled] |
GET /posts, each post carries a status |
| Errors | HTTP status codes | HTTP 200 + typed error results | HTTP status codes + JSON message and errors |
| Safe retries | not in the migration guide | not documented | Idempotency-Key header, replayed for 24 hours |
You can build the create-post request for curl or any of nine SDK languages without writing it by hand in the free social media API request builder.
A tested migration script (Python)
This replaces the three legacy calls most scripts make. It needs requests and three environment variables: POSTBOOST_API_TOKEN (from your avatar > Access Tokens > Create Token in the dashboard), POSTBOOST_WORKSPACE (the workspace UUID from the dashboard URL) and, for testing against a local mock, an optional POSTBOOST_API_BASE.
import hashlib, json, os, requests
BASE = os.environ.get("POSTBOOST_API_BASE", "https://postboost.co/app/api")
API = f"{BASE}/{os.environ['POSTBOOST_WORKSPACE']}"
HEADERS = {"Authorization": f"Bearer {os.environ['POSTBOOST_API_TOKEN']}", "Accept": "application/json"}
def call(method, path, body=None):
headers = dict(HEADERS)
if body is not None: # same request body = same key, so a retry replays instead of repeating
headers["Idempotency-Key"] = hashlib.sha256(json.dumps(body, sort_keys=True).encode()).hexdigest()
r = requests.request(method, API + path, json=body, headers=headers, timeout=60)
if r.status_code >= 400:
raise RuntimeError(f"{method} {path} -> {r.status_code}: {r.text[:500]}")
return r.json()
def list_accounts(): # was GET /profiles.json
return {a["id"]: f'{a["provider"]} @{a["username"]}' for a in call("GET", "/accounts")["data"]}
def upload_from_url(url): # was media[photo] on /updates/create.json
d = call("POST", "/media/remote/initiate", {"url": url})
if d["status"] != "completed": # files over 10 MB download in the background
raise RuntimeError(d.get("error") or f"poll /media/remote/{d['download_id']}/status")
return int(d["media"]["id"])
def schedule_post(account_ids, text, date, time, timezone, media_ids=()): # was POST /updates/create.json
item = {"body": text, "media": list(media_ids)}
return call("POST", "/posts", {
"accounts": account_ids,
"versions": [{"account_id": 0, "is_original": True, "content": [item]}],
"schedule": True, "date": date, "time": time, "timezone": timezone,
})
if __name__ == "__main__":
print(list_accounts())
image = upload_from_url("https://example.com/winter-menu.jpg")
post = schedule_post([12, 15], "Our winter menu starts today.", "2026-12-01", "09:30", "Europe/London", [image])
print(post["uuid"], post["status"])
Run it once with only print(list_accounts()) to get your account ids (the integer id, not the uuid), then put those ids into schedule_post. A successful run prints the new post's uuid and scheduled. We ran the script against a local mock of these three endpoints, including a validation error (422 with the field in errors) and an image over 10 MB (the background-download branch).
What it does differently from a legacy Buffer script:
- One request for several accounts.
accounts: [12, 15]schedules the same post to both; you do not loop per channel. To give one network its own text, add a version for that account id next to the original. - Always send
timezone.dateandtimeare read in it. Leave it out and they are read in a default zone from your settings, which is not necessarily UTC like Buffer'sdueAt, so a script ported as is can post at the wrong hour. - The upload runs once, the post can retry. The
Idempotency-Keyis a hash of the request body, so a retry after a timeout returns the first answer withIdempotent-Replayed: trueinstead of posting twice. A stored answer includes errors: if a422was caused by something outside the request (say, an account that needed reconnecting), change the request or wait 24 hours before sending the same body again. The duplicate guard also refuses the same content for the same account within 24 hours with a409. - Errors are HTTP status codes.
401bad token,404wrong workspace UUID,409duplicate,422validation (with anerrorsobject per field),429rate limit or an account's daily cap. See error handling.
Limits and cost on the PostBoost side
Every PostBoost plan, including Free, includes the REST API with no per-request fees and no monthly call quota; the API accepts up to 60 requests per minute, and scheduled posts have a daily cap per account and network (rate limits). The one metered network is X, which bills every API post: each plan includes a monthly number of X posts, explained in X API pricing.
To compare the two products beyond the API (plans, channels, MCP, webhooks), see PostBoost vs Buffer.
If you do not write code
- n8n: replace the HTTP Request node's URL and body with the PostBoost calls above, or give an AI Agent node the PostBoost MCP tools; the n8n guide covers both.
- Zapier and Make: PostBoost's apps for both are pending review, so for now call the REST API from Webhooks by Zapier or Make's HTTP module (Zapier and Make guide).
- An AI assistant: connect
https://postboost.co/mcpin Claude, ChatGPT or Cursor and ask for the post in plain words; the free MCP config generator writes the client config. Social media API vs MCP explains when each fits.
A migration plan that beats the deadline
- Before 9 December 2026: list every place that calls
api.bufferapp.com(search above). The brownout will show you any you missed, but on a day you did not choose. - Export what is queued. While the legacy API answers, read pending posts per profile with
/profiles/:id/updates/pending.jsonand save them. - Pick the target per job: Buffer GraphQL if the team stays in Buffer's app, or a REST API if the job is an automation you own end to end.
- Port one job, test it, then the rest. In PostBoost, connect the same social accounts first (each network's own sign-in), then schedule a test post a few days ahead and delete it once it looks right.
- Switch over well before 1 February 2027 and remove the old token from your scripts and secrets.
Do this in PostBoost
Free tools for this guide
Free tool
Social media tool picker
Tick what you need, such as a team dashboard, REST API, SDKs, MCP, webhooks, a free plan or a Zapier app, and see which social media tools match. Free.
Free tool
Social media API request builder
Build a create-post request for the PostBoost social media API and copy it as curl, Python, Node.js, PHP, Go, Ruby, Java, C#, Rust or the CLI.
Free tool
MCP server config generator for social media
Get the exact MCP setup to connect Claude, ChatGPT, Claude Code, Cursor, VS Code, Codex, Gemini CLI or n8n to PostBoost's social media MCP server.
FAQ
When does Buffer's legacy API shut down?
Buffer retires its legacy REST API on 1 February 2027. It announced this on 27 July 2026, planned two brownouts before then (11 November and 9 December 2026), and says requests to the legacy endpoints stop returning data after the retirement date.
Is Buffer shutting down?
No. Only the old REST API at api.bufferapp.com ends. Buffer's app keeps running, and its replacement API is a GraphQL API at api.buffer.com that Buffer says is available on every current plan, including Free.
How do I know if I use the legacy Buffer API?
Search your code, n8n workflows, Make scenarios and Zapier webhook steps for api.bufferapp.com or an access_token query parameter. Legacy endpoints end in .json, such as /1/updates/create.json or /1/profiles.json. Buffer says legacy responses carry Deprecation and Sunset headers.
What replaces updates/create.json in Buffer's new API?
The createPost GraphQL mutation. It takes one channelId per call, and a mode of addToQueue, shareNow or customScheduled with a dueAt timestamp. To create posts for several channels in one call, Buffer documents a separate createContentItem mutation.
Can I switch to a REST API instead of GraphQL?
Yes. In PostBoost, GET /{workspaceUuid}/accounts replaces /profiles.json, and one POST /{workspaceUuid}/posts schedules a post to several accounts at once with date, time and timezone fields. Errors come back as HTTP status codes, and an Idempotency-Key header makes retries safe.
Can I move my scheduled Buffer posts over automatically?
There is no shared format between schedulers. While the legacy API still answers, you can read your pending posts per profile with /profiles/{id}/updates/pending.json (or the posts query in Buffer's GraphQL API) and recreate the ones due after your cutover date with the new API.
Sources
- Buffer: Buffer's Legacy REST API is being fully retired on February 1, 2027 (2026-07-27)
- Buffer developers: Migrating from the REST API
- Buffer developers: Create a scheduled post (example)
- Buffer developers: Content items
- Buffer developers: API limits
- Buffer: Build any automation for social (API page)
- PostBoost docs: quickstart
- PostBoost docs: rate limits
- PostBoost docs: error handling
- PostBoost API reference: initiate remote upload