Background Removal API Pricing: Cost per Usable Image

The current background removal API pricing for mj-v7-remove-bg is 88 credits, or $0.088 per completed request, when checked on September 3, 2026. That is the right starting number for a request budget. It is not automatically the cost of one usable cutout.

A completed image can still have a halo, lose a handle opening, flatten a shadow, or arrive in a format that the next service cannot accept. This guide shows how to call the route, poll it safely, inspect the settled charge, and calculate cost per image that actually passes review.

TL;DR

• The live estimator returned 88 credits ($0.088) per completed mj-v7-remove-bg request on September 3, 2026. One credit is $0.001.^[3]
• The request takes exactly one public HTTP(S) URL. It does not take a prompt, resolution, speed, or parent task ID.^[4]
• The operation is asynchronous: submit once, save the returned task ID, and poll the task endpoint. Polling does not consume credits.^[5]
• Budget with total settled cost / accepted outputs, not the number of files submitted. At an 80% acceptance rate, an $0.088 request becomes $0.11 per usable image.
• A failed task with usage.credits: 0 was refunded. A completed result that your team rejects for poor edges was still completed work, so include it in your accepted-image calculation.^[5]
• Run a small test set drawn from your own catalog before committing volume. One clean product photo says little about hair, glass, low contrast, or objects with holes.

Why the quoted price is rarely the useful number

Developers are not short of background-removal price claims. They are short of numbers that survive contact with their own images.

One r/FlutterDev question asked for a cheaper way to remove backgrounds from uploaded app images after the author found remove.bg too expensive. The replies quickly moved beyond sticker price: people discussed output quality, response time, high-resolution processing, file type, base64 handoff, and the cost of processing thousands of images.^[1] A separate r/SaaS thread asked whether developers would trade a broad feature set for a focused background-removal service advertised at roughly $0.001 per image.^[2]

Those posts are demand evidence, not a verified price comparison. Community figures may describe an old rate, a promotional tier, an author's own product, or a workload with different resolution and latency requirements. The useful question is narrower:

cost per usable image = total settled API cost / images that pass review

That denominator changes the decision. A cheap endpoint that damages fine edges can cost more than a higher-priced one once reruns and manual cleanup are included.

What the current background removal API price buys

The live Midjourney V7 model page lists Remove BG as a lightweight edit. The current request estimate settles in whole credits, and the live estimate for the required payload is 88 credits.^[3] Because one credit equals $0.001, use $0.088 in a budget.

You may see the operation displayed as $0.0873 in a detailed price label. Do not use that fractional figure to reconcile a credit balance. The public pricing table and estimator show the payable unit as 88 whole credits, or $0.088. Check the live model page again before a large run because pricing can change.

The API subtotal excludes the work around the call:

• hosting the source at a URL the service can fetch;
• downloading and storing the result;
• validating transparency, dimensions, and file compatibility;
• human review or automated quality checks;
• completed outputs that fail your acceptance rules;
• resizing, color correction, shadow reconstruction, or later compositing.

For a prototype, those costs may be negligible. At catalog scale, they belong in the same spreadsheet as the API line item.

One source URL, no prompt and no parent task

mj-v7-remove-bg is simpler than the other Midjourney V7 edit operations. It does not chain from a previous generation. Send the image you already have in image_urls.^[4]

The schema is strict. Adding fields copied from another image model is not a harmless no-op; it makes the request invalid. Base64 strings, data: URLs, local paths, and authenticated browser-only links are also the wrong input. Upload the source to storage you control and confirm that it loads without a cookie or login.

Here is the complete cURL request:

curl https://reapi.ai/api/v1/images/generations \
  -H "Authorization: Bearer $REAPI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mj-v7-remove-bg",
    "image_urls": [
      "https://your-cdn.example/catalog/source-product.png"
    ]
  }'

A valid submission returns a task record in processing state. Save its id. The final image does not arrive in the POST response.

Submit once, then poll with a deadline

The safest beginner implementation has two separate actions: one POST that creates the job, followed by bounded GET requests that read its state. Do not put the POST inside the polling loop.

This Node.js example polls every 2.5 seconds and uses a 15-minute local deadline. The task reference recommends a two-to-three-second cadence and explains that in-flight task reads are cached, so faster polling adds request pressure without making the image finish sooner.^[5]

const API_BASE = 'https://reapi.ai/api/v1';
const API_KEY = process.env.REAPI_API_KEY;
const sourceUrl = process.argv[2];

if (!API_KEY) throw new Error('Set REAPI_API_KEY');
if (!sourceUrl) throw new Error('Pass one public source image URL');

const headers = {
  Authorization: `Bearer ${API_KEY}`,
  'Content-Type': 'application/json',
};

async function readJson(response) {
  const body = await response.json();
  if (!response.ok) {
    const code = body.error?.code ?? response.status;
    const message = body.error?.message ?? 'Request failed';
    throw new Error(`${code}: ${message}`);
  }
  return body;
}

