Libex

KO | EN

gitlite — search

#javascript #python #hacktoberfest #react #ai #typescript #llm #go #golang #android #machine-learning #rust #deep-learning #linux

★ 9 Open GitHub ↗

Open, unrestricted Audible metadata API for the audiobook automation community

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://raw.githubusercontent.com/LibexHQ/Libex/main/LICENSE)
[![Tests](https://github.com/LibexHQ/Libex/actions/workflows/tests.yml/badge.svg)](https://github.com/LibexHQ/Libex/actions/workflows/tests.yml)
[![GHCR](https://img.shields.io/badge/ghcr.io-libexhq%2Flibex-blue)](https://github.com/LibexHQ/Libex/pkgs/container/libex)
[![Docker Hub](https://img.shields.io/badge/docker%20hub-sunbrolynk%2Flibex-blue)](https://hub.docker.com/r/sunbrolynk/libex)

[![Books](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Flibexdb.com%2Fdb%2Fstats&query=%24.books&label=Books&color=orange)](https://libexdb.com/db/stats)
[![Books with Chapters](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Flibexdb.com%2Fdb%2Fstats&query=%24.booksWithChapters&label=Books%20with%20Chapters&color=b5179e)](https://libexdb.com/db/stats)
[![Authors](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Flibexdb.com%2Fdb%2Fstats&query=%24.authors&label=Authors&color=teal)](https://libexdb.com/db/stats)
[![Narrators](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Flibexdb.com%2Fdb%2Fstats&query=%24.narrators&label=Narrators&color=blue)](https://libexdb.com/db/stats)
[![Series](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Flibexdb.com%2Fdb%2Fstats&query=%24.series&label=Series&color=purple)](https://libexdb.com/db/stats)

Open, unrestricted Audible metadata API for the audiobook automation community.

</div>

> [!WARNING]
> **The public instance is moving to [libexdb.com](https://libexdb.com).**
>
> The old address `libex.lostcartographer.xyz` **stops serving on 4 November 2026**.
> If you use the public instance, update your configuration to `https://libexdb.com`.
>
> [Details and questions →](https://github.com/LibexHQ/Libex/issues/183)

> [!NOTE]
> **Self-hosting?** This doesn't affect you — you point at your own server. Nothing to do.

---

## Public Instance

A free public instance of Libex is available at [Libex](https://libexdb.com)

This instance is maintained by the Libex project and is free for community use. No API key required. No rate limits beyond what Audible naturally enforces.

If you rely on Libex for a project or tool, we recommend self-hosting your own instance for reliability and control.

---

## Why Libex?

The audiobook automation community has long depended on metadata services to power tools like Readarr, Audiobookshelf, and custom managers. When those services disappear or restrict usage, every project depending on them breaks.

Libex exists to be a permanent, community-owned alternative:

- **MIT licensed** — no restrictions, fork it, build on it, use it however you want
- **No usage restrictions** — works with any software, any workflow
- **Drop-in replacement** — compatible with AudiMeta's API endpoints
- **Audible-first** — always fetches fresh data, the local database is a fallback not a crutch
- **Persistent local library** — every book, author, and series ever requested is stored and queryable
- **All regions** — full support for all Audible markets without language restrictions
- **Self-hostable** — one `docker compose up` and you're running

---

## Quick Start

Pull the image:
```bash
# GHCR
docker pull ghcr.io/libexhq/libex:latest

# Docker Hub
docker pull sunbrolynk/libex:latest
```

Deploy:
```bash
# 1. Create a directory
mkdir libex && cd libex

# 2. Download the compose file
curl -O https://raw.githubusercontent.com/LibexHQ/Libex/main/docker-compose.yml

# 3. Create your environment file
cp .env.example .env
# Edit .env — DB_PASSWORD is required, all other values have sensible defaults

# 4. Start Libex
docker compose up -d

# 5. Verify
curl http://localhost:3333/health
```

Or copy the compose file directly:

```yaml
services:
  libex:
    image: ghcr.io/libexhq/libex:latest
    container_name: libex
    restart: unless-stopped
    ports:
      - "${PORT:-3333}:3333"
    environment:
      - DATABASE_URL=postgresql+asyncpg://${DB_USER:-libex}:${DB_PASSWORD}@postgres:5432/${DB_NAME:-libex}
      - CACHE_TTL=${CACHE_TTL:-86400}
      - PORT=${PORT:-3333}
      - WEB_CONCURRENCY=${WEB_CONCURRENCY:-6}
      - LOG_RETENTION_DAYS=${LOG_RETENTION_DAYS:-7}
      - LOG_LEVEL=${LOG_LEVEL:-INFO}
    volumes:
      - ./logs:/app/logs
    depends_on:
      postgres:
        condition: service_healthy
    networks:
      - default
      - libex-proxy
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3333/health"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 40s

postgres:
    image: postgres:16-alpine
    container_name: libex-postgres
    restart: unless-stopped
    command: ["postgres", "-c", "max_connections=200"]
    ports:
      - "5432:5432"
    environment:
      POSTGRES_DB: ${DB_NAME:-libex}
      POSTGRES_USER: ${DB_USER:-libex}
      POSTGRES_PASSWORD: ${DB_PASSWORD}
    volumes:
      - ./data/postgres:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U ${DB_USER:-libex}"]
      interval: 10s
      timeout: 5s
      retries: 5

networks:
  libex-proxy:
    name: libex-proxy
    driver: bridge
```

---

## Logging & Privacy

**Libex does not record who calls it.** No IP address is logged — not in full,
not truncated, not hashed — and no header or connection detail that would
identify a caller is written anywhere. Search text is stripped from the log
lines Libex writes about a request, with one exception noted below. See
[PRIVACY.md](PRIVACY.md) for the full policy.

The public instance uses [Axiom](https://axiom.co) for structured request
logging, so that broken endpoints and failing deploys are visible. This is
disclosed transparently.

**What is logged:**
- Request method, path, and status code
- Response time
- Query parameters — **names and values are allowlisted.** Structural params
  (`region`, `limit`, `page`, `sort`, filters) keep their values; anything a
  caller typed (`name`, `keywords`, `title`, `author`) keeps its name and loses
  its value to `REDACTED`; a name Libex doesn't recognise is dropped from the
  line entirely
- User agent — this names client *software*, not a person, and with no address
  logged beside it there is nothing to tie it back to an individual
- Cache hit/miss
- The process id of the worker that handled the request — a number belonging to
  the server, identical for every request that worker serves, and unrelated to
  who sent any of them
- Errors and exceptions. An unhandled error logs its message so a broken deploy
  can be diagnosed; if a message was built from something you sent, that text
  appears in that one line

**What is NOT logged:**
- Your IP address, in any form
- Anything you typed into a search, apart from the error case above
- Cookies, trackers, or fingerprinting of any kind — Libex sets none

**Why we log:**
To see which endpoints are failing and how fast they respond. Without
per-endpoint visibility, a bad release breaks things silently. None of that
requires knowing who you are.

**Who can see the logs:**
Only the instance maintainer has access to the Axiom dataset. Logs are retained
for 30 days and then automatically deleted by Axiom. The public instance also
sits behind Cloudflare, which sees every request in order to terminate TLS —
including your real IP, which is outside Libex's control. Axiom and Cloudflare
receive this data only to provide those services; we don't sell your data or
hand it to anyone else.

**The API docs are served locally.** The interactive docs at `/docs` and
`/redoc` are rendered from assets Libex ships — not from a CDN. Opening them
contacts nothing but Libex.

**If you self-host:**
Logging is completely optional. Leave `AXIOM_TOKEN` empty and Libex logs to
stdout and a rotating file only — nothing leaves your server. Logs print at
`LOG_LEVEL` (default `INFO`); set it to `DEBUG` for more detail when
troubleshooting. Warnings and errors go to stderr, everything else to stdout,
and structured context (counts, IDs) is appended to each line so you can see
what a task actually did.

---

## API Behavior

**HTML content:** `description` and `summary` fields on book responses, `description` on author responses, and `description` on series responses are returned as plain text with HTML stripped.

**Image URLs:** Cover image URLs are returned with Audible size suffixes stripped, giving you the base high-resolution image URL.

**ASIN validation:** All ASIN parameters are validated against Audible's 10-character alphanumeric format. Invalid ASINs return a 404 with a clear error message.

**Region validation:** All region parameters are validated against supported Audible regions. Invalid regions return a 400 error.

**Local database:** Every successful Audible response is written to a persistent relational database. This powers the DB query endpoints and serves as a fallback when Audible is unavailable.

**Virtual Voice Audiobooks:** Book responses include `isVvab` (boolean indicating whether the book is a Virtual Voice Audiobook — AI-narrated rather than human-narrated).

**Audible plans:** Book responses include `plans` (list of Audible plan names such as `"US Minerva"` or `"AccessViaMusic"`), letting clients determine subscription availability programmatically.

**Narrator profiles:** Narrator responses from `/db/narrator` include enrichment data sourced from [NarratorList.com](https://narratorlist.com) and [AussieNarrator.com](https://aussienarrator.com) where available. When profile data is present, the response includes `source`, `sourceUrl` (link to the narrator's full profile), `sourceUpdatedAt`, and an `attribution` string (e.g. `"Profile data provided by NarratorList.com, retrieved May 2026"`). Consumers displaying narrator data should include this attribution where practical.

---

## Audiobookshelf Configuration

Audiobookshelf's custom metadata provider calls `/{region}/search`, not `/search`. When configuring ABS, set your base URL to include the region:

```
http://YOUR-IP:3333/us
```

ABS will then call `/us/search?title=...&author=...` which returns the `{"matches": [...]}` format ABS expects. The flat `/search` endpoint returns a different format that ABS cannot parse.

---

## API Endpoints

| Method | Endpoint | Description |
|--------|----------|-------------|
| GET | `/book/{asin}` | Get book by ASIN |
| GET | `/book` | Get multiple books by ASIN (comma-separated, max 1000) |
| GET | `/book/{asin}/chapters` | Get chapter information |
| GET | `/book/sku/{sku}` | Get all region variants of a book by SKU group |
| GET | `/author/{asin}` | Get author profile |
| GET | `/author/{asin}/books` | Get all books by author ASIN (legacy) |
| GET | `/author/books/{asin}` | Get all books by author ASIN |
| GET | `/author/books` | Get books by author name |
| GET | `/author` | Search authors by name |
| GET | `/series/{asin}` | Get series metadata |
| GET | `/series/{asin}/books` | Get all books in a series (legacy) |
| GET | `/series/books/{asin}` | Get all books in a series |
| GET | `/series` | Search series by name |
| GET | `/narrator/books` | Get books by narrator name |
| GET | `/search` | Search Audible catalog |
| GET | `/quick-search` | Quick search via suggestions |
| GET | `/new-releases` | Recently released books, scanned live from Audible, newest first. Scope to one `category` (from `/categories`); without it, returns a live sample |
| GET | `/coming-soon` | Upcoming books, scanned live from Audible, soonest first. Scope to one `category` (from `/categories`); without it, returns a live sample |
| GET | `/categories` | List Audible's genre categories for a region as a nested tree (up to five levels deep), or a flat list with `?flat=true`; limit the levels with `?depth=N` (`depth=1` for just the top-level parents) — the ids for the `category` param |
| GET | `/{region}/search` | Regional search for Audiobookshelf compatibility |
| GET | `/{region}/quick-search/search` | Regional quick search for Audiobookshelf compatibility |
| GET | `/db/book` | Query the local indexed book library |
| GET | `/db/book/{asin}` | Get a single book from local DB |
| GET | `/db/book/{asin}/chapters` | Get chapter data from local DB |
| GET | `/db/book/sku/{sku}` | Get books by SKU group from local DB |
| GET | `/db/plans` | Get all distinct Audible plan names from local DB |
| GET | `/db/plans/{plan_name}` | Get all books under a specific plan from local DB |
| GET | `/db/genres` | Get all distinct genre/tag names from local DB |
| GET | `/db/vvab` | Get all virtual voice audiobooks (AI-narrated) from local DB |
| GET | `/db/new-releases` | Get recently released books from local DB, newest first |
| GET | `/db/coming-soon` | Get upcoming books from local DB, soonest first |
| GET | `/db/stats` | Get counts of books, authors, narrators, series, and books with chapters in local DB |
| GET | `/db/author/{asin}` | Get author from local DB |
| GET | `/db/author/{asin}/books` | Get author's books from local DB |
| GET | `/db/narrator` | Search narrators by name from local DB |
| GET | `/db/narrator/books` | Get books by narrator name from local DB |
| GET | `/db/series/{asin}` | Get series from local DB |
| GET | `/db/series/{asin}/books` | Get series books from local DB |
| GET | `/health` | Health check |

Full interactive documentation available at `/docs` when running.

---

## DB Query Endpoints

`GET /db/book` queries books that have been fetched and stored locally without hitting Audible. Useful for searching your indexed library by metadata.

All parameters are optional but at least one filter (or a `sort`) must be provided. Supports pagination via `limit` (default 20, max 100) and `page` (default 1).

The same filter set is available on the other book-list DB endpoints too — `/db/vvab`, `/db/plans/{plan_name}`, `/db/author/{asin}/books`, `/db/series/{asin}/books`, and `/db/narrator/books` — minus whichever field is already the endpoint's scope (e.g. `/db/vvab` doesn't take `is_vvab`).

| Parameter | Type | Match |
|-----------|------|-------|
| `title` | string | ILIKE |
| `subtitle` | string | ILIKE |
| `author_name` | string | ILIKE (join) |
| `series_name` | string | ILIKE (join) |
| `description` | string | ILIKE |
| `summary` | string | ILIKE |
| `publisher` | string | ILIKE |
| `copyright` | string | ILIKE |
| `isbn` | string | ILIKE |
| `region` | string | exact |
| `language` | string | exact |
| `book_format` | string | exact |
| `content_type` | string | exact |
| `content_delivery_type` | string | exact |
| `rating_better_than` | float | >= |
| `rating_worse_than` | float | <= |
| `longer_than` | int | >= (minutes) |
| `shorter_than` | int | <= (minutes) |
| `explicit` | bool | exact |
| `whisper_sync` | bool | exact |
| `has_pdf` | bool | exact |
| `is_listenable` | bool | exact |
| `is_buyable` | bool | exact |
| `is_vvab` | bool | exact |
| `plan_name` | string | JSONB contains |
| `genre` | string | ILIKE against genre/tag names (e.g. `fantasy` matches "Science Fiction & Fantasy") |
| `category` | string | Exact match on a category id from `/categories` (e.g. `18580628011`), or a comma-separated list to match any of several (e.g. `18580628011,18573212011`). Use `genre` for broad name matching |

Use `/db/genres` to discover the genre/tag names for `genre` (optionally with `?search=`), or `/categories` to discover the category ids for `category`.

### Sorting

The DB list endpoints and the live book-list endpoints (`/author/{asin}/books`, `/series/{asin}/books`, `/author/books`, bulk `/book`) accept `sort` and `order` (`asc`/`desc`). Sortable fields: `title`, `releaseDate`, `rating`, `lengthMinutes`, `language`, `publisher`, `updatedAt`. Series book endpoints default to series position order unless a sort field is given. The live endpoints sort the returned set; sorting isn't offered on relevance-ranked search.

Those same live book-list endpoints also accept a subset of the filters — rating range, length range, `language`, `book_format`, the booleans, `plan_name`, and `genre` — applied to the returned set. The heavier free-text filters stay on `/db/book`, which has the indexes for them.

### Release windows (new releases & coming soon)

There are two pairs of endpoints for browsing by release date — a local DB pair and a live Audible pair. All four take a `days` window (one of 30, 60, 90, 120, 240, 365; default 30) and the full live filter set, plus `sort`/`order`. The live pair also takes an optional `category` (see below).

**Local DB** (instant, no Audible call):
- `GET /db/new-releases` — books released in the last `days`, newest first. Already-released only.
- `GET /db/coming-soon` — books releasing in the next `days`, soonest first. Future releases only; Audible's "no date yet" placeholder is excluded.

**Live** (scanned fresh from Audible):
- `GET /new-releases` — same look-back, newest first.
- `GET /coming-soon` — same look-ahead, soonest first.

Audible exposes no direct new-releases or coming-soon feed, and any single catalog query is capped at a few hundred results, so the live pair reconstructs each list by scanning the catalog. To stay fast, the live endpoints scan **one category at a time**: pass a `category` id (from `GET /categories`) to get the full window for that category. Without a `category`, the scan walks Audible's un-categoried catalog — which is capped — so the bare call returns a **live sample**, not the whole catalog. The results are date-based and can't change until the date rolls over, so they're cached until the next UTC midnight and refresh on the first request of the new day.

For the **complete** list across all categories, use the **DB** endpoints (`/db/new-releases`, `/db/coming-soon`) — the seeder walks every category in the background and keeps them current — or aggregate per-category `/new-releases` calls client-side. Use the **live** endpoints when you want the freshest data for a specific category straight from Audible, including brand-new pre-orders the seeder may not have picked up yet.

`GET /categories` returns the category ids (and names) you can pass as `category`, as a nested tree that mirrors Audible's full taxonomy — up to five levels deep and ragged (some branches stop early, some go the full depth), each node carrying its own children. It's fetched fresh from Audible on each call and reconciled into the local store, which mirrors Audible's current taxonomy — new categories are added and ones Audible has moved or dropped are pruned, so a reshuffle on their end doesn't leave stale entries behind. Pass `?flat=true` to get a flat list instead of the tree — each node carries its `ancestors` (the {id, name} chain from the top-level root down to its parent, in order), so its depth and lineage are still recoverable. Pass `?depth=N` to limit how many levels come back — `depth=1` returns just the top-level parents, `depth=2` the top two levels, and so on; this works with both the nested and flat forms. Note this is Audible's *category* taxonomy, which is different from `/db/genres` (the genre/tag *names* attached to stored books).

### Narrator filters

`GET /db/narrator` searches narrators by name and also filters on `gender`, `language` (matches a language the narrator works in), `audiobooks_produced` (one of the count buckets), `source`, and `cultural_heritage`.

---

## Supported Regions

| Code | Region |
|------|--------|
| `us` | United States |
| `uk` | United Kingdom |
| `ca` | Canada |
| `au` | Australia |
| `de` | Germany |
| `fr` | France |
| `it` | Italy |
| `es` | Spain |
| `jp` | Japan |
| `in` | India |
| `br` | Brazil |

---

## Configuration

Copy `.env.example` to `.env` and configure:

| Variable | Default | Description |
|----------|---------|-------------|
| `DB_PASSWORD` | — | **Required.** PostgreSQL password |
| `DB_NAME` | `libex` | PostgreSQL database name |
| `DB_USER` | `libex` | PostgreSQL username |
| `PORT` | `3333` | Host port the API is exposed on |
| `WEB_CONCURRENCY` | `6` | Number of API worker processes. `1` restores single-process behaviour. Keep it at `1` while `SEEDER_ENABLED=true`. Each worker carries its own outbound concurrency budget to Audible rather than a share of one, so raising this multiplies what Libex has in flight there. More is not free, and only your own connection can tell you what it tolerates |
| `CACHE_TTL` | `86400` | Default cache TTL in seconds (24 hours); some endpoints use their own TTL |
| `LOG_LEVEL` | `INFO` | Log verbosity — `DEBUG`, `INFO`, `WARNING`, or `ERROR` |
| `LOG_RETENTION_DAYS` | `7` | Days of rotated logs to keep. `0` = infinite, no rotation |
| `AXIOM_TOKEN` | — | Axiom API token (optional — leave blank for stdout only) |
| `AXIOM_DATASET` | `libex` | Axiom dataset name |
| `SEEDER_ENABLED` | `false` | Enable background DB seeder |
| `SEEDER_INTERVAL_HOURS` | `24` | Hours between seeder cycles |
| `SEEDER_REQUEST_DELAY` | `1.0` | Seconds between Audible requests during seeding |
| `SEEDER_REGIONS` | `us` | Comma-separated regions to seed (e.g. `us,uk,de`) |
| `SEEDER_NEW_RELEASES_INTERVAL_HOURS` | `24` | Hours between new-releases worker runs |
| `SEEDER_REFRESH_ENABLED` | `false` | Re-fetch upcoming pre-orders as their release date approaches |
| `AUDIBLE_PROXY_URL` | — | Proxy URL for outbound Audible requests only. Supports `http://`, `https://`, `socks5://`. API serving is unaffected |
| `SEED_SECRET` | — | PBKDF2 hash for the internal seed endpoint. Empty = endpoint disabled. Generate with `python -m app.api.routes.internal.router` |

`DATABASE_URL` is constructed automatically by docker-compose from `DB_NAME`, `DB_USER`, and `DB_PASSWORD`. Only set it manually if running outside of Docker.

---

## Migrating from AudiMeta

Libex is API-compatible with AudiMeta. To migrate:

1. Deploy Libex using the quick start above
2. Update your base URL from your AudiMeta instance to your Libex instance
3. That's it — no other changes required

---

## Self-Hosting Notes

- Libex uses PostgreSQL as both a persistent library and a cache — no Redis required
- Every book, author, series, narrator, and genre ever requested is stored in a full relational schema and survives cache expiry indefinitely
- The local library powers the `/db/book` and `/book/sku/{sku}` endpoints and serves as an automatic fallback when Audible is unavailable
- Cache TTL varies by what is cached, defaulting to `CACHE_TTL` seconds (default 24 hours) unless an endpoint sets its own; expired entries are purged automatically
- Logs directory: `./logs` (relative to your compose file) — Libex writes a rotating log file to `./logs/libex.log` on the host
- Log rotation is daily. `LOG_RETENTION_DAYS=7` keeps 7 days of backups. Set to `0` for infinite retention with no rotation
- **Database seeder:** Set `SEEDER_ENABLED=true` to activate the background seeder. It expands the local DB so the `/db/*` endpoints have more to return, and runs as two independent workers:
  - **Expansion** walks author, series, and narrator relationships to discover books you haven't requested yet. Each cycle compounds — a single book fetch can seed hundreds of related books over time. Runs every `SEEDER_INTERVAL_HOURS` (default 24).
  - **New releases** scans Audible's recent catalog by release date so fresh titles get picked up automatically. It runs on its own worker and its own interval (`SEEDER_NEW_RELEASES_INTERVAL_HOURS`, default 24), so you can have it run more often than the heavier expansion work without waiting behind it. It walks every category in Audible's taxonomy by release date, going as deep as the catalog allows per category.
  - **Upcoming refresh** (optional, `SEEDER_REFRESH_ENABLED`, default off) re-fetches pre-orders you already have as their release date nears, since details like the date, cover, narrator, and runtime firm up over time. It refreshes more often the closer a book gets — roughly yearly when far out, down to daily inside the last two weeks — and leaves already-released books alone. Runs as a second phase of the new-releases worker.

Both workers share the same enable flag, regions, and rate limit. They run independently and rate-limit themselves to one Audible request per `SEEDER_REQUEST_DELAY` seconds (default 1.0). Configure `SEEDER_REGIONS` to seed multiple markets (e.g. `us,uk,de`)

Set `WEB_CONCURRENCY=1` while the seeder is enabled. The seeder starts in every API worker process and nothing coordinates them, so the default six workers walk the same books six times over — sustained, unattended traffic from your IP for no extra coverage
- **VPN proxy:** Set `AUDIBLE_PROXY_URL` to route outbound Audible API requests through a proxy. Only Audible requests are affected — API serving, database connections, and logging are completely unaffected. This is especially useful when running the seeder to avoid IP-based rate limiting. Any HTTP, HTTPS, or SOCKS5 proxy works. The compose file creates a `libex-proxy` Docker network automatically — connect your VPN proxy container to it, then set `AUDIBLE_PROXY_URL` to point at the proxy. Leave `AUDIBLE_PROXY_URL` blank to disable

---

## Contributing

Contributions are welcome. See [CONTRIBUTING.md](CONTRIBUTING.md) for branch naming, commit conventions, and PR requirements.

---

## Disclaimer

Libex is a metadata tool that fetches publicly available information from Audible's API. It does not host, distribute, or provide access to copyrighted audio content. Users are responsible for ensuring their use complies with applicable laws and Audible's terms of service.

---

## Acknowledgements

**Audible** — All metadata is sourced from Audible's public API. Libex is an independent project and is not affiliated with, endorsed by, or sponsored by Audible or Amazon.

**[NarratorList.com](https://narratorlist.com)** — Narrator profile data including biographies, images, languages, and accent ratings is sourced from NarratorList.com. NarratorList is a community-built database where audiobook narrators curate their own profiles. Maintained by Amy Soakes.

**[AussieNarrator.com](https://aussienarrator.com)** — Additional narrator profile data for Australian and New Zealand narrators. A sister site to NarratorList.com, also maintained by Amy Soakes.

**[Axiom](https://axiom.co)** — Structured logging for the public instance. Axiom provides the observability layer that helps us monitor and improve Libex.

**[AudiMeta](https://github.com/Vito0912/AudiMeta)** — The original Audible metadata service that inspired Libex and demonstrated the community need for this tooling. Credit to Vito0912 for pioneering this space.

**[FastAPI](https://fastapi.tiangolo.com)** — The modern Python web framework powering Libex.

**[SQLAlchemy](https://www.sqlalchemy.org)** — Async database toolkit for Python powering Libex's full relational schema across books, authors, series, narrators, genres, and their relationships.

---

## License

MIT — see [LICENSE](LICENSE) for details.

Libex

Explore Similar Repositories

Was this content helpful?

Recent Feedback

Download README