Start free trial
Trending New Genres Authors
EnglishEnglish
EspañolSpanish
简体中文Chinese
繁體中文Chinese (Traditional)
FrançaisFrench
DeutschGerman
日本語Japanese
PortuguêsPortuguese
ItalianoItalian
한국어Korean
РусскийRussian
NederlandsDutch
العربيةArabic
PolskiPolish
हिन्दीHindi
Tiếng ViệtVietnamese
SvenskaSwedish
ΕλληνικάGreek
TürkçeTurkish
ไทยThai
ČeštinaCzech
RomânăRomanian
MagyarHungarian
УкраїнськаUkrainian
IndonesiaIndonesian
DanskDanish
SuomiFinnish
БългарскиBulgarian
עבריתHebrew
NorskNorwegian
HrvatskiCroatian
CatalàCatalan
SlovenčinaSlovak
LietuviųLithuanian
SlovenščinaSlovenian
СрпскиSerbian
EestiEstonian
LatviešuLatvian
فارسیPersian
മലയാളംMalayalam
தமிழ்Tamil
اردوUrdu
Searching...
SoBrief
API Design Patterns

API Design Patterns

Build APIs clients can trust, with patterns for safer changes, retries, and long-running work.
by J.J. Geewax 2020 480 pages
3.86
146 ratings
Listen
Immersive
V2.3
Amazon Kindle Audible
Try Full Access for 3 Days
Unlock listening & more!
Continue

Key Takeaways

Design APIs as durable contracts, not code you can casually refactor.

Changes reach users directly. A web API is unlike a local library: its builders control the service, while clients depend on its public interface. Renaming a field or changing a response can break software the API team cannot update. Geewax judges a good API by four qualities: it works, expresses users’ intentions, stays simple, and behaves predictably.

Patterns prevent costly surprises. Resource-oriented design applies a small set of familiar actions to named resources. In the book’s Twitter-like example, returning 500,000 messages at up to 140 characters each could mean a 70-megabyte response. Adding pagination only after users depend on the old all-at-once response can silently hide most messages from existing clients. Patterns are blueprints for avoiding such structural repairs.

Analysis

The contract framing connects API design to institutional governance: a decision made by one team constrains many independent teams for years. Repeated conventions lower the effort needed to learn an interface, much as a shared vocabulary helps people coordinate. Yet consistency is not an end in itself. A standard that forces an unusual task into an unnatural shape can move complexity into configuration or workarounds. Good pattern use therefore requires both discipline and a visible explanation of where a pattern does not fit.

Names teach the interface. Names should be expressive, concise, and consistent. If the same idea appears as both `topic` and `messagingTopic`, users cannot safely build on what they learned. Field names should also clarify units: `sizeBytes` is safer than `size`. The Mars Climate Orbiter failure illustrates why: one team’s pound-force-second values were interpreted as newton-seconds, and the spacecraft was lost.

Model only useful connections. A resource relationship should support a real behavior, not merely make the model look complete. Deep hierarchies increase the information needed to locate an item, while making every small concept a resource multiplies methods and identifiers. Inline data can simplify retrieval, but duplicated shared data creates difficult update and consistency questions.

Analysis

Naming is part of a system’s error control, not cosmetic polish. A precise unit or consistent field name can make an invalid assumption visible before it becomes a runtime failure. Resource diagrams also force teams to confront who owns data and which actions should cascade. The trade-off is that a more normalized model can require extra network calls, while an inline model can make responses larger and updates ambiguous. The right choice depends on actual access patterns, not on a universal preference for normalization or denormalization.

Choose stable identifiers and explicit data semantics before clients depend on them.

Identifiers outlive records. A good resource identifier is unique, permanent, hard to predict, easy to share, and straightforward to generate. Reusing an identifier after deletion can make an old reference point to an entirely different resource. The book recommends string identifiers, and describes Crockford’s Base32 as a readable format that avoids several easily confused characters. A checksum can help distinguish a mistyped identifier from a valid identifier that simply has no resource.

