DEV Community

Viktor
Viktor

Posted on

How to Scrape Audible with Python: Best-Seller Charts, Narration vs. Story Ratings, Reviews, and a Chart Tracker (2026)

Audible's best-seller chart is one of the few public signals of what people buy in audiobooks. Indie authors checking comp titles, narrators watching their genre, and "what's hot in audio" newsletters all want that chart in a script, with the ratings behind each title.

This post builds audible.py, one Python file that uses only the standard library (urllib, sqlite3, re). It does five things:

  1. probe compares the chart page with the "best sellers" sort of Audible's catalog API (they don't match, and that's the first trap)
  2. chart reads a best-seller chart and joins it with rating data
  3. split compares narration scores with story scores across several genre charts
  4. search, book, reviews, author, categories, and bestsellers look up the catalog through an API
  5. track saves chart snapshots in SQLite and prints rank moves and new ratings between runs

Everything below ran on November 16, 2026 on a Linux VM with Python 3.13.5, and every output block is pasted unedited from those runs.

Read this first. Audible's terms prohibit scraping. The Audible Service Conditions of Use (last updated November 2, 2026) incorporate the Amazon.com Conditions of Use and say Audible "is an Amazon Service for the purposes of" them. The "License and Access" section of those Amazon conditions (last updated August 14, 2026) says your license "does not include any resale or commercial use of any Amazon Service, or its contents; any collection and use of any product listings, descriptions, or prices; any derivative use of any Amazon Service or its contents; [...] or any use of data mining, robots, or similar data gathering and extraction tools." Audible's own "Content Restrictions" add that you may not "use the Service or Content for any commercial or illegal purpose." So collecting Audible data with a script goes against its terms, whoever runs the requests. Read the terms yourself and weigh the legal risk for your use case before you run anything here. If an official source covers what you need, use it instead (see the next section). Reviews are personal writing by real listeners, so don't republish them, and store only what you need.

Is there an Audible API?

Not a public, documented one for catalog data. There's no developer portal, no key signup, and no published terms for third-party catalog access. Here's what does exist:

  • If you're the author, narrator, or rights holder, your real sales and royalty numbers are in your ACX or publisher dashboard. Those are actual sales, which the public chart never shows. If that's your use case, stop here.
  • Your own library. The Audible apps talk to api.audible.com/1.0/.... Account endpoints need a registered device. The open-source audible Python package handles that registration for your own account, which is the reasonable way to export your own library.
  • Catalog endpoints answer without a login. api.audible.com/1.0/catalog/products returned product data, ratings, and reviews to a plain script with no key. It's undocumented, so it can change or close at any time, and the terms quoted above still apply.

Also check robots.txt before writing any loop. For www.audible.com it has a block labeled #Block excess charts with Disallow: /charts/*?. That means the query-less chart URLs (/charts/best and /charts/best/<category>/<id>) are allowed and anything with a query string, including ?page=2, is not. Review pages like /allprodreviews are disallowed too. The script below only fetches page one of each chart, which is the top 20.

Step 1: Setup

No pip install. The header defines a descriptive User-Agent, the endpoints, and a small get() that backs off on 429/5xx:

#!/usr/bin/env python3
"""Audible best-seller charts, ratings, reviews and a chart tracker. Python 3.10+, stdlib only."""
import html
import json
import os
import re
import sqlite3
import sys
import time
import urllib.error
import urllib.parse
import urllib.request

UA = "audible-chart-notes/1.0 (personal research; contact: you@example.com)"
WEB = "https://www.audible.com"
CATALOG = "https://api.audible.com/1.0/catalog/products"
SA_API = "https://api.scrapeatlas.com/v1/audible"
SA_KEY = os.environ.get("SCRAPEATLAS_API_KEY", "")
GROUPS = "product_desc,rating,product_attrs,contributors,series,category_ladders"
DB = os.environ.get("AUDIBLE_DB", "audible.db")
Enter fullscreen mode Exit fullscreen mode
def get(url, params=None, headers=None, tries=4):
    """GET with a real User-Agent and backoff on 429/5xx. Returns (status, text)."""
    if params:
        url += "?" + urllib.parse.urlencode(params)
    for attempt in range(tries):
        req = urllib.request.Request(url, headers={"User-Agent": UA, **(headers or {})})
        try:
            with urllib.request.urlopen(req, timeout=120) as r:
                return r.status, r.read().decode("utf-8", "replace")
        except urllib.error.HTTPError as e:
            body = e.read().decode("utf-8", "replace")
            if e.code in (429, 500, 502, 503) and attempt < tries - 1:
                wait = 2 ** attempt * 3
                print(f"  {e.code} on {url[:70]}... retry in {wait}s", file=sys.stderr)
                time.sleep(wait)
                continue
            return e.code, body
    raise RuntimeError("unreachable")
Enter fullscreen mode Exit fullscreen mode

The User-Agent matters. When I sent an empty User-Agent, /charts/best answered 503 both times I tried. With the Python default (Python-urllib/3.x) or a descriptive string like the one above, it answered 200. Put a real contact in yours.

Step 2: Parse the chart page

https://www.audible.com/charts/best is server-rendered HTML, so you don't need a browser. Each title sits in an element with id="product-list-item-<ASIN>", the visible rank is in an <h3> ("1.", "2.", ...), and the title is in an aria-label attribute. Splitting the page on the item ID is simpler and sturdier than a full HTML parser here:

def chart_url(category=None):
    # robots.txt has "Disallow: /charts/*?" -> only fetch query-less chart URLs (page 1, 20 titles)
    return f"{WEB}/charts/best" + (f"/{category}" if category else "")


def parse_chart(page):
    rows = []
    for block in page.split('id="product-list-item-')[1:]:
        asin = block[:10]
        title = re.search(r"aria-label='([^']*)'", block)
        rank = re.search(r'<h3[^>]*>\s*<span[^>]*>\s*(\d+)\.\s*</span>', block)
        rows.append({
            "rank": int(rank.group(1)) if rank else None,
            "asin": asin,
            "title": html.unescape(html.unescape(title.group(1))) if title else None,  # double-escaped in markup
        })
    return rows


def fetch_chart(category=None):
    status, page = get(chart_url(category))
    if status != 200:
        raise SystemExit(f"chart page returned HTTP {status}")
    rows = parse_chart(page)
    if not rows:
        raise SystemExit("chart page parsed to 0 rows: markup changed, look at the HTML")
    return rows
Enter fullscreen mode Exit fullscreen mode

Two things I hit while writing this:

  • Titles are double-escaped. The aria-label contains Carl&amp;#39;s Doomsday Scenario, so one html.unescape() leaves you with Carl&#39;s. You need to unescape twice.
  • data-position restarts on every page. Each item also has a data-position attribute. On a ?page=2 URL it starts again at 1, so it isn't the chart rank. (I fetched page 2 once while exploring, before I'd read robots.txt. The script doesn't.) Use the visible <h3> rank.

fetch_chart() exits loudly if the page parses to zero rows. A silent empty chart in a tracker looks exactly like "nothing changed".

Step 3: The catalog API, and why its "best sellers" sort isn't the chart

The chart page doesn't give you exact rating counts, the narration/story split, release dates, or runtime. The catalog API does, and it accepts up to 20 ASINs per call via asins=. You choose the fields with response_groups. Without product_desc you get no title at all: my first run crashed with KeyError: 'title' until I added it.

def catalog(asins):
    """Batch lookup, 20 ASINs per call. Returns {asin: product}."""
    out = {}
    for i in range(0, len(asins), 20):
        chunk = asins[i:i + 20]
        status, body = get(CATALOG, {"asins": ",".join(chunk), "response_groups": GROUPS})
        if status != 200:
            raise SystemExit(f"catalog API HTTP {status}: {body[:200]}")
        for p in json.loads(body).get("products", []):
            out[p["asin"]] = p
        time.sleep(1)
    return out


def catalog_sorted(sort="BestSellers", n=20, category=None):
    params = {"products_sort_by": sort, "num_results": n, "response_groups": GROUPS}
    if category:
        params["category_id"] = category
    status, body = get(CATALOG, params)
    if status != 200:
        raise SystemExit(f"catalog API HTTP {status}: {body[:200]}")
    return json.loads(body)


def dist(p, kind="overall"):
    d = (p.get("rating") or {}).get(f"{kind}_distribution") or {}
    return d.get("average_rating") or 0.0, d.get("num_ratings") or 0
Enter fullscreen mode Exit fullscreen mode

The catalog API also has a products_sort_by=BestSellers option, and it's tempting to treat that as the chart. probe puts the two side by side:

def cmd_probe():
    """Is the API's BestSellers sort the same list as the chart page? (It isn't.)"""
    chart = fetch_chart()
    api = catalog_sorted("BestSellers", 20)
    api_asins = [p["asin"] for p in api["products"]]
    print(f"chart page: {len(chart)} titles | catalog sort=BestSellers: {len(api_asins)} of {api['total_results']:,}")
    print(f"{'#':>2}  {'chart page':<42} {'API BestSellers sort':<42}")
    for i in range(10):
        c = chart[i]["title"]
        a = api["products"][i]["title"] + f" ({api['products'][i].get('release_date')})"
        print(f"{i + 1:>2}  {short(c, 42):<42} {short(a, 42):<42}")
    overlap = set(api_asins) & {r["asin"] for r in chart}
    print(f"overlap in top 20: {len(overlap)}")