const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

async function getTask(taskId) {
  for (let attempt = 0; attempt < 4; attempt += 1) {
    let response;
    try {
      response = await fetch(`${API_BASE}/tasks/${taskId}`, {
        headers: { Authorization: `Bearer ${API_KEY}` },
        signal: AbortSignal.timeout(15_000),
      });
    } catch (error) {
      if (attempt === 3) throw error;
      await sleep(1000 * 2 ** attempt);
      continue;
    }

    if (response.status === 429) {
      const seconds = Number(response.headers.get('retry-after'));
      await response.body?.cancel();
      await sleep(Number.isFinite(seconds) ? seconds * 1000 : 5000);
      continue;
    }

    if ([502, 503, 504].includes(response.status)) {
      await response.body?.cancel();
      await sleep(1000 * 2 ** attempt);
      continue;
    }

    return readJson(response);
  }

  throw new Error(`Task ${taskId} could not be read after transient errors`);
}

async function removeBackground(imageUrl) {
  const submitted = await readJson(
    await fetch(`${API_BASE}/images/generations`, {
      method: 'POST',
      headers,
      body: JSON.stringify({
        model: 'mj-v7-remove-bg',
        image_urls: [imageUrl],
      }),
      signal: AbortSignal.timeout(30_000),
    })
  );

  const deadline = Date.now() + 15 * 60 * 1000;

  while (Date.now() < deadline) {
    await sleep(2500);
    const task = await getTask(submitted.id);

    if (task.status === 'completed') {
      const urls = task.output?.image_urls ?? [];
      if (urls.length === 0) {
        throw new Error('Task completed without an image URL');
      }
      return {
        taskId: task.id,
        imageUrls: urls,
        credits: task.usage?.credits,
      };
    }

    if (task.status === 'failed') {
      const code = task.error?.code ?? 'UNKNOWN_TASK_ERROR';
      const message = task.error?.message ?? 'Background removal failed';
      const credits = task.usage?.credits ?? 'unknown';
      throw new Error(
        `${code}: ${message}; task=${task.id}; settled_credits=${credits}`
      );
    }
  }

  throw new Error(`Polling deadline reached for task ${submitted.id}`);
}

removeBackground(sourceUrl)
  .then(console.log)
  .catch((error) => {
    console.error(error.message);
    process.exitCode = 1;
  });

Run it with:

REAPI_API_KEY=rk_live_xxx node remove-background.mjs \
  https://your-cdn.example/catalog/source-product.png

In production, write the task ID to your database before returning from the submit handler. A worker can then resume polling after a process restart. Keep the API key on the server; never place it in browser JavaScript or a mobile app bundle.

What one failed live request actually cost

We submitted one mj-v7-remove-bg request while checking this guide on September 3, 2026, using an owned mug photo. The API accepted the strict payload as task task_01a065b32dbe771eb5babd28de9b38d9, but it later ended in failed state with error code 80003 and the message Service authentication failed. It returned no output and usage.credits: 0, so its settled cost was $0, not $0.088.

We did not resubmit the unchanged request just to manufacture a successful example. This single run confirms the task and refund path; it says nothing about cutout quality, file type, dimensions, alpha support, or normal completion time. The 88-credit figure above remains the live estimate for a request that completes. Always read the terminal task instead of multiplying submission count by the advertised rate.^[5]

Turn request price into cost per usable image

Start with an acceptance rule, not a percentage you hope to achieve. Then measure the percentage on a sample from the workload you intend to ship.

If each completed request produces one candidate, the planning equation is:

usable-image cost = $0.088 / acceptance rate

The table below contains scenarios, not measured model quality:

Use settled task data for the numerator. The task response exposes usage.credits in every state. processing plus zero means billing has not settled. completed shows the charged credits. failed plus zero means the reservation was refunded; a positive value means a documented charge was retained.^[5]

This distinction prevents two accounting errors. Do not count a refunded provider failure as paid output, and do not erase a completed but ugly cutout from spend. It still consumed a paid request.

Decide what “usable” means before the test

A visual glance is too vague for a repeatable benchmark. Write a short rubric before submitting the sample, then apply the same checks to every result.

Transparency and edge integrity

Open the downloaded file in a tool that shows an alpha checkerboard. A white background is not transparency. Inspect the full silhouette at 100% and 400% zoom for white or dark halos, missing pixels, and chunks of the old background.

Holes, fine detail, and difficult materials

Include examples with handle openings, straps, spokes, loose hair, fur, and foliage. Add glass, translucent packaging, glossy metal, and low-contrast subject edges if those appear in your real catalog. A model that passes a dark mug on white may still fail a clear bottle or pale object on beige.

Product details and shadows