Types carry meaning. Decide what missing, null, empty, and zero mean, and document units and bounds. Numeric-looking identifiers are usually better as strings because arithmetic on them has no useful meaning. For values that exceed common numeric precision, string serialization can preserve the value for a suitable client-side library. Strings should use UTF-8, and identifiers should use Unicode normalization consistently.

Analysis

An identifier behaves like a long-lived pointer shared across organizational boundaries. Permanence protects references, while unpredictability can reduce the ease of guessing other resources. But opaque identifiers are not access control: authorization must still be checked for every request. Similarly, explicit types and units reduce ambiguity, but excessive detail can make an interface burdensome. The useful test is whether a client can interpret and validate a value without relying on hidden assumptions about the server’s programming language or storage system.

Keep standard methods boring; isolate consequential actions in custom methods.

Shared behavior builds trust. The standard methods are get, list, create, update, delete, and sometimes replace. Their value comes from predictable behavior across resource types. Update should modify specified fields; replace makes the resource match the supplied representation. Standard methods should avoid surprising side effects. For example, creating an email should store a draft, not silently send it.

Use a custom method for transitions. Sending an email changes state and contacts external systems, so a separate `SendEmail` action makes the consequence clear. Custom methods usually use POST and a colon to separate the resource path from the action. They are flexible, but users cannot infer as much about them, so teams should name and document them consistently. Long-running work can return an operation resource rather than keeping a request open indefinitely.

Analysis

The distinction resembles the separation between a database command and a business process. A simple update has narrow consequences; sending an email may involve remote dependencies, delays, and partial failure. Keeping these apart makes the interface easier to reason about and failure handling easier to design. The caution is that custom methods can become a refuge for poor resource modeling. If nearly every ordinary interaction needs a bespoke action, the underlying resource boundaries may deserve another look.

Choose relationship models by ownership, scale, and relationship metadata.

References are not guarantees. A cross-reference stores another resource’s identifier, commonly in a field ending in `Id`. It keeps records small and avoids updating every reference when a target changes. The cost is that a reference may point to a deleted resource, so clients should be prepared to check it. Copying full related resources inline can save a lookup, but risks stale data and growing responses.

Use hierarchy for ownership. Parent-child relationships make sense when access or deletion should flow from parent to child. Avoid deep hierarchies for mere association, especially when a child may move between parents. For many-to-many relationships, an association resource can store metadata such as a member’s role or join time. If the relationship is only a yes-or-no connection, add and remove methods can be simpler.

Analysis

Relationship design turns business assumptions into operational consequences. A hierarchy encodes more than a URL: it suggests ownership, access inheritance, and cascading deletion. Association records, by contrast, make the relationship itself visible and manageable. These choices also affect future change. A movable item placed in a permanent ownership hierarchy is likely to need a costly move operation. The useful challenge for designers is to ask not only what is connected, but what must remain true when either side changes or disappears.

Use opaque cursors and atomic batches to make collection work predictable.

Page by cursor, not by offset. Pagination divides large results into manageable requests. A client asks for at most `maxPageSize` results, sends back the opaque `nextPageToken`, and stops when that token is empty. A short page does not prove the list is finished. Keeping the token opaque lets the server change its storage strategy without exposing implementation details. Offset-based paging is fragile when new records arrive between requests.

Make bulk behavior explicit. Batch get, create, update, and delete operate on multiple resources in one request. The book favors atomic batches: all succeed or the request fails, rather than returning a difficult mixture of successes and failures. Results should preserve request order, especially when creation assigns identifiers. Filters belong on list methods so clients need not download every record just to find a subset.

Analysis

Pagination and batching solve different costs. Cursors limit response size and can conceal how the data is stored; batches reduce repeated network trips and can offer transaction-like guarantees. Atomicity simplifies client logic, though it may make a large batch fail because of one invalid item. Opaque cursors also do not promise a frozen view of changing data. When a stable snapshot matters, that guarantee must be designed explicitly rather than inferred from the presence of a token.

