Buffer Legacy API Shutdown (Feb 1, 2027): How to Migrate

Buffer retires its legacy REST API on 1 February 2027. What stops working, the endpoint map to Buffer's GraphQL API or a REST API, and a tested script.

A calendar page marked 1 February 2027 beside an old API endpoint being rerouted to a new one

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: createPost takes a single channelId; to post to several channels you send one mutation per channel. Buffer also documents createContentItem, which creates posts for several channels in one call and validates them all or none.
  • Scheduling per post: a mode of addToQueue, shareNow or customScheduled (with a dueAt UTC 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 to PostActionSuccess, so your code checks the body, not the status. Buffer's API limits page adds that an exceeded rate limit returns HTTP 429 with RATE_LIMIT_EXCEEDED and a Retry-After header.
  • Pagination by cursor (first, after, pageInfo.endCursor) instead of pages, and sent posts older than two years are not returned.
  • Gone: move_to_top and 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. date and time are read in it. Leave it out and they are read in a default zone from your settings, which is not necessarily UTC like Buffer's dueAt, so a script ported as is can post at the wrong hour.
  • The upload runs once, the post can retry. The Idempotency-Key is a hash of the request body, so a retry after a timeout returns the first answer with Idempotent-Replayed: true instead of posting twice. A stored answer includes errors: if a 422 was 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 a 409.
  • Errors are HTTP status codes. 401 bad token, 404 wrong workspace UUID, 409 duplicate, 422 validation (with an errors object per field), 429 rate 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/mcp in 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

  1. 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.
  2. Export what is queued. While the legacy API answers, read pending posts per profile with /profiles/:id/updates/pending.json and save them.
  3. 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.
  4. 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.
  5. 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

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

Related guides

Try PostBoost free

API, webhooks and MCP on every plan, including Free. No credit card required.