# eBay Fee Calculator: Final Value Fees, Profit & Margin (`moggedhq/ebay-fee-calculator`) Actor

Calculate eBay fees and profit: enter your item price and category, e.g. sneakers, cards or a used camera. About $0.002 per item. Final value fees, shipping, net profit, margin, ROI and break-even price from dated US fee tables. Store and promoted options. No login.

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

## Pricing

from $1.60 / 1,000 item 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

## eBay Fee Calculator: Final Value Fees, Profit & Margin

For eBay sellers comparing the profit on items before listing them. Enter your item price, category and cost, such as a used camera, adult sneakers or a trading card. **$0.002 per calculated item**: 100 items cost about **$0.20**, plus the small Actor start charge. No login is needed.

For **US-registered sellers on eBay.com, in USD**. Rates are a versioned snapshot checked **14 October 2026**. Listing URLs and account settings are not read.

### What you get

Example output:

> Profit $34.31 per sale (41% margin, 114% ROI) at $75.00 plus $8.00 shipping: final value fee $11.29, per-order $0.40.

That camera scenario uses a $30 purchase cost, $7 actual shipping cost, no Store subscription, no advertising and zero buyer sales tax. Its estimated break-even item price is $35.29. The three-item cloud example passed in 3.35 seconds on 14 October 2026. Verdict percentages are rounded; numeric fields keep two decimal places.

| Output field | Meaning |
| --- | --- |
| `verdict` | Plain-English profit or loss, margin, ROI and main fees |
| `status`, `recordType` | Successful calculation or a free input note |
| `itemId`, `name`, `inputIndex` | Your reference and original zero-based position |
| `categoryInput`, `category`, `categoryName` | Entered category and the exact fee group used |
| `price`, `shippingCharged`, `handlingCharged` | Seller revenue inputs, in USD |
| `salesTax`, `totalSaleAmount` | Buyer tax and the sale total including it |
| `finalValueFeeBase` | Amount used for the percentage final value fee |
| `finalValueFeeBeforeDiscount`, `topRatedDiscount` | Percentage fee and eligible discount |
| `finalValueFee`, `perOrderFee` | Discounted percentage fee and separate order charge |
| `internationalFee`, `promotedListingFee` | Conditional international and General campaign fees |
| `additionalFinalValueFee`, `insertionFee` | Optional entered surcharges and insertion cost |
| `totalEbayFees` | Sum of the eBay fee lines modeled here |
| `paymentProcessingIncluded` | True: payment processing is included in eBay's fee |
| `costPerUnit`, `shippingCost`, `otherCosts` | Your purchase, postage and other costs |
| `revenue`, `netProfit` | Revenue excluding buyer tax, then profit after modeled costs |
| `marginPercent`, `roiPercent` | Profit divided by revenue, or by item purchase cost |
| `breakEvenPrice`, `breakEvenNote` | Lowest modeled item price, or a reason it is unavailable |
| `feeRule` | Marginal tiers or whole-sale rate bands used |
| `feeTableVersion`, `feeTableCheckedAt` | Version and review date of the bundled rates |
| `feeSourceUrl`, `sourceUrls` | Official eBay fee, discount and advertising references |
| `feeScheduleEffectiveDate` | Null where no single effective date is stated for all rates |
| `calculatedAt`, `notes` | Calculation timestamp and explicit assumptions |

Dataset views show profit, fees and sources. The Output tab links to `SUMMARY` counts and warnings and `REPORT.html`. Summary profit adds scenarios; it is not a sales forecast.

Exact repeated item objects are skipped free. Give different scenarios distinct IDs or prices. Different objects are calculated separately.

### How to use it

1. Add items with `price`, a supported plain `category`, and `cost`. Enter actual `shippingCost` separately from the amount charged to the buyer.
2. Set `sellerType` for your Store level, eligible Top Rated Plus discount, advertising and international-sale assumptions. An item's own `sellerType` overrides common options.
3. Start the Actor and inspect the verdict, fee lines, category match and notes. Download JSON, CSV or Excel from the dataset, or open the report.

```json
{
  "items": [
    {
      "id": "camera",
      "name": "Used camera",
      "price": 75,
      "category": "camera",
      "cost": 30,
      "shippingCharged": 8,
      "shippingCost": 7,
      "salesTaxRate": 0
    }
  ],
  "marketplace": "US",
  "sellerType": {
    "storeLevel": "none",
    "topRatedPlus": false,
    "promotedListingRate": 0,
    "internationalSale": false,
    "ebayInternationalShipping": false
  }
}
```