Separate long-running work, recurring jobs, and data transfer into distinct contracts.

An operation tracks work. A long-running operation is a persistent, promise-like resource returned when a request may take time. It has an identifier, a `done` flag, an eventual result or error, and optional progress metadata. Clients can poll, wait, or sometimes cancel it. A rerunnable job separates configuration from execution: users create a job once, then call `run` without resupplying its settings. This also lets different users configure and execute work.

Move data deliberately. Import and export methods can connect an API directly to external storage, with separate settings for storage access and data conversion. They are data movers, not backup and restore: without snapshots, an export may combine records from different moments. For anonymous analytics entries, a write method can ingest data without creating individually addressable resources, and the data may not be immediately visible.

Analysis

These patterns clarify three questions that are often collapsed: what work is pending, what task should be repeated, and where bytes should travel. Separating them gives operators better control over permissions, progress, and failure recovery. It also exposes the limits of each guarantee. An operation record does not make a task repeatable, and an export does not create a consistent backup. The interface should name those limits plainly, especially when a familiar label such as “export” might otherwise imply stronger preservation than the service provides.

Design a safe exit for mistakes: preview, recover, and deduplicate.

Preview before destruction. A validation-only request checks what can be checked without changing data. For dangerous criteria-based deletion, the default should be preview, not execution: require an explicit `force` flag and return both a count and sample of matching resources. Soft deletion moves a resource out of ordinary views while allowing recovery; a separate expunge action permanently removes it. Resource revisions preserve past states and can restore one by creating a new current revision.

Make retries safe. A client-generated request identifier lets the server recognize a repeated non-idempotent request and return its cached response. The server should compare a fingerprint of the request as well, so a reused identifier with different content becomes a conflict, not a misleading duplicate response.

Analysis

The strongest safety designs change the default so that a small omission does not cause a large loss. Previewing and reversible deletion are especially valuable when users cannot easily inspect every affected record beforehand. These protections are not substitutes for authorization, retention policy, or backups. Soft deletion can conflict with legal duties to erase data, and revision history can preserve sensitive mistakes. Safety features therefore need explicit limits, including who can recover records and when permanent removal is required.

Treat retries as protocol behavior, with backoff and server guidance.

Retry only when sensible. Some failures describe a request that will keep failing, such as forbidden access. Others may be transient, such as a service being unavailable. When retrying is safe, exponential back-off increases the wait after each failure, while a maximum delay and retry count prevent endless attempts. Random jitter prevents many clients from retrying in lockstep and overwhelming a recovering service.

Use the server’s clockless advice. When the API knows when a request is likely to succeed, it can send a `Retry-After` duration. A duration avoids relying on the client and server having synchronized clocks. For uncertain non-idempotent requests, request deduplication helps prevent duplicate work. Retrying every error indiscriminately can repeat actions or waste capacity, so clients need both eligibility rules and timing rules.

Analysis

Retry behavior is a coordination problem across clients, servers, and networks. Back-off reduces pressure during failure, while jitter prevents synchronized clients from turning recovery into another outage. Server guidance is more informative than a client’s blind estimate, but clients still need sensible limits and cancellation. A retry policy should also be understood alongside method semantics: a timeout does not prove that a write never happened. Deduplication helps resolve that uncertainty, but only while the server retains the relevant request record.

Set compatibility rules before choosing how API versions evolve.

Compatibility is a promise. A change is backward compatible when existing client code continues to work as expected, but “expected” depends on the API’s users. Adding a field may be harmless for one client and exceed the memory available to a constrained device. Even bug fixes or changed defaults can alter behavior that clients have come to rely on.

Choose a version strategy consciously. Perpetual stability keeps old versions available while adding incompatible changes in new versions. Agile instability offers a shorter stability window and removes old versions on a declared schedule. Semantic versioning marks incompatible changes with a major increment, compatible additions with a minor increment, and compatible fixes with a patch increment. Each approach trades maintenance burden against user choice and stability.

