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

Published: 2026-11-17

**Key takeaways:** Buffer's legacy REST API (api.bufferapp.com/1/) stops returning data on 1 February 2027, after a brownout on 9 December 2026. Find every script or workflow that calls it, then move each job to Buffer's GraphQL API or a REST API: endpoint map and tested script below.

**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):

```graphql
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](/tools/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](/tools/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`.

```python
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](/docs/guardrails) 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](/docs/errors).

## 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](/docs/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](/learn/x-api-pricing).

To compare the two products beyond the API (plans, channels, MCP, webhooks), see [PostBoost vs Buffer](/compare/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](/docs/clients/n8n) 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](/docs/integrations/zapier-make)).
- **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](/tools/mcp-config-generator) writes the client config. [Social media API vs MCP](/learn/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

- [Agents and MCP](https://postboost.co/features/agents): Connect Claude, ChatGPT, Cursor or any MCP client.
- [Automations](https://postboost.co/features/automations): Add an RSS feed and new articles become drafts or queued posts.

## Free tools for this guide

- [Social media tool picker](https://postboost.co/tools/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.
- [Social media API request builder](https://postboost.co/tools/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.
- [MCP server config generator for social media](https://postboost.co/tools/mcp-config-generator): 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)](https://buffer.com/resources/legacy-rest-api-retired/)
- [Buffer developers: Migrating from the REST API](https://developers.buffer.com/guides/rest-migration.html)
- [Buffer developers: Create a scheduled post (example)](https://developers.buffer.com/examples/create-scheduled-post.md)
- [Buffer developers: Content items](https://developers.buffer.com/guides/content-items.md)
- [Buffer developers: API limits](https://developers.buffer.com/guides/api-limits.html)
- [Buffer: Build any automation for social (API page)](https://www.buffer.com/api)
- [PostBoost docs: quickstart](https://postboost.co/docs/quickstart)
- [PostBoost docs: rate limits](https://postboost.co/docs/rate-limits)
- [PostBoost docs: error handling](https://postboost.co/docs/errors)
- [PostBoost API reference: initiate remote upload](https://postboost.co/docs/api/initiate-remote-upload)

Canonical: https://postboost.co/learn/buffer-legacy-api-shutdown