Enter fullscreen mode Exit fullscreen mode
$ python3 audible.py probe
chart page: 20 titles | catalog sort=BestSellers: 20 of 66,012
 #  chart page                                 API BestSellers sort                      
 1  Exoplanet                                  Love Me Wicked: Zeke Wicked (The Wickeds:…
 2  Dungeon Crawler Carl                       To Crown It All (2026-11-17)              
 3  A Court of Splintered Harmony              Bro Doll (2027-02-16)                     
 4  Daddy Issues                               Blood of the Bastion (2026-11-14)         
 5  Carl's Doomsday Scenario                   The Washwoman at the River's End (2027-03…
 6  Mad Mabel                                  Building the Marriage You Want (2027-01-2…
 7  Sunrise on the Reaping (The Hunger Games)  A Majestic Christmas (The Billionaire Bro…
 8  The Dungeon Anarchist's Cookbook           Last Ride (2026-12-08)                    
 9  The Gate of the Feral Gods                 Deck the Halls with Boughs of Murder (202…
10  The Witch                                  Dragon Bound 4: A Legacy Building Fantasy…
overlap in top 20: 0
Enter fullscreen mode Exit fullscreen mode

Zero overlap in the top 20. The API's "BestSellers" sort is full of books released in the last few days or still on pre-order (release dates out to March 2027), most with 0 to 6 ratings. Whatever that sort ranks by, it isn't the public chart. If you write about "Audible best sellers", the chart page is the source that matches what readers see.

The total_results figure isn't stable either. For the same BestSellers query I saw 65,243 at about 10:59, 66,012 at 11:03, and 74,865 at 11:05 (UTC+7, all on November 16). Don't treat it as a catalog size.

Step 4: The chart with real numbers

chart takes the 20 ASINs from the page and looks them up in one batch call:

def cmd_chart(category=None):
    rows = fetch_chart(category)
    meta = catalog([r["asin"] for r in rows])
    print(f"{chart_url(category)}  ({len(rows)} titles)")
    print(f"{'#':>2}  {'title':<40} {'ratings':>8} {'overall':>7} {'perf':>5} {'story':>5} {'hrs':>5}  released")
    for r in rows:
        p = meta.get(r["asin"], {})
        o, n = dist(p)
        perf, _ = dist(p, "performance")
        story, _ = dist(p, "story")
        hrs = (p.get("runtime_length_min") or 0) / 60
        print(f"{r['rank']:>2}  {short(r['title'], 40):<40} {n:>8,} {o:>7.2f} {perf:>5.2f} {story:>5.2f} "
              f"{hrs:>5.1f}  {p.get('release_date', '?')}")
    missing = [r["asin"] for r in rows if r["asin"] not in meta]
    if missing:
        print("not returned by catalog API:", ", ".join(missing))
Enter fullscreen mode Exit fullscreen mode
$ python3 audible.py chart
https://www.audible.com/charts/best  (20 titles)
 #  title                                     ratings overall  perf story   hrs  released
 1  Exoplanet                                   5,686    4.44  4.70  4.34   4.1  2026-11-05
 2  Dungeon Crawler Carl                       73,987    4.84  4.92  4.80  13.5  2021-01-28
 3  A Court of Splintered Harmony               6,108    4.38  4.69  4.29  12.0  2026-10-27
 4  Daddy Issues                                1,463    4.88  4.82  4.88   6.3  2026-11-10
 5  Carl's Doomsday Scenario                   42,193    4.89  4.96  4.86  11.5  2021-04-22
 6  Mad Mabel                                  20,920    4.79  4.86  4.77   9.3  2026-04-21
 7  Sunrise on the Reaping (The Hunger Game…   39,401    4.85  4.82  4.83  12.8  2025-03-18
 8  The Dungeon Anarchist's Cookbook           40,430    4.89  4.96  4.85  16.9  2021-05-14
 9  The Gate of the Feral Gods                 33,302    4.90  4.97  4.88  18.1  2021-09-16
10  The Witch                                   9,764    4.49  4.57  4.46   9.5  2026-10-06
11  The Butcher's Masquerade                   35,809    4.94  4.98  4.92  23.6  2022-05-26
12  The Eye of the Bedlam Bride                25,796    4.91  4.97  4.89  26.8  2023-09-01
13  This Inevitable Ruin                       31,933    4.93  4.97  4.90  28.7  2025-02-11
14  Theo of Golden                             39,731    4.84  4.88  4.81  13.2  2025-12-02
15  A Parade of Horribles                      33,382    4.92  4.98  4.89  20.4  2026-05-12
16  The Demon-Haunted World                     5,812    4.67  4.69  4.67  17.4  2017-05-30
17  Department of Fate                             28    4.89  4.93  4.96  15.8  2026-11-10
18  Contend                                     1,670    4.97  4.96  4.92   7.8  2026-10-13
19  Bad in Bed                                 11,013    4.78  4.88  4.71   8.7  2026-10-22
20  Threshing Day (Wing and Claw Collection)    9,737    4.79  4.84  4.76   5.9  2026-09-29
Enter fullscreen mode Exit fullscreen mode

A few things stand out:

  • Rank isn't popularity. Department of Fate is #17 with 28 ratings, released six days earlier. Dungeon Crawler Carl, from January 2021, is #2 with 73,987. The chart reflects recent sales, while rating counts pile up over years, so don't use one as a stand-in for the other.
  • One author takes 8 of the 20 spots. Matt Dinniman's Dungeon Crawler Carl books are at #2, #5, #8, #9, #11, #12, #13, and #15. Series backlists move together on Audible, and a chart tracker should group by series or author, not only by title.
  • There are three averages, not one. Every title has overall, performance, and story distributions. That's the most Audible-specific thing in the data, and Step 5 uses it.

Step 5: Narration vs. story

On Audible, listeners rate the performance (the narrator) separately from the story. That lets you ask a question you can't ask about print books: where does the narrator lift the book, and where do they hold it back? split reads several genre charts, removes repeats (a title can appear on the overall chart and two genre charts), skips titles with fewer than 200 ratings on either axis, and sorts by performance - story:

def cmd_split(categories):
    """Narration vs story: where do listeners rate the performance above the book?"""
    rows, seen, dupes = [], set(), 0
    for cat in categories:
        chart = fetch_chart(cat or None)
        meta = catalog([r["asin"] for r in chart])
        for r in chart:
            p = meta.get(r["asin"])
            if r["asin"] in seen:  # same title on several charts: count it once
                dupes += 1
                continue
            seen.add(r["asin"])
            if not p:
                continue
            perf, pn = dist(p, "performance")
            story, sn = dist(p, "story")
            if min(pn, sn) < 200:  # tiny samples swing wildly
                continue
            narrators = ", ".join(n["name"] for n in p.get("narrators", [])[:2])
            label = cat.split("/")[0].removesuffix("-audiobooks") if cat else "overall"
            rows.append((perf - story, perf, story, min(pn, sn), r["title"], narrators, label))
        time.sleep(2)
    rows.sort(reverse=True)
    print(f"{len(seen)} unique titles on {len(categories)} charts ({dupes} repeats skipped); "
          f"{len(rows)} have >=200 performance and story ratings\n")
    print(f"{'gap':>6} {'perf':>5} {'story':>5} {'n':>8}  title / narrator")
    for row in rows[:8] + [None] + rows[-5:]:
        if row is None:
            print("   ...")
            continue
        g, perf, story, n, title, narr, cat = row
        print(f"{g:>+6.2f} {perf:>5.2f} {story:>5.2f} {n:>8,}  {short(title, 36)} / {short(narr, 28)} [{short(cat, 20)}]")
    gaps = [r[0] for r in rows]
    print(f"\nperformance > story for {sum(g > 0 for g in gaps)} of {len(gaps)} titles; "
          f"median gap {sorted(gaps)[len(gaps) // 2]:+.3f}")
Enter fullscreen mode Exit fullscreen mode

The category paths come from the links on the chart page itself (/charts/best/<slug>/<id>). I used the overall chart plus six genres:

$ python3 audible.py split "" science-fiction-fantasy-audiobooks/18580606011 \
    mystery-thriller-suspense-audiobooks/18574597011 romance-audiobooks/18580518011 \
    biographies-memoirs-audiobooks/18571951011 business-careers-audiobooks/18572029011 \
    history-audiobooks/18573518011
106 unique titles on 7 charts (34 repeats skipped); 91 have >=200 performance and story ratings

   gap  perf story        n  title / narrator
 +0.59  4.58  3.99      415  All She Wants for Christmas / Ruth Wilson, Matthew Rhys [mystery-thriller-su…]
 +0.47  4.45  3.98   20,679  Yesteryear: A GMA Book Club Pick / Rebecca Lowman [mystery-thriller-su…]
 +0.44  4.34  3.91      274  Caller Unknown / Juliet Rylance [mystery-thriller-su…]
 +0.40  4.69  4.29    5,980  A Court of Splintered Harmony / Elizabeth Evans [overall]
 +0.39  4.82  4.43      284  Split Second: Thirty-Two Switcheroo / Lorelei King [mystery-thriller-su…]
 +0.37  4.70  4.34    5,605  Exoplanet / Anthony Mackie, Ariana DeBo… [overall]
 +0.30  4.72  4.42      631  Christmas Staycation / Kelsey Navarro Foster, Bran… [romance]
 +0.29  4.51  4.22      961  The Single Father / Tamaryn Payne [mystery-thriller-su…]
   ...
 -0.06  4.82  4.88    1,459  Daddy Issues / Sofia Franklyn [overall]
 -0.06  4.76  4.82   35,060  Bad Blood / Will Damron [business-careers]
 -0.09  4.57  4.66    2,190  Influence, New and Expanded / Robert B. Cialdini [business-careers]
 -0.10  4.61  4.71      370  The Nerd Reich / Gil Durán [business-careers]
 -0.14  4.55  4.69   53,310  Fourth Wing / Rebecca Soler, Teddy Hamilt… [science-fiction-fan…]

performance > story for 73 of 91 titles; median gap +0.082
Enter fullscreen mode Exit fullscreen mode

From this one snapshot:

  • Narrators usually score higher. Performance beat story for 73 of 91 titles, but the median gap is small (+0.082 stars).
  • Thrillers top the list. Four of the five biggest positive gaps are on the mystery/thriller chart. A story average just under 4.0 with performance above 4.3 is a book that listeners rate for its narrator.
  • Business and memoir go the other way. Business books and an author-read memoir (Daddy Issues) are among the few where story beats performance. Fourth Wing has the largest negative gap of the sample (-0.14) on 53,310 ratings, so that's not small-sample noise.
  • Keep the 200-rating floor. Without it, Department of Fate (28 ratings) would show up with a confident-looking gap from a handful of people.

This is one day's chart, not a study. To say anything about narrators in general, run it across many snapshots and categories.

Step 6: Searches, single titles, reviews, and authors through an API

Past the chart, the edge cases pile up: ASINs differ by marketplace, reviews come from a separate endpoint whose raw payload includes the reviewer's Amazon account ID (which you shouldn't store), and author pages and the category tree are more undocumented shapes that can change without notice.

So the rest of the script uses ScrapeAtlas*, a scraping API that covers 50 platforms, Audible among them. It returns the same catalog data as normalized JSON (rating.overall/performance/story, authors[], categories[] ladders), takes marketplace as a parameter (us, uk, ca, au, in, de, fr, it, es, jp), and returns review objects without the account ID. The helper sends an x-api-key header and turns error responses into readable messages:

def sa(path, **params):
    if not SA_KEY:
        raise SystemExit("Set SCRAPEATLAS_API_KEY first.")
    status, body = get(f"{SA_API}/{path}", params, headers={"x-api-key": SA_KEY})
    data = json.loads(body)
    if status != 200:
        failure = data.get("failure") or {}
        raise SystemExit(f"ScrapeAtlas {path} HTTP {status}: {failure.get('code')} {failure.get('message')}")
    return data


def short(s, n):
    s = s or ""
    return s if len(s) <= n else s[: n - 1] + "…"
Enter fullscreen mode Exit fullscreen mode

I tested six Audible routes: search, audiobook, reviews, author, categories, and best-sellers.

Search

def cmd_sa_search(query):
    data = sa("search", query=query, sort="relevance", limit=5)
    print(f"search {query!r}: {data['total']} results (showing {len(data['results'])})")
    for b in data["results"]:
        o = b["rating"]["overall"]
        print(f"  {b['asin']}  {short(b['title'], 44):<44} {o['count']:>8,} ratings  avg {o['average']:.2f}  "
              f"{b['runtimeMinutes'] / 60:.1f}h  {b['releaseDate']}")
Enter fullscreen mode Exit fullscreen mode
$ python3 audible.py search dungeon crawler carl
search 'dungeon crawler carl': 154 results (showing 5)
  B08V8B2CGV  Dungeon Crawler Carl                           73,987 ratings  avg 4.84  13.5h  2021-01-28
  B0934GTSGT  Carl's Doomsday Scenario                       42,193 ratings  avg 4.89  11.5h  2021-04-22
  B094XCNV6G  The Dungeon Anarchist's Cookbook               40,430 ratings  avg 4.89  16.9h  2021-05-14
  B09GCYRZRQ  The Gate of the Feral Gods                     33,302 ratings  avg 4.90  18.1h  2021-09-16
  B0GL147D7S  Cello's Gate                                       28 ratings  avg 4.71  18.9h  2026-11-03
Enter fullscreen mode Exit fullscreen mode

The fifth result, Cello's Gate, is a different book released 2026-11-03, with 28 ratings. Title search matches on words, so check the author before you trust a top-N list.

One title with all three distributions

def cmd_sa_book(asin, marketplace="us"):
    b = sa("audiobook", asin=asin, marketplace=marketplace)["audiobook"]
    print(f"{b['title']}  [{b['asin']}, {marketplace}]")
    print(f"  by {', '.join(a['name'] for a in b['authors'])} | read by {', '.join(n['name'] for n in b['narrators'])}")
    print(f"  {b['publisher']} | released {b['releaseDate']} | {b['runtimeMinutes'] // 60}h{b['runtimeMinutes'] % 60:02d}m | {b['formatType']}")
    for kind in ("overall", "performance", "story"):
        d = b["rating"][kind]
        bars = " ".join(f"{s}*:{d[w]:,}" for s, w in zip("54321", ("five", "four", "three", "two", "one")))
        print(f"  {kind:<11} avg {d['average']:.3f} from {d['count']:,}  ({bars})")
    print(f"  written reviews: {b['rating']['reviewCount']:,}")
    print("  categories:", " | ".join(" > ".join(c["name"] for c in ladder) for ladder in b["categories"]))
Enter fullscreen mode Exit fullscreen mode
$ python3 audible.py book B0GP1KB3T5
Daddy Issues  [B0GP1KB3T5, us]
  by Sofia Franklyn | read by Sofia Franklyn
  Simon & Schuster Audio | released 2026-11-10 | 6h19m | unabridged
  overall     avg 4.879 from 1,463  (5*:1,345 4*:81 3*:21 2*:10 1*:6)
  performance avg 4.818 from 1,459  (5*:1,292 4*:101 3*:40 2*:19 1*:7)
  story       avg 4.875 from 1,459  (5*:1,341 4*:78 3*:22 2*:12 1*:6)
  written reviews: 252
  categories: Biographies & Memoirs > Entertainment & Celebrities | Biographies & Memoirs > Women
Enter fullscreen mode Exit fullscreen mode

Only 252 written reviews against 1,463 ratings. Most Audible listeners give stars without writing anything, so a review sample tells you about the people who write, not about everyone who rated.

ASINs are per marketplace

$ python3 audible.py book B08V8B2CGV de; python3 audible.py book B08V893CH7 de
ScrapeAtlas audiobook HTTP 404: not_found The Audible audiobook, author or category was not found.
--- same book, audible.de's English-edition ASIN:
Dungeon Crawler Carl  [B08V893CH7, de]
  by Matt Dinniman | read by Jeff Hays
  Audible Studios | released 2021-01-28 | 13h31m | unabridged
  overall     avg 4.775 from 1,802  (5*:1,530 4*:187 3*:49 2*:23 1*:13)
  performance avg 4.910 from 1,472  (5*:1,380 4*:68 3*:13 2*:6 1*:5)
  story       avg 4.702 from 1,472  (5*:1,185 4*:190 3*:63 2*:14 1*:20)
  written reviews: 159
  categories: Literatur & Belletristik > Belletristik > Mit Videospiel-, Film- & Fernsehbezug | Krimis & Thriller > Thriller | Science Fiction & Fantasy > Fantasy > Paranormal & Urban Fantasy > Zeitgenössische Fantasy
Enter fullscreen mode Exit fullscreen mode

The US ASIN for Dungeon Crawler Carl doesn't exist on audible.de: the English edition sold there is B08V893CH7, and there's a German translation (B0G4RYRYB3) as well. ScrapeAtlas gives a clean 404 not_found for the wrong one. The raw catalog API is less helpful: api.audible.de/1.0/catalog/products/B08V8B2CGV answered HTTP 200 with {"product":{"asin":"B08V8B2CGV"},"response_groups":["always-returned"]}, which is an empty product, not an error. If you go direct, check for a title before you trust a 200. Also notice the German listeners' split for the same audiobook: performance 4.910 vs. story 4.702.

Reviews: recent vs. critical vs. everyone

def cmd_sa_reviews(asin, pages=3):
    """Pull 'critical' and 'recent' reviews and compare the sample with the full distribution."""
    for sort in ("recent", "critical"):
        reviews, meta = [], None
        for page in range(1, pages + 1):
            data = sa("reviews", asin=asin, sort=sort, page=page, limit=20)
            meta = meta or data
            reviews += data["reviews"]
            if not data["hasMore"]:
                break
            time.sleep(1)
        stars = [r["overallRating"] for r in reviews if r["overallRating"]]
        low = sum(s <= 2 for s in stars)
        print(f"sort={sort}: {len(reviews)} reviews, {low} rated 1-2 stars "
              f"({low / max(len(stars), 1):.0%}), dates {min(r['submittedAt'] for r in reviews)[:10]}"
              f" .. {max(r['submittedAt'] for r in reviews)[:10]}")
        for r in reviews[:3]:
            print(f"   {r['overallRating']}/{r['performanceRating']}/{r['storyRating']}  "
                  f"{short(r['title'].strip(), 40)!r}  helpful={r['helpfulVotes']}")
    d = meta["rating"]["overall"]
    print(f"all ratings: {(d['one'] + d['two']) / d['count']:.1%} are 1-2 stars "
          f"({d['one'] + d['two']:,} of {d['count']:,})")
Enter fullscreen mode Exit fullscreen mode
$ python3 audible.py reviews B0HDFGKSTL
sort=recent: 60 reviews, 14 rated 1-2 stars (23%), dates 2026-11-15 .. 2026-11-16
   5/5/5  'Time is an insane !'  helpful=0
   5/5/5  'WOW'  helpful=0
   4/5/4  'Good listen'  helpful=0
sort=critical: 60 reviews, 60 rated 1-2 stars (100%), dates 2026-11-09 .. 2026-11-15
   1/3/1  "that's some pretty bad writing"  helpful=0
   1/2/1  "One of the worst books I've ever read"  helpful=0
   1/2/1  'Why would Andy Weir produce this?'  helpful=0
all ratings: 6.8% are 1-2 stars (385 of 5,687)
Enter fullscreen mode Exit fullscreen mode

This is the most useful output in the post if you analyze review sentiment. Exoplanet was the #1 title on the chart that morning:

  • All 60 of the most recent reviews were posted within about a day (November 15 to 16). For a hot new release, "recent" means the last few hours, not a representative sample.
  • 23% of those recent reviews are 1–2 stars, but only 6.8% of all 5,687 ratings are. People who write reviews in launch week are much more negative than the star ratings overall. If you build a "sentiment" metric from the newest reviews, it'll read as much worse than the book's actual rating.
  • sort=critical is exactly what it says: all 60 reviews were 1–2 stars. It's useful for "what do people complain about", useless as a sample.
  • Notice the scores like 1/3/1: a critical reviewer can still rate the narration higher than the story. That's the Step 5 split again, one listener at a time.

Authors and categories

def cmd_sa_author(asin):
    data = sa("author", asin=asin, limit=50)
    a = data["author"]
    print(f"{a['name']} ({a['asin']}): {data['total']} titles on Audible US")
    rows = []
    for b in data["books"]:
        o = b["rating"]["overall"]
        rows.append((o["count"], b))
    for n, b in sorted(rows, key=lambda x: -x[0])[:10]:
        lang = "" if b["language"] == "english" else f" [{b['language']}]"
        print(f"  {n:>8,}  {b['rating']['overall']['average']:.2f}  {short(b['title'], 44)}{lang}  {b['releaseDate']}")


def cmd_sa_categories():
    data = sa("categories")
    cats = data["categories"]
    print(f"{len(cats)} top-level categories, {sum(len(c.get('children', [])) for c in cats)} children")
    for c in cats[:6]:
        print(f"  {c['id']}  {c['name']} ({len(c.get('children', []))} children)")
Enter fullscreen mode Exit fullscreen mode
$ python3 audible.py author B002BLP1QY
Matt Dinniman (B002BLP1QY): 38 titles on Audible US
    73,987  4.84  Dungeon Crawler Carl  2021-01-28
    42,193  4.89  Carl's Doomsday Scenario  2021-04-22
    40,430  4.89  The Dungeon Anarchist's Cookbook  2021-05-14
    35,809  4.94  The Butcher's Masquerade  2022-05-26
    33,382  4.92  A Parade of Horribles  2026-05-12
    33,302  4.90  The Gate of the Feral Gods  2021-09-16
    31,933  4.93  This Inevitable Ruin  2025-02-11
    25,796  4.91  The Eye of the Bedlam Bride  2023-09-01
     7,172  4.59  Operation Bounce House  2026-02-10
     2,705  4.35  Dominion of Blades  2017-06-22

$ python3 audible.py categories
24 top-level categories, 240 children
  18571910011  Arts & Entertainment (6 children)
  18571951011  Biographies & Memoirs (15 children)
  18572029011  Business & Careers (6 children)
  18572091011  Children's Audiobooks (20 children)
  24427740011  Comedy & Humor (3 children)
  18573211011  Computers & Technology (6 children)
Enter fullscreen mode Exit fullscreen mode

The author list explains Step 4: the eight Dungeon Crawler Carl audiobooks on the chart are the author's eight most-rated titles. The category IDs are the same ones in the chart URLs, so you can build /charts/best/<slug>/<id> for any of the 24 top-level categories without scraping the navigation.

The best-sellers route has the same catch as Step 3

def cmd_sa_bestsellers(category=None, marketplace="us"):
    params = {"limit": 10, "marketplace": marketplace}
    if category:
        params["categoryId"] = category
    data = sa("best-sellers", **params)
    print(f"best-sellers {marketplace} category={category}: total {data['total']:,}")
    for i, b in enumerate(data["results"], 1):
        print(f"  {i:>2}. {short(b['title'], 46):<46} {b['rating']['overall']['count']:>7,} ratings  released {b['releaseDate']}")
Enter fullscreen mode Exit fullscreen mode
$ python3 audible.py bestsellers
best-sellers us category=None: total 74,865
   1. Love Me Wicked: Zeke Wicked (The Wickeds: Dar…       2 ratings  released 2026-11-13
   2. To Crown It All                                      0 ratings  released 2026-11-17
   3. Bro Doll                                             0 ratings  released 2027-02-16
   4. Blood of the Bastion                                 0 ratings  released 2026-11-14
   5. The Washwoman at the River's End                     0 ratings  released 2027-03-23
   6. Building the Marriage You Want                       0 ratings  released 2027-01-26
   7. A Majestic Christmas (The Billionaire Brother…       6 ratings  released 2026-11-13
   8. Last Ride                                            0 ratings  released 2026-12-08
   9. Deck the Halls with Boughs of Murder                 0 ratings  released 2026-11-24
  10. Dragon Bound 4: A Legacy Building Fantasy            5 ratings  released 2026-11-13
Enter fullscreen mode Exit fullscreen mode

This is the same order as the catalog API's BestSellers sort from Step 3 (Love Me Wicked, To Crown It All, Bro Doll, ...), not the chart page. To be clear about what I found: it's useful for spotting new and upcoming releases that sell early. If you need the public top-20 chart, read the chart page as in Step 2 and use the API only to add data to it. That's what the tracker does.

Step 7: Track the chart in SQLite

A single snapshot only tells you the order right now. The tracker stores each chart's 20 rows with rating and review counts, then compares with the previous snapshot for that chart. It prints entries, exits, rank moves, and how many ratings and reviews each title gained:

SCHEMA = """
CREATE TABLE IF NOT EXISTS snap (taken TEXT, chart TEXT, rank INTEGER, asin TEXT, title TEXT,
                                 ratings INTEGER, avg REAL, reviews INTEGER,
                                 PRIMARY KEY (taken, chart, asin));
"""


def cmd_track(categories):
    db = sqlite3.connect(DB)
    db.executescript(SCHEMA)
    taken = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
    for cat in categories:
        name = cat or "overall"
        prev_at = db.execute("SELECT max(taken) FROM snap WHERE chart=?", (name,)).fetchone()[0]
        prev = {r[0]: r[1:] for r in db.execute(
            "SELECT asin, rank, ratings, reviews, title FROM snap WHERE chart=? AND taken=?", (name, prev_at))}
        rows = fetch_chart(cat or None)
        meta = catalog([r["asin"] for r in rows])
        print(f"[{name}] {taken} vs {prev_at or 'nothing (first run)'}")
        for r in rows:
            p = meta.get(r["asin"], {})
            avg, n = dist(p)
            reviews = (p.get("rating") or {}).get("num_reviews") or 0
            db.execute("INSERT INTO snap VALUES (?,?,?,?,?,?,?,?)",
                       (taken, name, r["rank"], r["asin"], r["title"], n, avg, reviews))
            if not prev:
                continue
            if r["asin"] not in prev:
                print(f"  NEW  #{r['rank']:<2} {short(r['title'], 44)}  ({n:,} ratings)")
                continue
            old_rank, old_n, old_rev, _ = prev[r["asin"]]
            if old_rank != r["rank"] or n != old_n:
                move = old_rank - r["rank"]
                arrow = f"up {move}" if move > 0 else f"down {-move}" if move < 0 else "same"
                print(f"  #{r['rank']:<2} ({arrow:>7})  {short(r['title'], 40):<40} ratings {n - old_n:+,}  reviews {reviews - old_rev:+,}")
        for asin, (old_rank, _, _, title) in prev.items():
            if asin not in {r["asin"] for r in rows}:
                print(f"  OUT  was #{old_rank:<2} {short(title, 44)}")
        if not prev:
            print(f"  stored {len(rows)} rows")
        db.commit()
        time.sleep(2)
Enter fullscreen mode Exit fullscreen mode

First run (overall chart plus Science Fiction & Fantasy):

$ python3 audible.py track "" science-fiction-fantasy-audiobooks/18580606011
[overall] 2026-11-16T04:06:04Z vs nothing (first run)
  stored 20 rows
[science-fiction-fantasy-audiobooks/18580606011] 2026-11-16T04:06:04Z vs nothing (first run)
  stored 20 rows
Enter fullscreen mode Exit fullscreen mode

Second run, 23 minutes later:

$ python3 audible.py track "" science-fiction-fantasy-audiobooks/18580606011
[overall] 2026-11-16T04:29:01Z vs 2026-11-16T04:06:04Z
  #1  (   same)  Exoplanet                                ratings +6  reviews +1
  #4  (   same)  Daddy Issues                             ratings +1  reviews +0
  #6  (   same)  Mad Mabel                                ratings +3  reviews +1
  #7  (   same)  Sunrise on the Reaping (The Hunger Game… ratings +6  reviews +0
  #9  (   same)  The Gate of the Feral Gods               ratings +1  reviews +0
  #10 (   same)  The Witch                                ratings +4  reviews +1
  #14 (   same)  Theo of Golden                           ratings +2  reviews +0
  #15 (   same)  A Parade of Horribles                    ratings +1  reviews +0
  #18 (   same)  Contend                                  ratings +2  reviews +0
  #19 (   same)  Bad in Bed                               ratings +3  reviews +0
  #20 (   same)  Threshing Day (Wing and Claw Collection) ratings +1  reviews +0
[science-fiction-fantasy-audiobooks/18580606011] 2026-11-16T04:29:01Z vs 2026-11-16T04:06:04Z
  #1  (   same)  Exoplanet                                ratings +6  reviews +1
  #6  (   same)  The Gate of the Feral Gods               ratings +1  reviews +0
  #10 (   same)  A Parade of Horribles                    ratings +1  reviews +0
  #11 (   same)  Threshing Day (Wing and Claw Collection) ratings +1  reviews +0
  #12 (   same)  Project Hail Mary                        ratings +2  reviews +0
Enter fullscreen mode Exit fullscreen mode

Not a single rank changed in 23 minutes, on either chart, so the chart doesn't update in real time. Ratings did move: Exoplanet gained 6 ratings and 1 written review in that window (and shows up on both charts, since it's #1 in each), Sunrise on the Reaping gained 6, and titles that gained nothing are left out of the diff. Over a day, the "ratings gained" column is the more interesting one: it's a rough proxy for listening activity, which the chart's rank alone doesn't give you.

To run it daily, add a cron entry (or a systemd timer) and keep the cadence low. The charts don't need minute-level polling, and robots.txt already limits you to page one:

15 7 * * * cd /home/you/audible && SCRAPEATLAS_API_KEY=... python3 audible.py track "" science-fiction-fantasy-audiobooks/18580606011 >> track.log 2>&1
Enter fullscreen mode Exit fullscreen mode

The tracker only needs the chart page and the catalog API; the key matters only if you add Step 6 commands to the job. After a few weeks, query days on chart per title, best rank per series, and ratings gained per day vs. rank.

The CLI

if __name__ == "__main__":
    cmd, *args = sys.argv[1:] or ["help"]
    cats = args or [""]
    commands = {
        "probe": lambda: cmd_probe(),
        "chart": lambda: cmd_chart(args[0] if args else None),
        "split": lambda: cmd_split(cats),
        "search": lambda: cmd_sa_search(" ".join(args)),
        "book": lambda: cmd_sa_book(*args),
        "reviews": lambda: cmd_sa_reviews(args[0]),
        "author": lambda: cmd_sa_author(args[0]),
        "bestsellers": lambda: cmd_sa_bestsellers(*args),
        "categories": lambda: cmd_sa_categories(),
        "track": lambda: cmd_track(cats),
    }
    if cmd not in commands:
        raise SystemExit("usage: audible.py probe|chart [cat]|split [cat...]|search Q|book ASIN [mkt]|"
                         "reviews ASIN|author ASIN|bestsellers [catId] [mkt]|categories|track [cat...]")
    commands[cmd]()
Enter fullscreen mode Exit fullscreen mode

Gotchas I hit, collected

  • The terms prohibit scraping. The Audible conditions bring in Amazon's "no data mining, robots" clause. Read them before running anything.
  • robots.txt allows /charts/... without a query string only. That's page one, the top 20 per category.
  • "BestSellers" sort ≠ the chart. It showed zero overlap with the chart's top 20, and its total_results jumped between 65,243 and 74,865 in six minutes.
  • No product_desc, no title. response_groups decides which fields you get back.
  • An empty User-Agent got 503 on the chart page both times I tried it.
  • Titles are double-escaped in aria-label, and data-position restarts on every page.
  • ASINs are per marketplace. The raw API answers a wrong-marketplace ASIN with an empty 200.
  • Recent reviews aren't a sample. For new releases they cluster in the last day and run far more negative than the ratings.
  • Raw review payloads include author_id. Drop it if you collect reviews at all.
  • Rank ≠ rating count. A six-day-old book with 28 ratings sat at #17.

Wrapping up

  • The public chart is HTML. Read the top 20 per category, and let the catalog API fill in exact ratings, runtime, and release dates.
  • Audible's three rating axes (overall, performance, story) are its most distinctive data. In this snapshot narration beat story for 73 of 91 titles, and thrillers showed the biggest gaps.
  • Treat reviews with suspicion. Writers are a minority of raters, and launch-week reviewers are harsher.
  • Two SQLite snapshots show rank moves and new ratings, which is the closest public proxy for sales momentum.

What would you track on Audible: your own genre's chart, narrators, or new releases? And if you've found a better public signal for audiobook sales than the chart, I'd like to hear it.


*I build it.

Top comments (0)