### Inputs and defaults

| Input | Default and behavior |
| --- | --- |
| `items` | Array of up to 10,000 manual item objects; empty input produces a free note |
| `costPerUnit` | Optional shared purchase cost; missing cost is never guessed |
| `costPerUnitById` | Optional cost map such as `{"camera":30}`; overrides the shared cost |
| `marketplace` | `US`; other marketplaces produce free notes |
| `sellerType.storeLevel` | `none`; also `starter`, `basic`, `premium`, `anchor`, `enterprise` |
| `sellerType.topRatedPlus` | False; set true only for a qualifying US listing |
| `sellerType.promotedListingRate` | 0; otherwise enter a percent from 2 through 100 |
| `sellerType.internationalSale` | False; true means buyer registration or delivery is outside the US |
| `sellerType.ebayInternationalShipping` | False; true assumes the eligible international-fee exemption |

Each item requires a positive `price` and a supported `category`. Its own `cost` takes precedence over `costPerUnitById` and the shared `costPerUnit`; the item alias `costPerUnit` also works. Explicit zero cost is allowed, but ROI is then null because dividing by zero has no meaning.

Optional item amounts are `shippingCharged`, `shippingCost`, `handlingCharged`, `insertionFee` and `otherCosts`, all defaulting to zero. Use `otherCosts` for packaging, allocated subscription expense, expected returns or optional listing upgrades you want included in profit. It does not become part of `totalEbayFees`, because you decide what it contains.

Use either `salesTaxRate`, a percentage up to 30, or `salesTaxAmount`, a fixed USD amount. Do not enter both. With neither provided, the calculation uses zero tax and says so. Missing postage also receives an explicit note. Individual monetary inputs are capped at $1,000,000.

`feeShippingCharged` optionally replaces shipping in the final value fee base where eBay's shipping exceptions apply. It cannot exceed seller-received `shippingCharged`. Other percentage fees still use the actual sale total. For authentication shipping paid directly to eBay, do not include that amount in your seller revenue.

`additionalFinalValueFeeRate` is an optional percentage surcharge, default zero, applied without the Top Rated discount. Use your actual applicable surcharge; account performance and eligibility are not looked up. Refunds, taxes on seller fees, foreign exchange, donations and subscription charges are not automatically calculated.

### Categories and rate logic

Plain names map to explicit fee groups. Supported examples include `general`, `books`, `cards`, `coins`, `bullion`, `handbags`, `jewelry`, `watches`, `sneakers`, `guitars`, `heavy equipment`, `nft`, `camera`, `electronics`, `laptop`, `musical instruments`, `pro audio`, `auto parts`, `tires`, `motors_apparel`, `motors_electronics`, `stamps` and `consoles`.

Common aliases include `pokemon cards`, `comic books`, `used camera`, `lens`, `smartphone`, `ssd`, `brake pads`, `vinyl records`, `lego` and `home and garden`. Unknown category text produces a free note instead of silently receiving a guessed rate. Use a specific category where an exception exists. `general` is your deliberate choice for the most-categories schedule, not a product classifier.

Non-Store and Starter schedules share the standard category rates. Basic, Premium, Anchor and Enterprise share the higher-Store final value fee schedule. Store subscription payments themselves differ and are not allocated automatically. The calculator distinguishes marginal rates above thresholds from a new percentage applied to the entire sale. This matters especially for handbags, jewelry and bullion.

Adult athletic shoes have a separate threshold and qualifying sales have no per-order fee. Books, cards, watches, guitars, electronics, computers and vehicle parts have their own rules. Accessories can belong to different fee groups from the main product: for example, use `camera accessories` for the general accessory group and `memory cards` for the applicable equipment group. Full eBay numeric category IDs are not supported.

### How profit and break-even work

Revenue is item price plus seller-received shipping and handling. Buyer sales tax is excluded from revenue but included in applicable percentage-fee bases. Profit subtracts modeled eBay fees, purchase cost, actual postage and other costs. Margin divides that profit by revenue. ROI divides it by the item purchase cost only; it is not annualized.

The 10% Top Rated Plus reduction applies to the percentage final value fee, not the per-order charge, advertising or international fee. General campaign advertising assumes the sale is attributed at your entered rate. Set the rate to zero for an organic scenario. Eligible eBay International Shipping scenarios suppress the US international fee.