Confirm that labels, printed text, thin attachments, and the product outline did not change. Decide whether a contact shadow should be kept, softened, or removed. Different destinations need different answers, so “shadow removed” is not automatically a pass.

File contract

Record MIME type, extension, width, height, byte size, alpha presence, and the number of returned URLs. The public contract returns output.image_urls, but it does not promise a specific extension or pixel size for this operation. Test the real file against the next API, design tool, or marketplace importer in your pipeline.

A useful pilot is large enough to represent the hard cases, not just the easy ones. Ten to thirty owned images can expose obvious incompatibilities. A final procurement benchmark should follow the distribution of your actual catalog.

Retry failures without creating a cost loop

Retry rules should use the error, not frustration. The public error reference separates invalid input, authentication, insufficient balance, rate limits, capacity failures, and terminal workflow failures.^[6]

Keep the submit action outside automatic polling retries. Once a POST returns a task ID, every later check should be a GET for that task. For a completed image that fails your rubric, a second identical request may reproduce the same edge problem. Changing the input crop, contrast, or preprocessing is more useful than an unbounded rerun.

Download accepted files to your own storage as soon as the task completes. The task documentation says output URLs are rehosted on the CDN but does not guarantee long-term retention.^[5]

Hosted route versus an official Midjourney API

mj-v7-remove-bg is a hosted route exposed through reAPI. It should not be described as Midjourney's official public API. Midjourney's current community guidelines say it does not generally provide an API and prohibits unauthorized automation except for rare, explicitly granted cases.^[7]

That distinction matters during procurement. Review the hosted service's own contract and acceptable-use terms instead of assuming that a model label creates an official vendor relationship. The separate guide Does Midjourney Have an API? covers that question in detail; this article stays focused on the callable route and its cost.

FAQ

Does mj-v7-remove-bg need a previous Midjourney task?

No. It is a direct-image edit. Pass one public image URL in image_urls; do not send task_id or model_params.^[4]

Can I send a base64 image?

No. The request schema accepts one public HTTP(S) URL. Upload the file first, then send a URL that the service can fetch without your browser session.

Is the current price $0.0873 or $0.088?

Use $0.088 for billing estimates. The operation may appear as $0.0873 in a detailed display, but the live estimator returns 88 whole credits and one credit equals $0.001.^[3]

Does one request return four background-removed images?

Do not budget on that assumption. Four images per request describes the base Midjourney V7 generation. The direct Remove BG contract takes one source image and returns an image URL array, but it does not promise four cutouts. Inspect the terminal task's array length in your pilot.^[4]

Does the API always return a transparent PNG?

The current public contract promises image URLs, not a particular extension, MIME type, or alpha-channel guarantee. Download a real result and verify alpha before building a PNG-only downstream workflow.

Does polling cost credits?

No. Polling a task does not consume credits. Poll every two to three seconds and stop at a deadline that suits your application.^[5]

Are failed background-removal tasks charged?

Read usage.credits on the terminal task. A failed task with zero credits was fully refunded. The generic task contract allows a positive retained charge in some model-specific post-generation safety cases, so do not infer the bill from status alone.^[5]

What will 1,000 usable images cost?

At a 100% acceptance rate, 1,000 requests cost $88 at the current rate. At 80% acceptance, reaching 1,000 usable files requires 1,250 requests and costs $110, before storage and review. Replace the assumed rate with your measured pilot.

Choose by accepted cost, not sticker price

The current background removal API pricing is straightforward at the request level: 88 credits, or $0.088. The production decision starts after that. Test the edges and file contract your application actually needs, read settled usage from every task, and divide total spend by outputs that pass a fixed rubric.

Start with the Midjourney V7 API reference, run a small owned-image pilot, and keep the task polling reference next to your implementation. That gives you a defensible cost per usable image instead of a price claim copied from a landing page or forum comment.

References

1. Reddit r/FlutterDev. Free background remover API recommendations. Retrieved September 3, 2026 from reddit.com/r/FlutterDev/comments/1gkaff1
2. Reddit r/SaaS. Would you use a background removal API if it was 900% cheaper than the big names. Retrieved September 3, 2026 from reddit.com/r/SaaS/comments/1ou4hp1
3. reAPI. Midjourney V7 model page and live pricing. Retrieved September 3, 2026 from reapi.ai/models/midjourney-v7
4. reAPI. Midjourney V7 API reference. Retrieved September 3, 2026 from reapi.ai/docs/midjourney-v7
5. reAPI. Tasks: polling, usage, output, and refund semantics. Retrieved September 3, 2026 from reapi.ai/docs/api/tasks
6. reAPI. API error codes and retry guidance. Retrieved September 3, 2026 from reapi.ai/docs/api/errors
7. Midjourney. Community Guidelines: unauthorized automation and third-party apps. Retrieved September 3, 2026 from docs.midjourney.com/hc/en-us/articles/32013696484109-Community-Guidelines