# Amazon FBA Fees Calculator: Profit, Margin & ROI per ASIN (`moggedhq/amazon-fba-calculator`) Actor

Calculate Amazon FBA fees and profit per unit for ASINs at your cost price, e.g. a yoga mat or phone case. About $0.018 per ASIN. Referral, fulfillment, storage, net profit, margin, ROI and break-even from Amazon's public Revenue Calculator. US. No login.

- **URL**: https://apify.com/moggedhq/amazon-fba-calculator.md
- **Developed by:** [mogged](https://apify.com/moggedhq) (community)
- **Categories:** E-commerce, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $14.40 / 1,000 asin calculations

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Amazon FBA Fees Calculator: Profit, Margin & ROI per ASIN

For Amazon US sellers comparing supplier costs, planned prices and FBA profit across a product list. **About $0.018 per successful ASIN calculation.** Checking 50 products costs about $0.90 before plan discounts, plus the small Actor start fee. No Amazon login, seller account, API key or account cookies are required.

Paste ASINs or product URLs and your costs. Get profit, margin, ROI, Amazon fees and a break-even price checked against Amazon's public Revenue Calculator.

### What you get

| Field | What it tells you |
|---|---|
| `verdict` | A readable per-unit profit or loss statement, with whole-number margin and ROI |
| `asin`, `productTitle`, `productUrl` | The exact product that Amazon matched |
| `sellingPrice`, `priceSource` | Your planned price, or the current featured-offer item price |
| `referralFee` | Amazon's category-dependent referral fee at that price |
| `fbaFulfillmentFee` | The complete estimated FBA fulfillment fee, including the fuel surcharge |
| `baseFulfillmentFee`, `fuelSurcharge` | The separate components Amazon exposes; do not add the surcharge twice |
| `storageFee`, `storageSeason` | Allocated storage per unit sold, using the chosen month's rates |
| `closingFee`, `digitalServicesFee` | Additional selling-fee lines when Amazon returns them |
| `totalAmazonFees`, `totalCostPerUnit` | Amazon fees, then Amazon fees plus your costs |
| `netProfit`, `marginPercent`, `roiPercent` | Per-unit economics with numeric percentages for spreadsheets |
| `breakEvenPrice`, `breakEvenProfit` | The lowest checked cent with non-negative estimated profit |
| `buyBoxSeller`, `shipsFrom`, `fulfillmentMethod` | Public featured-offer context; the model itself always calculates FBA |
| `category`, `categoryCode` | Public catalog category information |
| `feeDate`, `feeSource`, `feeSourceUrl`, `checkedAt` | The calculation date, original source and retrieval timestamp |
| `peakFulfillmentApplies`, `futureFulfillmentFees` | Whether peak fulfillment applies and any announced future FBA amount |
| `productDetails` | Optional public item/package dimensions, weight and browse path when available |
| `recordType`, `status`, `note` | Distinguish paid calculations, free notes and the free summary |

Every run saves a **SUMMARY** record with the best and worst margins and a readable **REPORT.html**. The dataset has separate profit, fees and source views. Export JSON, CSV, Excel or another supported dataset format from Apify. In an integration, filter for `recordType = CALCULATION` before adding the rows to a product-cost spreadsheet.

### A real example

On 14 October 2026, a cloud run checked `B0D5CLSMFB`, an Anker 10,000 mAh power bank, using a $6 product cost and the $23.99 public featured-offer price. It returned:

> Profit $10.45 per unit (44% margin, 174% ROI) at $23.99: referral $3.60, FBA $3.92, storage $0.02.

The numerical margin was 43.54%, ROI was 174.09%, and break-even was $11.71. The $3.92 fulfillment fee included a $0.13 fuel surcharge. Amazon also returned an announced $4.14 fulfillment amount for 15 October 2026. These are dated observations, not promises that this ASIN will keep the same price or fees.

One paced sample calculation finished in 7.2 seconds. An earlier run with a source retry took 56 seconds. The Actor starts at most one ASIN every three seconds and sends one request at a time. Break-even checks, optional product-page details and retries add time, so large jobs can take longer than three seconds per ASIN. Run one job at a time for a product list rather than launching many overlapping copies.

### When to use it

Compare wholesale quotes, check planned prices, identify losses, model holiday fees or allocate storage using stock turnover. This Actor does not predict sales, authenticity, selling eligibility or Buy Box wins.

### How to use it

1. Enter US ASINs or product URLs. Duplicates are removed.
2. Enter a common cost or per-ASIN costs. Add shipping and other expenses where relevant.
3. Run, compare verdicts, then export the dataset or open the report. Check free notes for unavailable ASINs.

Set Apify's maximum charge before larger jobs. A sample calculation costs less than $0.02 at the base rate.

### Inputs

| Input | Default | Example and meaning |
|---|---|---|
| `asins` | No automatic list | `["B0D5CLSMFB", "B002DYIZH6"]`; up to 1,000 unique ASINs |
| `urls` | Empty | `["https://www.amazon.com/dp/B0D5CLSMFB"]`; an alternative to ASINs |
| `costPerUnit` | Required for each calculation | `6`; your product acquisition cost in USD |
| `costPerUnitByAsin` | Empty | `{"B0D5CLSMFB": 6, "B002DYIZH6": 18}`; overrides the common cost |
| `sellingPrice` | Public featured-offer item price | `19.99`; the price you intend to charge |
| `sellingPriceByAsin` | Empty | `{"B0D5CLSMFB": 21.99}`; overrides the common selling price |
| `inboundShippingPerUnit` | `0` | `0.50`; your inbound transport cost per unit |
| `otherCostsPerUnit` | `0` | `1.20`; prep, ads, expected returns, placement or other costs you choose to include |
| `unitsPerMonth` | `1` | `100`; expected units sold per month, used for storage allocation |
| `averageInventoryUnits` | Same as monthly sales | `20`; average stock on hand, giving a stock-to-sales ratio of 0.2 in this example |
| `feeDate` | Today in US Eastern time | `2026-10-15`; announced future dates through 2027-01-14 are supported |
| `marketplace` | `US` | Only Amazon.com and USD are currently implemented |
| `includeProductDetails` | `false` | `true` adds a slower public-page read for optional dimensions and browse path |

Apify's form requires each field to have one type. Use the named `ByAsin` maps for per-product values rather than mixing numbers and objects in the form. Costs must be finite and non-negative. Selling price and monthly sales must be greater than zero. Missing costs, unsupported marketplaces and malformed ASINs produce free notes when they reach the Actor. Apify can reject a JSON type mismatch before a run starts.

```json
{
  "asins": ["B0D5CLSMFB", "B002DYIZH6"],
  "costPerUnitByAsin": {
    "B0D5CLSMFB": 6,
    "B002DYIZH6": 18
  },
  "inboundShippingPerUnit": 0.50,
  "otherCostsPerUnit": 0.75,
  "unitsPerMonth": 100,
  "averageInventoryUnits": 20
}
```

### How the calculations work

**Net profit** is price minus Amazon fees, product cost, inbound shipping and other costs. **Margin** is profit divided by price. **ROI** is profit divided by product cost plus inbound shipping plus other costs. Zero investment produces `null` ROI.

Storage equals Amazon's monthly estimate for one inventory unit multiplied by average inventory divided by monthly sales. Without an inventory input, the assumption is one month of storage per unit sold. Entering zero inventory deliberately models zero storage.

Arithmetic retains fractional-cent storage values. Currency outputs round to cents; numeric percentages keep two decimal places. Independently rounded fee lines can differ from the displayed total by one cent.

**Break-even** queries Amazon at candidate prices and checks fee bands around $10, $15, $20 and $50, including boundary cents and minimum referral fees. It returns the first non-negative cent in the earliest profitable band, keeping your costs and storage assumptions fixed.

### Current and peak-season fees

The source is **Amazon Revenue Calculator (public, signed out)**. Its fulfillment total already includes the fuel surcharge; the separate surcharge field is informational.

The published 2026 holiday fulfillment window is 15 October 2026 through 14 January 2027. Peak storage covers October through December. January can therefore have peak fulfillment and non-peak storage. Peak verdicts say `incl. peak`.

For future rates, `feeEffectiveDate` is Amazon's announced date. For current rates it is the retrieval date, explicitly labeled in `feeEffectiveDateMeaning`, not the original schedule start. `feeScheduleUrl` links to Amazon's schedule. Historical dates and dates beyond the implemented schedule produce free notes.

### Pricing and spending limits

| Successful calculations | Base calculation charge |
|---|---:|
| 1 | $0.018 |
| 10 | $0.18 |
| 50 | $0.90 |
| 100 | $1.80 |
| 1,000 | $18.00 |

The small Apify Actor start charge is additional: $0.00005 per GB, with a minimum of one start unit. Bronze calculations are $0.0171 each, Silver $0.0162 and Gold or higher $0.0144. Apify displays the rate for your plan before you run.

Only a successful ASIN calculation is charged. Invalid inputs, exact-match failures, source errors, duplicates and the summary do not incur a calculation charge. The start charge still applies to a run that only returns free notes. There is no separate default dataset-row charge, and the paid price includes the Actor's platform usage.

When the remaining budget cannot cover another calculation, the Actor stops cleanly and writes its summary. The ASIN count limit is 1,000 per run for all users; there is no smaller free-plan wall. Split larger catalogs into sequential jobs and keep the same cost assumptions if you want comparable results.

### Use through the API

For a small request, use the synchronous dataset endpoint. Keep the token in an environment variable:

```bash
curl -X POST \
  'https://api.apify.com/v2/acts/moggedhq~amazon-fba-calculator/run-sync-get-dataset-items?maxTotalChargeUsd=0.20' \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"asins":["B0D5CLSMFB"],"costPerUnit":6}'
```

Python:

```python
import os
import requests

response = requests.post(
    "https://api.apify.com/v2/acts/moggedhq~amazon-fba-calculator/run-sync-get-dataset-items",
    headers={"Authorization": "Bearer " + os.environ["APIFY_TOKEN"]},
    params={"maxTotalChargeUsd": 0.20},
    json={"asins": ["B0D5CLSMFB"], "costPerUnit": 6},
    timeout=300,
)
response.raise_for_status()
calculations = [row for row in response.json() if row["recordType"] == "CALCULATION"]
```

JavaScript:

```javascript
const response = await fetch(
  "https://api.apify.com/v2/acts/moggedhq~amazon-fba-calculator/run-sync-get-dataset-items?maxTotalChargeUsd=0.20",
  {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.APIFY_TOKEN}`,
      "Content-Type": "application/json"
    },
    body: JSON.stringify({asins: ["B0D5CLSMFB"], costPerUnit: 6})
  }
);
if (!response.ok) throw new Error(`Apify request failed: ${response.status}`);
const rows = await response.json();
```

For larger lists, use asynchronous runs and retrieve the dataset after completion. Tasks, schedules, webhooks, Make, Zapier and n8n accept the same inputs. Avoid overlapping jobs.

### Use with AI agents (MCP)

Connect an agent to [Apify MCP](https://mcp.apify.com) and ask it to find an Amazon FBA fees calculator. Give it your ASINs, cost prices and maximum spend. A useful request is:

> Calculate Amazon FBA fees and profit for B0D5CLSMFB at a $6 cost. Include referral, fulfillment, October storage, margin, ROI and break-even. Spend no more than $0.20 and explain any source-limit notes.

Agents should read the input schema and inspect `recordType` and `status` in results. This Actor requires no third-party AI key.

### Limits you should understand

Guests cannot see the package dimensions, shipping weight or exact size tier Amazon uses internally. Those fields remain null. Optional retail measurements are separate: item size is not automatically package size. No local-table fee is fabricated when Amazon cannot estimate an ASIN.

Some real listings are unavailable in the public calculator. On 14 October 2026, 48 of 50 varied physical ASINs matched; the other two also returned unrelated results in the guest UI. Those matches were rejected. Coverage changes over time.

Amazon can throttle the source. The Actor uses a stable guest proxy session, sequential requests, Retry-After and backoff up to about 60 seconds. Persistent limits stop the remaining list, with free notes. Check the calculation count even when the Apify run succeeds.

Tax, ads, returns, aged or low inventory, storage-utilization surcharges, inbound placement, prep and seller-plan subscriptions are not automatically modeled. Add your own costs. Featured FBM offers supply price context; this Actor models FBA.

### FAQ

**Are Seller Central credentials required?** No. Only signed-out public data is used.

**Can each ASIN have a different cost?** Yes: use `costPerUnitByAsin`. `sellingPriceByAsin` works the same way.

**Are other countries supported?** No. This version supports Amazon.com and USD only.

**Are low-price FBA rates included?** Amazon calculates the applicable fee at each requested selling price, including relevant low-price rates.

**Is fuel counted twice?** No. `fuelSurcharge` is already inside `fbaFulfillmentFee`.

**Why does storage differ from the UI?** The guest UI may initially select January-September. Compare the same season and inventory-to-sales ratio.

**Why did a valid listing return a note?** Exact matching, price or source access may be unavailable. A price override helps only when price is the missing value.

**Is break-even guaranteed profit?** It is an estimate under your entered costs. Additional charges or later fee changes alter the result.

**Why is ROI null?** Product, inbound shipping and other costs sum to zero.

**Are failed ASINs charged?** No calculation charge applies. The small run start charge is independent.

**Can I process hundreds of products?** Yes, up to 1,000. Use an asynchronous run, set a maximum charge and run lists sequentially.

Amazon FBA fees calculator, Amazon FBA profit calculator, referral fees, fulfillment fees, storage costs, margin, ROI and break-even price for US ASIN lists.

# Actor input Schema

## `asins` (type: `array`):

US Amazon ASINs to calculate, such as B0D5CLSMFB. Exact matches only. Duplicate ASINs and failures are free. Up to 1,000 unique ASINs.

## `urls` (type: `array`):

Alternative to ASINs. Paste amazon.com /dp/, /gp/product/ or /gp/aw/d/ product URLs. No account or cookies needed.

## `costPerUnit` (type: `number`):

What you pay for one unit, before inbound shipping. Required for a calculation; enter 0 only when the product costs you nothing. Use costPerUnitByAsin for different costs.

## `costPerUnitByAsin` (type: `object`):

Overrides costPerUnit for listed ASINs, e.g. {"B0D5CLSMFB": 6, "B002DYIZH6": 18}. Values are USD per unit.

## `sellingPrice` (type: `number`):

Your planned item selling price. Leave empty to use the current featured offer. Amazon fees and break-even use this price; shipping charged to an FBM buyer is not added.

## `sellingPriceByAsin` (type: `object`):

Planned selling prices in USD keyed by ASIN. Overrides the common sellingPrice.

## `inboundShippingPerUnit` (type: `number`):

Your cost to send each unit to Amazon. Default 0. Add inbound placement charges here or to otherCostsPerUnit if relevant.

## `otherCostsPerUnit` (type: `number`):

Optional per-unit advertising, prep, returns, inbound placement, tax or other seller-specific costs. Default 0. None are guessed.

## `unitsPerMonth` (type: `number`):

Used with averageInventoryUnits to allocate monthly storage. If averageInventoryUnits is omitted, one month of storage is assumed per unit sold.

## `averageInventoryUnits` (type: `number`):

Your average stock level. Storage per unit sold equals Amazon monthly storage per unit times this number divided by unitsPerMonth. Enter 0 only for a deliberate zero-storage scenario.

## `feeDate` (type: `string`):

ISO date, such as 2026-10-15. Default today in US Eastern time. Future dates supported through 2027-01-14 using announced API rates. October-December storage and fulfillment peak dates are separate.

## `marketplace` (type: `string`):

US only. Prices and costs are US dollars. Other marketplaces return a free note.

## `includeProductDetails` (type: `boolean`):

Optional, slower. Reads public item/package dimensions, weight and browse path when available. Item dimensions are never treated as package measurements. The API fee calculation does not require these fields.

## Actor input object example

```json
{
  "asins": [
    "B0D5CLSMFB"
  ],
  "costPerUnit": 6,
  "inboundShippingPerUnit": 0,
  "otherCostsPerUnit": 0,
  "unitsPerMonth": 1,
  "marketplace": "US",
  "includeProductDetails": false
}
```

# Actor output Schema

## `calculations` (type: `string`):

No description

## `fees` (type: `string`):

No description

## `report` (type: `string`):

No description

## `summary` (type: `string`):

No description

## `all` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "asins": [
        "B0D5CLSMFB"
    ],
    "costPerUnit": 6
};

// Run the Actor and wait for it to finish
const run = await client.actor("moggedhq/amazon-fba-calculator").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "asins": ["B0D5CLSMFB"],
    "costPerUnit": 6,
}

# Run the Actor and wait for it to finish
run = client.actor("moggedhq/amazon-fba-calculator").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "asins": [
    "B0D5CLSMFB"
  ],
  "costPerUnit": 6
}' |
apify call moggedhq/amazon-fba-calculator --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,moggedhq/amazon-fba-calculator"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/pzn5ibocAJOlyke4x/builds/iOlmF4oIeJTmayIQl/openapi.json