Break-even holds your entered costs, shipping income and handling fixed, and checks the applicable fee bands up to a $1,000,000 item price. A tax percentage changes with the candidate price; an entered tax amount stays fixed. The search accounts for whole-sale rate drops, the sneaker threshold, per-order changes and cent rounding. Extreme rates can make break-even unavailable, in which case the field is null and a note explains why. A low break-even price does not mean there is market demand at that price.

### Price and spending limits

| Calculated items | Base item charges |
| --- | ---: |
| 3 sample items | $0.006 |
| 100 items | $0.20 |
| 1,000 items | $2.00 |
| 10,000 items | $20.00 |

The Actor start charge is $0.00005 at the default 128 MB, in addition to those figures. Per-item prices are $0.0019 on Bronze, $0.0018 on Silver and $0.0016 on Gold and higher tiers. You do not separately pay platform compute or proxies for this pay-per-event Actor.

Only successful calculations incur an item charge. Invalid objects, unsupported categories, duplicates and summary records are free; the start charge still applies. The Actor checks your maximum charge before the next calculation and stops cleanly when it cannot charge another item. The summary reports unprocessed entries. There are no external AI or data-service charges and no separate free-plan item cap.

### Use with AI agents (MCP)

Connect an agent to `https://mcp.apify.com` and ask it to find an eBay fee calculator. A useful request is: "Calculate fees, profit, margin and break-even for these manual eBay items using my prices, categories and costs." Have it inspect the input schema and pass the item array to `moggedhq/ebay-fee-calculator`.

Give agents prices, categories and costs. Check the returned category, rate date and notes. Listing URLs alone are insufficient.

### API and integrations

Use your own Apify token in your environment and send the same input JSON:

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("moggedhq/ebay-fee-calculator").call(
    run_input={"items": [{"price": 75, "category": "camera", "cost": 30,
                          "shippingCharged": 8, "shippingCost": 7}]}
)
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(row["verdict"])
```

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('moggedhq/ebay-fee-calculator').call({
  items: [{ price: 75, category: 'camera', cost: 30 }]
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

```bash
curl -X POST \
  'https://api.apify.com/v2/acts/moggedhq~ebay-fee-calculator/run-sync-get-dataset-items' \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"items":[{"price":75,"category":"camera","cost":30}]}'