Analysis

Compatibility is a social agreement expressed through technical policy. The same change can be safe for a startup that updates frequently and disruptive for a bank or embedded device that expects long-term stability. A written policy makes those assumptions discussable before a crisis forces a decision. Version labels alone cannot do this work: they communicate only what the organization has decided their increments mean. The practical challenge is to balance durable guarantees with the cost of maintaining old behavior and delaying useful changes.

Sign requests when proof of origin, integrity, and nonrepudiation all matter.

Three claims must hold. Authentication should establish who sent a request, ensure its contents were not altered, and, when required, make it difficult for the sender to deny having sent it. Digital signatures use an asymmetric key pair: the client keeps the private key and registers the public key with the API. The private key signs; the public key verifies.

Sign the whole request. A signature should cover the HTTP method, host, path, date, and a digest of the body. Otherwise, an attacker could change the destination or action while leaving the signed body untouched. This is stronger than a shared secret when a third party must verify who authorized a request, but it adds computational and implementation cost. For less demanding cases, transport security and other authentication schemes may be sufficient.

Analysis

The important distinction is between authentication for access and evidence for later dispute. A shared secret can establish that one of two parties knew the secret, but it cannot independently prove which party created a message. Public-key signatures address that asymmetry, while request fingerprinting binds the proof to the request’s meaning. The design is consequently most valuable where auditability matters. It is not automatically the best everyday choice: key custody, revocation, replay protection, and implementation quality remain essential parts of a secure system.

Analysis

The book’s central insight is that API design is less about choosing clever endpoints than about allocating uncertainty. Every interface choice decides who must remember what, who bears the cost of failure, and which assumptions can safely be made by distant clients. Standard methods reduce interpretive uncertainty by giving users repeated behaviors. Resource models expose durable concepts. Field masks, cursors, and explicit operation resources then handle complexity without making every interaction bespoke.

That consistency is a form of leverage, but also a constraint. Reusing a pattern lowers the cognitive burden for clients and the decision burden for API teams. Yet the pattern can conceal costs if a team mistakes uniformity for correctness. An atomic batch may be easier to understand but harder to complete. A hierarchy can simplify authorization while making relocation costly. An immutable version can protect clients while burdening the provider with old behavior. The book is strongest when it makes these costs visible rather than presenting a convention as magic.

A useful way to read its catalog is as a sequence of boundary decisions. Decide what is a resource and what is merely data. Decide whether an operation is a simple state change or an external process. Decide whether a failure is safe to repeat, whether a deletion is recoverable, and whether a response describes a snapshot or a changing system. These distinctions determine whether an API can be operated safely by clients that do not share the designer’s context.

The result is an architectural ethic: do not make consumers infer semantics from implementation details. Name units, keep cursors opaque, distinguish preview from execution, and state compatibility promises before clients rely on them. The patterns cannot remove the judgment required to build an API. They make that judgment legible, reusable, and less likely to be rediscovered through production failures.

Summary in 30 Seconds
Public APIs become dependencies that teams cannot update at will, so stable names, identifiers, and data meanings matter. Familiar operations make behavior easier to predict, while custom actions clarify consequential changes. Opaque cursors, atomic batches, and persistent operation records make large or slow tasks manageable. Preview destructive requests, preserve recovery options, and deduplicate retries. Compatibility policies should be explicit, and signed requests can verify origin and integrity.
Contains spoilers

Last updated:

Report Issue

Review Summary

3.86 out of 5
Average of 146 ratings from Goodreads and Amazon.

API Design Patterns receives mixed reviews, with an overall rating of 3.89 out of 5. Readers appreciate its comprehensive coverage of API design topics, practical insights, and structured approach. The book is praised for discussing complex patterns and providing valuable guidance for backend engineers and API designers. However, some criticize its verbosity, repetitiveness, and occasional lack of context. Despite these drawbacks, many readers consider it a must-read for those involved in API development, offering a good balance of theory and practical examples.

