# Amazon Seller Fee Calculator – FBA & MFN (`buchmann/amazon-seller-fee-calculator`) Actor

- **URL**: https://apify.com/buchmann/amazon-seller-fee-calculator.md
- **Developed by:** [Buchmann GmbH](https://apify.com/buchmann) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Amazon Revenue Calculator

Get **Amazon FBA and MFN fee estimates** for any ASIN across **12 marketplaces** — Germany, UK, France, Italy, Spain, and more — in seconds.

This Actor uses Amazon's public **Seller Central Revenue Calculator**. Select a marketplace, enter **one ASIN per run**, and receive a structured **fee breakdown** with fulfillment costs, referral fees, storage, VAT, and estimated net proceeds. Export results to JSON, CSV, Excel, or automate via the Apify API.

Ideal for **Amazon FBA sellers**, agencies, arbitrage researchers, and anyone doing **Amazon product research** or **profitability analysis** without logging into Seller Central.

### Supported marketplaces

| Code | Marketplace |
| --- | --- |
| `DE` | Germany (Amazon.de) |
| `GB` | United Kingdom (Amazon.co.uk) |
| `FR` | France (Amazon.fr) |
| `IT` | Italy (Amazon.it) |
| `ES` | Spain (Amazon.es) |
| `NL` | Netherlands (Amazon.nl) |
| `SE` | Sweden (Amazon.se) |
| `PL` | Poland (Amazon.pl) |
| `IN` | India (Amazon.in) |
| `AE` | United Arab Emirates (Amazon.ae) |
| `TR` | Turkey (Amazon.com.tr) |
| `SA` | Saudi Arabia (Amazon.sa) |

### What you get

For each run (one ASIN):

- **Product snapshot** — title, image, current price, seller, condition, sales rank, review rating
- **FBA fees** — Amazon fulfillment, referral, storage, prep, VAT, and more
- **MFN fees** — merchant-fulfilled referral, closing fees, VAT, and more
- **Summary totals** — total Amazon fees and estimated net proceeds per fulfillment method

### Input

#### Minimal example

```json
{
  "marketplace": "DE",
  "asin": "B081ZCQP4P"
}
```

#### Recommended for reliable runs

Amazon may block datacenter traffic. Enable **Apify Proxy** with a **residential IP** matching your marketplace:

```json
{
  "marketplace": "DE",
  "asin": "B081ZCQP4P",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "DE"
  }
}
```

#### Input fields

| Field | Required | Description |
| --- | --- | --- |
| `marketplace` | No | Country code (`DE`, `GB`, `FR`, …). Default: `DE` |
| `asin` | Yes | One Amazon ASIN per run (10 characters) |
| `itemPrice` | No | Override item price in local currency |
| `shippingPrice` | No | MFN shipping charge (default: `0`) |
| `proxyConfiguration` | No | Apify Proxy settings. **Strongly recommended** |

### Output

Each run produces **one dataset record**. Records include a `success` boolean. Sample success and error outputs are defined in the [dataset schema](.actor/dataset_schema.json) (`examples`) and in [`.actor/example_output.json`](.actor/example_output.json) / [`.actor/example_output_error.json`](.actor/example_output_error.json).

#### Successful record (`success: true`)

Example for ASIN `B081ZCQP4P` on Amazon.de (130 EUR product, FBA + MFN):

```json
{
  "success": true,
  "asin": "B081ZCQP4P",
  "marketplace": "DE",
  "amazonDomain": "amazon.de",
  "sourceUrl": "https://sellercentral.amazon.de/revcalpublic?mons_sel_locale=de_DE",
  "scrapedAt": "2026-08-28T10:18:16.811Z",
  "product": {
    "asin": "B081ZCQP4P",
    "title": "Amoroses 12 echte stabilisierte Rosen halten jahrelang - Originelle Geschenkidee Eleganter Blumenstrauß für Geburtstag, Hochschulabschluss und besondere Anlässe (Weiße Schachtel mit weißen Rosen)",
    "imageUrl": "https://m.media-amazon.com/images/I/41YTJhPrWML._SL120_.jpg",
    "feeCategory": "gl_lawn_and_garden",
    "soldBy": "AmoRoses",
    "condition": "New",
    "shipsFrom": "Amazon",
    "price": { "amount": 130, "currency": "EUR" },
    "shipping": { "amount": 0, "currency": "EUR" },
    "salesRank": 1387315,
    "salesRankCategory": "Küche, Haushalt & Wohnen",
    "customerReviewsRating": "4,5 von 5 Sternen",
    "offerCount": 1
  },
  "programs": [
    {
      "programId": "Core#0",
      "programName": "Fulfilled by Amazon (FBA)",
      "itemPrice": { "amount": 130, "currency": "EUR", "formatted": "130.00 EUR" },
      "totalFees": { "amount": 29.2968, "currency": "EUR", "formatted": "29.30 EUR" },
      "netProceeds": { "amount": 79.9472, "currency": "EUR", "formatted": "79.95 EUR" },
      "feeLines": [
        { "id": "FulfillmentFee", "label": "FS-FBAPerUnitFulfillmentFee-FullName", "amount": { "amount": 3.96, "currency": "EUR", "formatted": "3.96 EUR" } },
        { "id": "ReferralFee", "label": "FS-Commission-FullName", "amount": { "amount": 19.5, "currency": "EUR", "formatted": "19.50 EUR" } },
        { "id": "vatAmount", "label": "VAT", "amount": { "amount": 20.756, "currency": "EUR", "formatted": "20.76 EUR" } }
      ]
    },
    {
      "programId": "MFN#1",
      "programName": "Merchant Fulfilled (MFN)",
      "itemPrice": { "amount": 130, "currency": "EUR", "formatted": "130.00 EUR" },
      "totalFees": { "amount": 20.49, "currency": "EUR", "formatted": "20.49 EUR" },
      "netProceeds": { "amount": 88.754, "currency": "EUR", "formatted": "88.75 EUR" },
      "feeLines": [
        { "id": "ReferralFee", "label": "FS-Commission-FullName", "amount": { "amount": 19.5, "currency": "EUR", "formatted": "19.50 EUR" } },
        { "id": "FixedClosingFee", "label": "FS-FixedClosingFee-FullName", "amount": { "amount": 0.99, "currency": "EUR", "formatted": "0.99 EUR" } },
        { "id": "vatAmount", "label": "VAT", "amount": { "amount": 20.756, "currency": "EUR", "formatted": "20.76 EUR" } }
      ]
    }
  ],
  "rawApiResponses": ["..."],
  "warnings": []
}
```

The full response (including all `feeLines` and unmodified `rawApiResponses` from Amazon's API) is in [`.actor/example_output.json`](.actor/example_output.json).

#### Failed record (`success: false`)

The Actor **does not crash** on Amazon rate limits or blocks. It retries up to **3 times** with increasing delays (2s, 4s), then writes a structured error record:

```json
{
  "success": false,
  "asin": "B01F0YYEFW",
  "marketplace": "DE",
  "amazonDomain": "amazon.de",
  "scrapedAt": "2026-08-28T09:56:53.547Z",
  "error": {
    "code": "RATE_LIMITED",
    "message": "Amazon temporarily rate-limited this request (HTTP 429). This does not mean the ASIN is invalid. Enable Apify Proxy (RESIDENTIAL) matching your marketplace, or run again later.",
    "retryable": true,
    "httpStatus": 429,
    "stage": "productmatch"
  }
}
```

#### Error codes

| Code | Meaning | Retryable? |
| --- | --- | --- |
| `ASIN_NOT_FOUND` | ASIN not in the selected marketplace catalog | No |
| `RATE_LIMITED` | Amazon returned HTTP 429 (too many requests) — **the ASIN may still be valid** | Yes |
| `AMAZON_BLOCKED` | Request blocked (often missing/wrong proxy) | Yes |
| `API_ERROR` | Other Amazon API error | Depends |
| `INVALID_ASIN` | ASIN format invalid (not 10 characters) | No |

**Important:** A `RATE_LIMITED` or `AMAZON_BLOCKED` error does **not** mean the ASIN does not exist. Verify the ASIN on the Amazon website, enable a residential proxy for your marketplace, and retry the run.

#### Key fields in `programs` (success only)

- `programName` — Fulfilled by Amazon (FBA) or Merchant Fulfilled (MFN)
- `itemPrice` — price used for the calculation
- `totalFees` — sum of Amazon fees
- `netProceeds` — estimated proceeds after fees and VAT
- `feeLines` — individual fee components (fulfillment, referral, storage, etc.)

### Testing status

| Marketplace | Status |
| --- | --- |
| **DE (Germany)** | **Production-tested** — primary development and validation market |
| GB, FR, IT, ES, NL, SE, PL, IN, AE, TR, SA | Supported — basic smoke tests only; report issues if results look off |

The **Germany (DE)** marketplace is the most thoroughly tested. Other marketplaces use the same underlying calculator logic with marketplace-specific locale and country settings. If you encounter problems outside DE, try a residential proxy for that country and open an issue with the ASIN and marketplace code.

### Limitations

- **Programs:** FBA and MFN only (not Pan-EU, EFN, or other programs).
- **ASINs:** Products must exist in the selected marketplace catalog.
- **Estimates only:** Results match Amazon's public Revenue Calculator — not a guarantee of actual fees.
- **Rate limits:** Amazon may return HTTP 429. The Actor retries automatically (up to 3 times) and returns a clear `RATE_LIMITED` error instead of crashing.
- **One ASIN per run:** For bulk lookups, call the Actor multiple times via API or Apify tasks.
- **Proxy:** Match `apifyProxyCountry` to your `marketplace` for best results.

### Tips

1. Always enable **Apify Proxy** on the Apify platform.
2. Use **RESIDENTIAL** proxies with the matching country code.
3. Save your input as **Default input** for repeat runs.
4. For many ASINs, run the Actor in parallel via the Apify API (one ASIN per run).

### Keywords

Amazon revenue calculator, Amazon fee calculator, Amazon FBA fees, Amazon FBA calculator, Amazon MFN fees, Seller Central calculator, Amazon profit calculator, Amazon seller tools, FBA fee estimator, fulfillment fees Amazon, referral fee calculator, Amazon.de fees, Amazon Germany, Amazon UK fees, Amazon France, Amazon product research, ASIN fee lookup, Amazon margin calculator, e-commerce seller fees, Amazon Europe, FBA vs FBM, Amazon storage fees, net proceeds Amazon, Amazon seller profitability, bulk ASIN analysis

### Disclaimer

This Actor is not affiliated with or endorsed by Amazon. Fee data is sourced from Amazon's public Revenue Calculator and is provided for informational purposes only. Always verify fees in Seller Central before making business decisions.

# Actor input Schema

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

Amazon marketplace (DE = production-tested; other markets supported with basic validation). Match proxy country to marketplace for best results.

## `asin` (type: `string`):

One Amazon ASIN per run (10 characters, e.g. B081ZCQP4P). For multiple ASINs, start separate runs or use the Apify API in a loop.

## `itemPrice` (type: `number`):

Custom item price in the marketplace currency. Leave empty to use the product's current Amazon price.

## `shippingPrice` (type: `number`):

Shipping charge for the self-fulfilled (MFN) calculation. Defaults to 0.

## `proxyConfiguration` (type: `object`):

Enable Apify Proxy for reliable access to Amazon. Match apifyProxyCountry to your marketplace (e.g. DE for Germany, GB for UK).

## Actor input object example

```json
{
  "marketplace": "DE",
  "asin": "B081ZCQP4P",
  "shippingPrice": 0,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

Status, ASIN, product title, and error details (if any).

## `feeBreakdown` (type: `string`):

FBA and MFN program fees with line items (successful lookups).

# 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 = {
    "asin": "B081ZCQP4P",
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("buchmann/amazon-seller-fee-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 = {
    "asin": "B081ZCQP4P",
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("buchmann/amazon-seller-fee-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 '{
  "asin": "B081ZCQP4P",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call buchmann/amazon-seller-fee-calculator --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,buchmann/amazon-seller-fee-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/0XeId0vDGeWNxWpaU/builds/rGek1NfaMx4pKLWGq/openapi.json