```

Apify tasks, Make, Zapier and n8n can connect spreadsheet rows to profit estimates. Scheduled runs reuse supplied values; they do not refresh listing prices or fee tables. Keep tokens in secret settings.

### Limits and FAQ

**Does it scrape listings?** No. Enter manual prices and categories. URL and item-ID fetching is not offered.

**Are these live account fees?** No. They are estimates from a dated public table snapshot. Account exceptions, promotions and subsequent fee changes may differ. Review the source links and your seller statement.

**Why is the effective date null?** The source does not give one start date for every rate. The checked date identifies when this version was reviewed without inventing an effective date.

**Can I calculate a multi-item order?** Each row models one item in one order. It therefore has its own per-order fee. Combined orders require allocation that this version does not perform; quantity values other than one produce a free note.

**Are monthly Store payments included?** No. Allocate the amount per expected sale in `otherCosts` if you want it in profit.

**Why is payment processing zero?** eBay includes processing in its final value fee. Adding a second processing percentage would count it twice.

**Can it handle UK sellers or vehicle sales?** This version supports US sellers and ordinary US item sales, including specified vehicle parts. It does not calculate UK, foreign-seller, motor vehicle, real-estate or eBay Live fees.

**How are failures charged?** Unsupported or invalid items return explanatory note rows with no item charge. The small run start charge remains. A completed run can contain notes, so check `status` as well as the run status.

**Where do the rules come from?** [eBay selling fees](https://www.ebay.com/help/selling/fees-credits-invoices/x?id=4822), [Store selling fees](https://www.ebay.com/help/selling/fees-credits-invoices/store-selling-fees-managed-payments-sellers?id=4809), [Top Rated Plus requirements](https://www.ebay.com/help/policies/member-behaviour-policies/seller-performance-policy?id=4347) and [General campaign fees](https://www.ebay.com/help/selling/promoted-listings/promoted-listings?id=4164). This independent calculator is not affiliated with eBay.

# Actor input Schema

## `items` (type: `array`):

Manual sale scenarios. Each requires price (USD), category (e.g. sneakers, camera, books, cards, laptop, jewelry, watches, handbags, guitars, auto parts, general), and cost or a global costPerUnit. Optional id, name, shippingCharged, shippingCost, handlingCharged, salesTaxRate (percent) OR salesTaxAmount, insertionFee, otherCosts, feeShippingCharged for shipping exceptions, additionalFinalValueFeeRate, and sellerType overrides. Each row means one item in one order. Up to 10,000. Unknown categories, invalid inputs and exact duplicate objects are free. Example: {"price":75,"category":"camera","cost":30,"shippingCharged":8,"shippingCost":7}.

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

Used when an item has no cost. Enter zero only when your item truly cost nothing. Per-item cost overrides this. For a map by item id, use costPerUnitById.

## `costPerUnitById` (type: `object`):

USD cost map keyed by each item id, such as {"camera":30,"sneakers":85}. Item cost takes precedence.

## `sellerType` (type: `object`):

storeLevel: none, starter, basic, premium, anchor or enterprise. topRatedPlus: true only if this listing qualifies for the US 10% percentage-fee discount. promotedListingRate: 0 or 2 to 100 percent, assuming an attributed General campaign sale. internationalSale: true if buyer registration or delivery is outside the US. ebayInternationalShipping: true to apply the eligible US international-fee exemption. Defaults: no store, no discount, no ads, domestic. Each item may override these via its own sellerType.

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

US only, with USD amounts and a US-registered seller. Other marketplaces become a free note.

## Actor input object example

```json
{
  "items": [
    {
      "id": "camera",
      "name": "Used camera",
      "price": 75,
      "category": "camera",
      "cost": 30,
      "shippingCharged": 8,
      "shippingCost": 7
    },
    {
      "id": "sneakers",
      "name": "Adult sneakers",
      "price": 180,
      "category": "sneakers",
      "cost": 85,
      "shippingCost": 8
    },
    {
      "id": "cards",
      "name": "Trading card",
      "price": 35,
      "category": "cards",
      "cost": 12,
      "shippingCharged": 4,
      "shippingCost": 3.5
    }
  ],
  "sellerType": {
    "storeLevel": "none",
    "topRatedPlus": false,
    "promotedListingRate": 0
  },
  "marketplace": "US"
}
```

# Actor output Schema

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

No description

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

No description

## `summary` (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 = {
    "items": [
        {
            "id": "camera",
            "name": "Used camera",
            "price": 75,
            "category": "camera",
            "cost": 30,
            "shippingCharged": 8,
            "shippingCost": 7
        },
        {
            "id": "sneakers",
            "name": "Adult sneakers",
            "price": 180,
            "category": "sneakers",
            "cost": 85,
            "shippingCost": 8
        },
        {
            "id": "cards",
            "name": "Trading card",
            "price": 35,
            "category": "cards",
            "cost": 12,
            "shippingCharged": 4,
            "shippingCost": 3.5
        }
    ],
    "sellerType": {
        "storeLevel": "none",
        "topRatedPlus": false,
        "promotedListingRate": 0
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("moggedhq/ebay-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 = {
    "items": [
        {
            "id": "camera",
            "name": "Used camera",
            "price": 75,
            "category": "camera",
            "cost": 30,
            "shippingCharged": 8,
            "shippingCost": 7,
        },
        {
            "id": "sneakers",
            "name": "Adult sneakers",
            "price": 180,
            "category": "sneakers",
            "cost": 85,
            "shippingCost": 8,
        },
        {
            "id": "cards",
            "name": "Trading card",
            "price": 35,
            "category": "cards",
            "cost": 12,
            "shippingCharged": 4,
            "shippingCost": 3.5,
        },
    ],
    "sellerType": {
        "storeLevel": "none",
        "topRatedPlus": False,
        "promotedListingRate": 0,
    },
}

# Run the Actor and wait for it to finish
run = client.actor("moggedhq/ebay-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 '{
  "items": [
    {
      "id": "camera",
      "name": "Used camera",
      "price": 75,
      "category": "camera",
      "cost": 30,
      "shippingCharged": 8,
      "shippingCost": 7
    },
    {
      "id": "sneakers",
      "name": "Adult sneakers",
      "price": 180,
      "category": "sneakers",
      "cost": 85,
      "shippingCost": 8
    },
    {
      "id": "cards",
      "name": "Trading card",
      "price": 35,
      "category": "cards",
      "cost": 12,
      "shippingCharged": 4,
      "shippingCost": 3.5
    }
  ],
  "sellerType": {
    "storeLevel": "none",
    "topRatedPlus": false,
    "promotedListingRate": 0
  }
}' |
apify call moggedhq/ebay-fee-calculator --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,moggedhq/ebay-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/5C1AZvFmZJMbh0K2f/builds/VFD4fkuaIeLRDvbGr/openapi.json