Your rating:
4.36
214 ratings
Want to read the full book?

Glossary

Resource-oriented APIs

Standard actions on resources

An API style organized around named things the service manages, called resources, rather than a long list of unrelated actions. A small, consistent set of methods, such as get, list, create, update, and delete, applies to those resources. The approach aims to make an API easier to learn and more predictable.

Field mask

Selected resource fields

A list of field paths specifying which parts of a resource should be retrieved or updated. On retrieval, it can reduce the response to the fields a client needs. On update, it limits changes to the stated fields, avoiding accidental overwrites of values the client does not know about.

Long-running operation

Persistent asynchronous work record

A resource representing work that may take too long to complete during a single request. It has an identifier, a completion status, an eventual result or error, and optional metadata such as progress. Clients can retrieve its status, wait for completion, and, when supported, cancel or pause the work.

Rerunnable job

Stored task configuration

A resource that stores the configuration for a task independently from executing that task. A client creates or updates the job, then invokes a run method without resending its settings. This separation supports recurring execution and allows different users to have permission to configure a task and to run it.

Singleton sub-resource

Isolated single child resource

A single child resource used to separate part of a parent resource’s data when it has different size, security, volatility, or access needs. It exists because its parent exists, and deleting the parent removes it. It can be retrieved and updated independently, but is not separately created or deleted.

Association resource

Addressable relationship record

A resource representing a many-to-many connection between two other resources. It makes the relationship independently addressable and can store metadata about it, such as a membership role or join time. The added flexibility comes with extra methods and more API concepts for clients to learn.

Pagination

Chunked collection retrieval

A method for returning large collections in manageable portions rather than one enormous response. A request supplies a maximum page size and an opaque page token; the response supplies a token for continuing. Pagination ends when the next-page token is empty, not necessarily when a page contains fewer results than requested.

Request deduplication

Safe repeated request handling

A mechanism for recognizing that a client has retried a request after a lost response. The client supplies a request identifier, and the service can return the original cached response instead of repeating the action. A fingerprint of the request helps detect accidental reuse of the same identifier for different content.

Soft deletion

Recoverable resource removal

A deletion behavior that marks a resource as deleted and removes it from ordinary listings without immediately erasing its stored data. A separate undelete method can restore it, while an expunge method permanently removes it. Expiration policies can later clear deleted resources automatically.

Resource revision

Timestamped resource snapshot

A saved representation of a resource at a particular point in its history. Revisions can be listed and retrieved, and a previous state can be restored by creating a new revision based on it. Revision history supports diagnosis and recovery, but increases storage needs and can retain sensitive data.

Exponential back-off

Increasing retry delays

A retry strategy that increases the waiting time after each failed attempt, commonly doubling the delay until a maximum is reached. A retry limit prevents endless attempts, while random jitter helps keep many clients from retrying in synchronized waves. A server can give more specific timing through a Retry-After header.

Crockford's Base32

Readable identifier encoding

An encoding format used to represent identifier data with a restricted alphabet designed to reduce confusion when values are copied or spoken. It omits characters that are easily mistaken for others, accepts some common input variations, and can include a checksum character to help detect typographical errors.

FAQ

What is API Design Patterns by J.J. Geewax about?

  • Comprehensive API design guide: The book presents a structured collection of design patterns and principles for building web APIs, with a focus on resource-oriented APIs.
  • Practical and accessible: It uses TypeScript-style API definitions and real-world examples, such as a Twitter-like API, to illustrate concepts for developers familiar with HTTP and serialization.
  • Organized for learning: The content is divided into six parts, covering API basics, design patterns, resource relationships, collective operations, and safety/security concerns.

Why should I read API Design Patterns by J.J. Geewax?

  • Improve API usability: The book helps designers create APIs that are operational, expressive, simple, and predictable, leading to better user experiences and higher adoption.
  • Avoid common pitfalls: It distills years of best practices, helping readers sidestep mistakes like inconsistent naming, poor resource layout, and problematic versioning.
  • Consistency and scalability: Following the patterns ensures APIs are easier to maintain, evolve, and integrate, benefiting both providers and consumers.

