Logimu — Amazon product data & search API

Amazon and Walmart product data and search, in one API.

Turn a keyword into ranked, grouped product results. Pull any ASIN's price, BSR, rating, and every seller offer. Scrape Amazon and Walmart live on demand — a product page, or a whole search-results page. And read what our observations add up to: brand dossiers, seller maps, operator footprints and category landscapes, from the same key.

Built for teams putting real Amazon product data into AI applications and agents (REST and an MCP connector), for e-commerce businesses doing price monitoring, repricing, product research and brand protection, and for analytics teams working with price, rank and seller history.

Get Logimu access — API or dashboard
14-day money-back guarantee. $19 buys 25,000 credits a month: 50,000 stored lookups with full rank, seller and Buy Box history, 500,000 lookups of the history alone, or 25,000 live fetches. Failed requests are never billed. Every feature available in all plans.
Start for $19/month Check your products in the demo
Using Claude or ChatGPT? Add Logimu to your assistant
$19 Entry plan — 25,000 credits a month
<100 ms Warehouse search & lookups
12 markets US, UK, DE, CA, AU, JP, FR, IT, ES, MX, BR + Walmart · one price
2–10× cheaper than Keepa API on the same monthly volume, and 3–20× cheaper than Rainforest API
Since 2023 Amazon US price and rank history; every record states its own range
8 live scrapes Amazon product, offers, search, Best Sellers, Today’s Deals and seller pages; Walmart product and search pages
Live demo · no signup

Search your own products. See what the API returns.

The demo doubles as a coverage check: enter one of your ASINs, a barcode, a keyword or an Amazon product link. A product we hold shows its full record and history; one we don’t hold yet is fetched live from Amazon.

Start for $19/month

Price history in bulk

Amazon historical price API for 10,000 to 1,000,000 products.

One call per product returns its stored history for 0.05 credit, so $19 a month covers 500,000 products: the Buy Box price on each day we observed the product, its sales rank in every category, and each seller’s price. Send up to 20,000 ASINs as one batch, see the credit cost before it runs, and download the rows as JSONL or CSV. A product we hold no history for is never billed.

A one-time price-history pull, by list size
Products On Logimu: history only, 0.05 credit each Batch time Keepa API: 1 token each
10,000products $19 plan500 credits, 2% of its month about 2 minutes $55 plan, about 8 hours
100,000products $19 plan5,000 credits, 20% of its month about 20 minutes $55 plan, about 3½ days
1,000,000products $50 plan50,000 credits, half of its month about 3 hours $110 (two $55 plans), about 17 days

In short: price history for 10,000 or 100,000 Amazon products fits the $19 Logimu plan and 1,000,000 products the $50 plan, with each 20,000-product batch done in about 4 minutes. On Keepa’s $55 plan the same pull takes about 8 hours, 3½ days, or 17 days on two plans ($110).

Logimu: the plan whose monthly credits cover the pull; batch time measured on a 20,000-product history batch (4 minutes, October 2026), with longer lists running as consecutive batches. Keepa: 1 token per product request with price history (keepa.com API docs), the cheapest plan or combination of plans that yields those tokens within a month, from keepa.com’s plan list (October 2026, €1 = $1.12) with tokens used around the clock; time is tokens divided by tokens a minute. Full Keepa comparison

How far back
Amazon US price and rank history since 2023. Every record states its own range in observed_from and observed_to.
Limits
30 requests a second per IP, with bursts to 60. A batch of 20,000 products counts as one request. Credits are a monthly allowance, not a per-minute refill.
Full records
A full record, at 0.5 credit a product, adds every seller we observed and the page content to the same history: 10,000 fit the $19 plan, 100,000 the $50 plan and 1,000,000 the $250 plan.
curl
# One product: its stored price, rank and seller history (0.05 credit)
curl "https://api.logimu.com/v1/product?asin=B00M3IFUMK&country=us&history_only=true" \
  -H "X-API-KEY: $LOGIMU_API_KEY"

# A list: create a batch of up to 20,000 ASINs, run it, download the rows
curl -X POST https://api.logimu.com/v1/batches \
  -H "X-API-KEY: $LOGIMU_API_KEY" -H "Content-Type: application/json" \
  -d '{"name": "price-history", "country": "us", "mode": "cache",
       "include": ["history_only"], "asins": ["B00M3IFUMK", "B07YYJRXQR"]}'
curl -X POST https://api.logimu.com/v1/batches/BATCH_ID/runs -H "X-API-KEY: $LOGIMU_API_KEY"
curl https://api.logimu.com/v1/batches/BATCH_ID/runs/RUN_ID/result.jsonl \
  -H "X-API-KEY: $LOGIMU_API_KEY" -o price_history.jsonl
Python
# pip install requests; one ASIN per line in asins.txt (10,000 to 1,000,000 lines)
import csv, json, os, time
import requests

