Back
Vulnerabilities 7 min read

Vulnerability in Instagram Ads | Bypassing the Ad Account Creation Limit via the Boost-on-Web pro2pro Controller

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:

Replay Request fetch() with new flow_id POST /b/<MEDIA_ID>/?…&promote
credentials: include
pro2pro Controller boost.on.web.async.controller Provisions a backing ad account
HTTP 200 · no limit check
Business Portfolio + 1 new ad account same portfolio, count climbs
repeat ↻ change flow_id
ad_account_creation_limit never enforced
One replayable request — on each call another ad account appeared under the same portfolio. Diagram is illustrative, reconstructed from my recording of the flow.

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.