What are the key takeaways from API Design Patterns by J.J. Geewax?

  • Patterns and anti-patterns: The book highlights both effective design patterns and common anti-patterns, such as offset-based pagination and in-line data, to guide better API decisions.
  • Advanced concepts covered: It addresses complex topics like request deduplication, resource revisions, authentication, and versioning, equipping readers for real-world challenges.
  • Balance of theory and practice: The book combines foundational principles with practical advice, code examples, and exercises to reinforce learning.

What makes a "good" API according to API Design Patterns by J.J. Geewax?

  • Operational and reliable: APIs should reliably do what users expect, meeting non-functional requirements like latency and accuracy.
  • Expressive and simple: Users must be able to clearly express their intent without awkward workarounds, and the API should be as simple as possible.
  • Predictable and consistent: Consistent naming, behavior, and patterns reduce surprises, making APIs easier to learn and use effectively.

How does API Design Patterns by J.J. Geewax define and use API design patterns?

  • Reusable blueprints: API design patterns are reusable solutions to common interface design problems, focusing on structure rather than implementation.
  • Addressing API rigidity: Since APIs are hard to change once public, patterns help get the design right from the start.
  • Promoting uniformity: Patterns encourage consistency across APIs, reducing fragmentation and making APIs easier to learn within organizations.

What naming conventions and advice does API Design Patterns by J.J. Geewax provide for APIs?

  • Names are critical: API names are public and long-lived, so choosing expressive, simple, and predictable names is essential to avoid confusion and costly changes.
  • Avoid "API smells": Prepositions in names often signal deeper design issues, and units should be included in names for clarity (e.g., sizeBytes vs. sizeMegapixels).
  • Consistency across the API: Good naming practices ensure uniformity and make APIs easier to use and maintain.

How does API Design Patterns by J.J. Geewax recommend structuring resources and their relationships?

  • Thoughtful resource layout: Carefully choose resources and define only necessary relationships (references, hierarchies, many-to-many, self-references) to avoid complexity.
  • Avoid anti-patterns: Don’t create resources for everything, avoid deep hierarchies, and refrain from in-lining all data to prevent confusion and inefficiency.
  • Modeling relationships: Use association resources for many-to-many relationships and string ID fields for references, ensuring flexibility and data integrity.

What are the standard API methods and their characteristics in API Design Patterns by J.J. Geewax?

  • Standard methods defined: The book emphasizes Get, List, Create, Update (PATCH), Delete, and Replace (PUT) as the core methods.
  • Consistency is key: Each method should behave predictably and consistently across all resources to maximize learnability.
  • Idempotency and side effects: Most methods are idempotent except Delete, which should fail if the resource doesn’t exist; side effects should be minimized for predictability.

How does API Design Patterns by J.J. Geewax handle partial updates and retrievals using field masks?

  • Granular field selection: Field masks let clients specify which fields to retrieve or update, reducing unnecessary data transfer and supporting fine-grained updates.
  • Transport and syntax: Field masks are sent as repeated query parameters and can address nested fields, but not array items by index.
  • Defaults and limitations: By default, all fields are returned unless specified, and updates infer the mask from provided data.

When and how should custom methods be used in APIs according to API Design Patterns by J.J. Geewax?

  • For nonstandard actions: Custom methods handle operations with side effects (e.g., sending emails, launching rockets) that don’t fit standard CRUD methods.
  • Separation of concerns: They keep complex operations distinct from simple data manipulation, maintaining the purity of standard methods.
  • Consistent implementation: Custom methods use POST and a colon in the URL (e.g., /resource:action) and should be applied consistently across the API.