API = "https://api.logimu.com"
s = requests.Session()
s.headers["X-API-KEY"] = os.environ["LOGIMU_API_KEY"]

asins = [line.strip() for line in open("asins.txt") if line.strip()]
runs = []
for i in range(0, len(asins), 20_000):  # up to 20,000 ASINs per batch
    batch = s.post(f"{API}/v1/batches", json={
        "name": f"price-history-{i // 20_000 + 1}", "country": "us", "mode": "cache",
        "include": ["history_only"], "asins": asins[i:i + 20_000]}).json()
    run = s.post(f"{API}/v1/batches/{batch['id']}/runs").json()
    runs.append(f"{API}/v1/batches/{batch['id']}/runs/{run['id']}")

with open("price_history.csv", "w", newline="") as f:
    out = csv.writer(f)
    out.writerow(["asin", "date", "buybox_price"])
    for url in runs:
        while s.get(url).json()["status"] in ("queued", "running"):
            time.sleep(10)
        with s.get(f"{url}/result.jsonl", stream=True) as rows:
            for line in rows.iter_lines():
                row = json.loads(line)
                if row["status"] != "ok":  # not found: never billed
                    continue
                history = row["product"].get("buybox_price_history") or {}
                for point in history.get("points", []):
                    out.writerow([row["asin"], point["date"], point["price"]])
JavaScript
// Node 18+; up to 20,000 ASINs per call
const API = "https://api.logimu.com";
const headers = { "X-API-KEY": process.env.LOGIMU_API_KEY, "Content-Type": "application/json" };
const call = async (path, init = {}) => (await fetch(API + path, { headers, ...init })).json();

async function priceHistory(asins, country = "us") {
  const batch = await call("/v1/batches", { method: "POST", body: JSON.stringify(
    { name: "price-history", country, mode: "cache", include: ["history_only"], asins }) });
  const run = await call(`/v1/batches/${batch.id}/runs`, { method: "POST" });
  const path = `/v1/batches/${batch.id}/runs/${run.id}`;
  while (["queued", "running"].includes((await call(path)).status)) {
    await new Promise((r) => setTimeout(r, 10000));
  }
  const jsonl = await (await fetch(`${API}${path}/result.jsonl`, { headers })).text();
  return jsonl.split("\n").filter(Boolean).map((line) => JSON.parse(line))
    .filter((row) => row.status === "ok")
    .map((row) => ({ asin: row.asin, prices: row.product.buybox_price_history?.points ?? [] }));
}

const rows = await priceHistory(["B00M3IFUMK", "B07YYJRXQR"]);
console.log(rows[0].asin, rows[0].prices.slice(-3));

Each example ran against the live API on October 27, 2026. Set LOGIMU_API_KEY to your key. Reference: history only, batches.

The Logimu API

Three layers of Amazon data. One key, one credit grammar.

Self-serve and metered by credits, live in minutes. Plans from $19/month with an unconditional 14-day money-back. Every Amazon marketplace costs the same, and you are never billed for a request that did not return what you asked for.

Live proof · derived intelligence

The operator network behind a brand, live.

This is the real Nike seller network — every brand below shares Amazon buy-box sellers with Nike, drawn from our observed daily record. The Logimu API serves exactly this object: GET /v1/brand/network?brand=Nike&country=us returns the nodes[] and weighted edges[] you see drawn here, one credit per hop. Hover a brand for its numbers; click one to recenter; type any brand to map it.

Node colour is the brand’s heat (seller pressure: how many sellers per listing and how fast that is rising), size is its catalogue, distance is how many sellers two brands share. Counts and shares from observed buy-box data, refreshed daily — never estimates. Available on every paid plan. Endpoint reference →

Questions about the data.

Can I get sales estimates for an Amazon product?

Yes, on amazon.com. Where the page shows Amazon’s own “bought in past month” badge, GET /v1/product returns the badge as shown, with its history over time; it is a rounded floor such as “1K+”, not an exact count. For listings without the badge it returns sales_estimate, units a month modelled from the listing’s 7-day median Best Sellers Rank on its category’s rank-to-sales curve. Each estimate carries a confidence from 0 to 100, and sales_estimate_detail adds the band (such as “100+”), the rank it used and the category whose curve it read. Below confidence 30 the number is withheld and you get the band. It is a modelled estimate, not an Amazon figure. Docs →

More questions in the FAQ →

E-commerce & marketplace data

Amazon and Walmart product data, delivered reliably.

The hardest targets in e-commerce extraction — captchas, Akamai, behavioral fingerprinting. Our API delivers this data in continuous production with 97%+ delivery rates.

Switching from another provider? See how we compare to Bright Data and Firecrawl. Lost PA-API access? See our PA-API alternative with a live product-search demo.

Start with the API.

Get an API key from $19/month and make your first call in minutes. Cancel anytime, 14-day money back.

Sign up