How does API Design Patterns by J.J. Geewax address advanced topics like pagination, filtering, and versioning?

  • Cursor-based pagination: The book recommends using page tokens as cursors instead of numeric offsets to avoid duplicate or missing results.
  • Flexible filtering: Advocates for unstructured string filters (like SQL WHERE clauses) for usability and future flexibility, evaluating one resource at a time.
  • Versioning strategies: Discusses perpetual stability, agile instability, and semantic versioning, each with trade-offs in stability and user satisfaction.

What security and reliability patterns does API Design Patterns by J.J. Geewax recommend (e.g., request deduplication, validation, authentication)?

  • Request deduplication: Use client-generated request IDs to identify and deduplicate non-idempotent requests, caching responses for a limited time.
  • Validation with validateOnly: The validateOnly flag allows clients to preview request outcomes without executing them, ensuring safety and correctness.
  • Authentication via digital signatures: Users register public keys with the API server and sign requests with private keys, ensuring integrity, authenticity, and nonrepudiation.

About the Author

JJ Geewax is the author of API Design Patterns. While limited information is provided about the author in the given content, it can be inferred that Geewax has extensive experience in API design and development. The book's comprehensive coverage of complex API-related topics suggests that the author possesses deep knowledge in the field. Geewax's writing style is described as opinionated and structured, indicating a confident and experienced voice in the subject matter. The author's approach to explaining API design patterns has been generally well-received by readers, particularly for its practical insights and thorough examination of various aspects of API development.

Download PDF

To save this API Design Patterns summary for later, download the free PDF. You can print it out, or read offline at your convenience.
Download PDF
File size: 0.43 MB     Pages: 22

Download EPUB

To read this API Design Patterns summary on your e-reader device or app, download the free EPUB. The .epub digital book format is ideal for reading ebooks on phones, tablets, and e-readers.
Download EPUB
File size: 1.39 MB     Pages: 28
Want to read the full book?
Follow
Listen
Home
Swipe
Library
Get App
Try Full Access for 3 Days
Listen, bookmark, and more
Compare Features Free Pro
📖 Read Summaries
Read unlimited summaries. Free users get 3 per month
🎧 Listen to Summaries
Listen to unlimited summaries in 40 languages
—
❤️ Unlimited Bookmarks
Free users are limited to 4
—
📜 Unlimited History
Free users are limited to 4
—
📥 Unlimited Downloads
Free users are limited to 1
—
Risk-Free Timeline
Today: Get Instant Access
Listen to full summaries of 26,000+ books. That's 12,000+ hours of audio!
Day 2: Trial Reminder
We'll send you a notification that your trial is ending soon.
Day 3: Your subscription begins
You'll be charged on Nov 24,
cancel anytime before.
Consume 2.8× More Books
2.8× more books Listening Reading
Our users love us
600,000+ readers
Trustpilot Rating
TrustPilot
4.6 Excellent
This site is a total game-changer. I've been flying through book summaries like never before. Highly, highly recommend.
— Dave G
Worth my money and time, and really well made. I've never seen this quality of summaries on other websites. Very helpful!
— Em
Highly recommended!! Fantastic service. Perfect for those that want a little more than a teaser but not all the intricate details of a full audio book.
— Greg M
Save 62%
Yearly
$119.88 $44.99/year/yr
$3.75/mo
Monthly
$9.99/mo
Start a 3-Day Free Trial
3 days free, then $44.99/year. Cancel anytime.
Unlock a world of fiction & nonfiction books
26,000+ books for the price of 2 books
Read any book in 10 minutes
Discover new books like Tinder
Request any book if it's not summarized
Read more books than anyone you know
#1 app for book lovers
Lifelike & immersive summaries
30-day money-back guarantee
Download summaries in EPUBs or PDFs
Cancel anytime in a few clicks

Why one summary?

Scanner
Find a barcode to scan

⭐
⭐
⭐
We have a special gift for you
Open
38% off
DISCOUNT FOR YOU
⭐
⭐
⭐
$79.99
$49.99/year
Only $4.16 per month
Continue
2 taps to start, super easy to cancel
Settings
General
Widget
Loading...