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
Graph Databases

Graph Databases

New Opportunities for Connected Data
When relationships drive the query, a graph can turn deep database lookups into direct paths.
by Ian Robinson 2013 238 pages
3.64
437 ratings
Listen
Immersive
V2.3
Amazon Kindle Audible
Try Full Access for 3 Days
Unlock listening & more!
Continue

Key Takeaways

Choose a graph when relationships, not records, contain the answer

The connections carry meaning. A graph represents entities as nodes and meaningful links as named, directed relationships. In the labeled property graph model, nodes and relationships can hold properties, while nodes can have labels such as User, Order, or Product. The model can represent everything from social ties to the dependencies among servers and applications.

Choose it selectively. The key question is whether understanding your data requires following connections across multiple entities. A simple inventory may fit a table or document more naturally. A domain whose value lies in paths, dependencies, or indirect associations is a stronger graph candidate.

Analysis

A useful test is to describe the hardest question the system must answer. If the answer requires repeatedly reconstructing how separate records connect, the graph model may bring the underlying structure into view. If the question is mostly about filtering or aggregating isolated records, a graph can add conceptual overhead without much benefit. The book’s strongest argument is therefore not that all data is secretly a graph, but that the data model should make the domain’s important relationships explicit.

Store connections directly instead of reconstructing them through joins

Traversal avoids repeated joins. Relational databases represent many connections through foreign keys and join tables. As a query follows more links, it must perform more joins; aggregate stores often require application code to look up referenced records. A graph database stores relationships as part of the data, so a query can follow them directly.

The gap can grow quickly. In a cited comparison using a social network of one million people, each with about 50 friends, a friends-of-friends-of-friends query took roughly 30 seconds in the relational database and 0.168 seconds in Neo4j. At depth four, the times were about 1,544 seconds and 1.359 seconds. At depth five, the relational query did not finish, while Neo4j returned results in about 2.132 seconds. This is one experiment, not a universal benchmark.

Analysis

The example illustrates a structural advantage, not a guarantee that every graph query beats every relational query. The cost of a traversal depends on how many connections it must actually visit, and a highly connected starting point can still lead to enormous work. Comparisons also depend on database versions, hardware, indexes, and query design. The more durable lesson is to identify whether joins are incidental overhead or the central operation the application performs.

Turn hidden nouns into nodes before they disappear

Verbs can hide entities. An early email model represented communication with relationships such as Bob EMAILED Charlie and Bob BCC’d Edward. It recorded that contact occurred, but could not reliably show which people were copied on the same individual message. The email itself, the crucial entity for an investigation, had vanished into the verb.

Give events their own structure. The improved model creates an Email node, connects the sender with SENT, and connects recipients with TO, CC, and BCC. A reply is another email, linked to the message it answers. The same reasoning applies to employment, performances, and reviews: when an event connects several entities or has its own attributes, representing it as a node preserves details that a single relationship cannot carry.

Analysis

This modeling choice is a safeguard against information loss. If an event matters as evidence, has multiple participants, or can be discussed in its own right, making it explicit gives the system somewhere to attach context and provenance. The trade-off is a larger graph and more relationships to maintain. That added structure is worthwhile when it supports questions the simpler model cannot answer, rather than being added merely because the graph permits it.

Make the model answer a real user question

Start with a use case. A book-review application might need to find books liked by readers who also liked a particular title. That request immediately suggests nodes for readers and books, plus LIKES relationships. It also gives the team a concrete query to test against the model.

Describe patterns directly. Cypher, Neo4j’s declarative graph query language, lets developers express a desired pattern in text using symbols for nodes and relationships. A query can anchor on a known reader and book, then follow LIKES links to discover other readers and their preferred books. The model should also read sensibly when its labels and relationships are followed as a sentence. If it reads poorly or cannot express the intended query, revisit the design.

Analysis

The method makes data modeling and query design mutually corrective. A conceptual diagram is not automatically useful just because it resembles the domain; its value depends on whether it supports the questions that motivate the application. A working query exposes missing entities and ambiguous relationships early, when they are cheaper to address. The caution is that a model built only around today’s known queries can become narrow, so the domain vocabulary and likely changes deserve attention too.

Evolve the graph in small additions, then test its promises

Add structure incrementally. Graphs can usually accommodate new nodes, labels, relationships, and subgraphs without redesigning the entire model. A retail application might begin with a DELIVERY ADDRESS relationship, add BILLING ADDRESS for a new feature, then add a general ADDRESS relationship when customers need to see every address. The original relationships can remain useful for their specific tasks.

Schema-free is not rule-free. Tests can document expected domain behavior and catch regressions as the application changes. The book recommends small, representative test graphs, often around ten nodes, with separate tests for ordinary and exceptional cases. Changes to existing relationship types or properties deserve particular scrutiny, since queries may rely on their meaning.

Analysis

Incremental change lowers the cost of learning: teams can encode newly discovered requirements without waiting for a sweeping schema redesign. But flexibility transfers some responsibility from database-enforced structure to application code and tests. A graph that accepts new shapes can also accumulate inconsistent ones. Tests are most useful when they assert domain rules, not just that a query returns something, and when their examples reflect the awkward cases real data tends to reveal.

Use graphs for cross-domain recommendations and permissions

Indirect links create useful results. Talent.net recommends professional contacts by comparing shared interests and work history. People with more common interests receive stronger recommendation scores; people who collaborated on the same projects can also be found through those project nodes. When repeated traversal proved inefficient for a frequently used query, the system added WORKED WITH relationships as shortcuts.

Permission is also a path. TeleGraph modeled administrators, groups, companies, employees, and accounts as a connected structure. Permissions could flow down company hierarchies, while DENIED links could block access inherited from above. The same graph supported both finding everything an administrator could manage and checking whether one specific account was permitted.

Analysis

These examples show that a graph is valuable when decisions depend on context gathered across several kinds of relationship. A recommendation may combine interests, employers, and collaboration; an access check may combine group membership, organizational hierarchy, and exceptions. Explicit shortcuts can improve a high-traffic query while leaving the richer model intact. Those shortcuts do create maintenance obligations, so the system must keep derived connections consistent with the facts from which they were created.

Expect fast local traversals, not magic global scalability

Native adjacency removes indirection. In a system with index-free adjacency, a node has direct references to its neighboring nodes through stored relationships. Moving from one connected node to another avoids repeatedly searching a global index. The book describes traversal cost as proportional to the number of relationships followed, rather than the size of the whole graph.

The advantage has boundaries. Some graph databases store graph-shaped data without native graph processing, so traversals may still rely on indexes. Even native systems depend on memory and storage performance, and a query touching a huge part of the network can take substantial time. Distributing one connected graph across machines is difficult because a traversal that crosses machines pays network costs.

Analysis

The important distinction is between a large database and a large query. A graph can grow while a query remains quick if it touches only a small neighborhood, but that does not make broad scans or global calculations free. The book also separates native graph storage from native graph processing, a useful reminder that a product’s data model does not reveal its physical design. Architecture claims should be checked against the actual workload and deployment.

Test latency on realistic graphs before production surprises you

Correctness is not speed. A query that works on a tiny test graph may slow down when real relationship counts, data volume, or cache misses appear. The book recommends performance tests against representative data, running queries repeatedly and recording results as code, hardware, or database versions change. End-to-end application tests should reflect expected usage and report percentiles, not just averages. One example target is keeping 98% of requests below 200 milliseconds.

Plan the operating model. Neo4j is presented as supporting ACID transactions, recovery, and replicated clusters. In the described master-slave design, writes go through the master and replicas can lag, so a read immediately after a write needs deliberate handling. Memory, disks, redundancy, and workload shape all affect production performance.

Analysis

Performance testing is most informative when it resembles the conditions that cause failure: realistic graph density, cold as well as warm caches, and the application’s actual traffic pattern. Percentiles matter because an acceptable average can conceal a painful tail for users. Operational guarantees also need precise interpretation. Replication can improve availability and read capacity, but it does not erase consistency trade-offs or eliminate the need to design for failures.

Read social networks through closed triangles and weak bridges

Triangles suggest future ties. The strong triadic closure property says that if someone has strong relationships with two people, those two are more likely to form a connection themselves. In a workplace, two colleagues who both work closely with the same manager may be likely to become collaborators or peers.

The kind of tie matters. Structural balance describes whether the positive and negative relationships in a three-person pattern fit together without creating persistent tension. A local bridge is a connection that serves as the only path between otherwise separate groups. Such links can carry unfamiliar information; the book uses this to explain why a loose acquaintance may provide a more useful job lead than a close friend. These are predictive clues, not certainties.

Analysis

The value of these ideas lies in turning network shape into hypotheses about behavior. A triangle can signal opportunities for collaboration, while a bridge can identify a person or channel connecting otherwise separate communities. The interpretation depends on how relationships are defined: a manager link, a friendship, and a message exchange are not interchangeable evidence. These patterns can guide investigation, but treating them as proof risks confusing an analytical model with the complicated motives of actual people.

Use Dijkstra for certainty, A when a good heuristic exists

Shortest paths need a cost model. Dijkstra’s algorithm finds the least-cost route by repeatedly extending the cheapest known path to a nearby unsolved node. In the book’s Australia road example, it finds a 50-hour route from Sydney to Perth, while exploring some detours along the way.

A* adds a destination estimate. It balances the cost already traveled with a heuristic estimate of the remaining journey, steering exploration toward the destination while retaining an optimal result under the algorithm’s conditions. Global Post used graph paths for time-sensitive parcel routing: relationships counted only when their date ranges covered the delivery period, and the route between delivery bases was selected by weighted cost. This shows how path algorithms turn a domain model into an operational decision.

Analysis

The algorithm is only as useful as the graph’s weights and constraints. A route can be mathematically cheapest while being unsuitable if its cost omits a relevant business rule, such as whether a connection is active during the required period. A* can reduce unnecessary exploration when its heuristic is informative, while Dijkstra offers a dependable baseline for weighted paths. The modeling work and the algorithm therefore belong together: the graph defines what counts as a route, and the cost defines what counts as best.

Analysis

The book’s central contribution is as much a modeling argument as a database argument. It asks developers to stop treating connections as incidental metadata and instead represent them as data that can be queried directly. That shift can reduce the distance between a domain expert’s account of a problem, the diagram on a whiteboard, and the structure that software actually stores. The email example makes the point especially well: the first model is easy to read but loses the message as an entity, and therefore cannot answer important investigative questions.

Its performance case is strongest for graph-local workloads, where a query starts at known nodes and follows a limited part of the graph. The book’s benchmark dramatizes the cost of deep relational joins, but the numbers should be read as a case study rather than a timeless law. Query plans, hardware, data shape, and database versions matter. A graph database also does not remove the need for careful modeling; it makes relationships explicit while shifting some governance into tests and application logic.

The most useful modern interpretation is workload-first polyglot architecture. A transactional graph database is well suited to applications that repeatedly navigate connected records. Global ranking, broad statistical analysis, and other whole-network computations may need different tools or a separate processing layer. Likewise, native adjacency improves traversal within an instance but does not make distributing arbitrary connected graphs across machines simple. The book acknowledges this hard boundary, even while arguing enthusiastically for graph adoption.

Finally, the predictive examples deserve a distinction between inference and evidence. Triangles and bridges can help surface plausible social patterns, but the meaning of a tie depends on how it was captured and what the analysis assumes. A graph makes those assumptions inspectable; it does not make them automatically true. Used with that discipline, the book offers a durable principle: choose a data model that makes the important questions natural to ask, then test the model against the decisions the system must support.

Summary in 30 Seconds
Graph databases make connections explicit, so queries can follow relationships instead of rebuilding them through repeated joins. In one cited test on a million-person social network, a three-step query took about 30 seconds relationally and 0.168 seconds in Neo4j, though results depend on workload and setup. Model events as nodes when they carry their own details. Test designs and latency on realistic data. Graphs suit local traversals, but large-scale distribution remains difficult.
Contains spoilers

Last updated:

Report Issue

Review Summary

3.64 out of 5
Average of 437 ratings from Goodreads and Amazon.

Graph Databases receives mixed reviews, with an average rating of 3.63/5. Readers appreciate its introduction to graph database concepts and Neo4j, but criticize its focus on Neo4j rather than graph databases in general. The book is praised for clear explanations and real-world examples, but some find it overly enthusiastic and lacking in technical depth. Many reviewers note its value as a starter guide for those new to graph databases, while more experienced readers may find it too basic. The writing style and structure receive both positive and negative comments.

Your rating:
4.23
119 ratings
Want to read the full book?

Glossary

Labeled property graph model

Nodes and typed connections

A graph model composed of nodes, relationships, labels, and properties. Nodes represent entities and may have one or more labels describing their roles. Named, directed relationships connect a start node to an end node and may also have properties. The model represents both the entities in a domain and the meaningful connections among them.

Index-free adjacency

Direct links between neighbors

A graph-processing design in which nodes maintain direct references to their adjacent nodes through relationships. Traversals follow these links rather than repeatedly using a global index to locate the next record. This can make traversal cost depend on the portion of the graph visited, though the benefit varies with the implementation and workload.

Cypher

Neo4j graph query language

A declarative query language for describing graph patterns and actions in Neo4j. Its syntax represents nodes with parentheses and relationships with arrows, making queries resemble small graph diagrams. Clauses such as MATCH, WHERE, and RETURN locate patterns, filter results, and specify what to return.

Graph-local query

Query over a nearby subgraph

A query that begins at one or more known points in a graph and traverses the surrounding relationships to find relevant data. Its work is focused on the portion of the graph encountered, rather than requiring a scan of the entire dataset. The book presents this as a workload well suited to graph databases.

Strong triadic closure property

Strong ties predict a third tie

A proposed social-network pattern: when one person has strong relationships with two other people, those two are more likely to have at least a weaker relationship with each other. It can help identify possible future connections or unusual structures, but it is a predictive tendency, not a rule that holds in every network.

Structural balance

Consistency among three-way ties

A way to interpret a three-person network pattern by considering whether its positive and negative relationships fit together. In the book’s workplace example, colleague relationships are treated as positive and management relationships as negative. Balanced patterns can suggest stable social arrangements, while unbalanced ones may point to tension or pressure for change.

Local bridge

Sole link between groups

A relationship that provides the only connection between two otherwise separate parts of a network. Local bridges can connect people with different information or perspectives, making them relevant to communication analysis and recommendations. Their significance depends on the real meaning and activity of the relationship represented.

Dijkstra's algorithm

Least-cost path search

An algorithm for finding a shortest path between nodes when relationships have costs. It expands the cheapest known paths and marks a node solved once its lowest-cost route from the starting point is established. It can explore areas that do not contribute to the final route, but provides a general method for weighted path finding.

A* algorithm

Heuristic-guided path search

A shortest-path algorithm that combines the cost already incurred with an estimate of the remaining cost to the destination. The estimate guides the search toward promising routes, potentially avoiding unnecessary exploration. The book presents it as combining the cost-based logic of Dijkstra’s algorithm with destination-directed guidance.

FAQ

What’s Graph Databases by Ian Robinson about?

  • Core introduction: Graph Databases by Ian Robinson introduces the fundamentals of graph databases, focusing on the labeled property graph model and how it represents and queries connected data.
  • Scope and approach: The book covers graph theory basics, graph database technologies, data modeling, application development, and real-world use cases, using Neo4j and Cypher as primary examples.
  • Industry impact: It highlights how graph databases transform industries like social networking, IoT, retail, and telecommunications by enabling better performance and flexibility.
  • Audience: The book is aimed at developers, database professionals, and decision-makers seeking practical understanding and implementation guidance.

Why should I read Graph Databases by Ian Robinson?

  • Understanding connected data: The book explains why traditional databases struggle with connected data and how graph databases excel at modeling and querying complex relationships.
  • Practical guidance: Readers receive hands-on advice for graph data modeling, querying with Cypher, application architecture, and testing strategies, making it suitable for real-world projects.
  • Future-proofing skills: As graph databases become mainstream, the book prepares readers to participate in this shift and innovate with graph technology.
  • Industry relevance: Real-world examples and case studies demonstrate the business value and agility that graph databases bring to enterprises.

What are the key takeaways from Graph Databases by Ian Robinson?

  • Graph model advantages: Graph databases offer performance, flexibility, and agility for connected data, outperforming relational and other NoSQL databases in these areas.
  • Native graph processing: Concepts like index-free adjacency and native storage enable constant-time traversals and efficient querying.
  • Iterative modeling: The book emphasizes iterative, test-driven development and evolving data models to match changing business needs.
  • Real-world impact: Case studies show how graph databases power social recommendations, access control, logistics, and more, delivering business responsiveness and innovation.

What is the labeled property graph model in Graph Databases by Ian Robinson?

  • Definition: The labeled property graph model consists of nodes (entities) and relationships (connections), both of which can have properties (key-value pairs) and labels.
  • Expressiveness: Relationships are directed and named, allowing for rich semantic modeling and supporting complex, variably structured data.
  • Schema flexibility: The model is schema-free and additive, enabling easy evolution of the data model without disrupting existing applications.
  • Foundation for querying: This model underpins the book’s examples and is central to the power and flexibility of graph databases.

How does Graph Databases by Ian Robinson compare graph databases to relational and NoSQL databases?

  • Relational limitations: Relational databases require expensive joins for connected data, leading to poor performance and rigid schemas.
  • NoSQL differences: Other NoSQL stores (key-value, document, column family) lack first-class relationships, making connected data management complex and inefficient.
  • Graph database strengths: Graph databases treat relationships as first-class citizens, enabling fast traversals and efficient querying of highly connected data.
  • Consistency and transactions: Graph databases like Neo4j maintain ACID transactions, providing strong consistency, unlike many NoSQL stores that relax consistency for scalability.

What are the main benefits of using graph databases according to Graph Databases by Ian Robinson?

  • Performance: Graph databases deliver millisecond query responses for connected data, with execution time based on the traversed subgraph rather than the entire dataset.
  • Flexibility: The schema-free, additive nature allows for easy evolution of the data model, reducing migration and maintenance overhead.
  • Agility: Graph databases support agile and test-driven development, enabling rapid iteration and alignment with business needs.
  • Business impact: Organizations benefit from accelerated development cycles, extreme responsiveness, and the ability to model complex domains naturally.

How does Graph Databases by Ian Robinson explain graph data modeling best practices?

  • Modeling approach: Entities are modeled as nodes, and their connections as relationships, closely reflecting real-world semantics.
  • Iterative development: The book advocates for iterative, incremental modeling, testing with representative data, and evolving the model as requirements change.
  • Avoiding anti-patterns: It warns against encoding entities as relationships and stresses explicit modeling for clarity and queryability.
  • Handling complexity: Techniques for representing complex values and time (e.g., versioned graphs, timeline trees) are discussed to support evolving schemas.

How does Graph Databases by Ian Robinson teach querying with Cypher?

  • Cypher introduction: Cypher is presented as an expressive, declarative query language that uses ASCII-art patterns to match graph structures.
  • Core clauses: The book covers essential Cypher clauses like MATCH, WHERE, RETURN, CREATE, and MERGE, with practical examples.
  • Idiomatic queries: Readers are encouraged to write idiomatic queries that start from known nodes and traverse local neighborhoods for performance.
  • Optimization tips: The book advises on restricting variable-length paths and precomputing relationships for performance-critical queries.

What application architectures and development practices are recommended in Graph Databases by Ian Robinson?

  • Deployment modes: Neo4j can run embedded within applications (JVM-only, low latency) or as a standalone server (platform-independent, REST API).
  • Server extensions: For complex logic, server extensions allow custom Java code to run inside Neo4j, enabling domain-specific RESTful services.
  • Test-driven development: The book emphasizes test-driven modeling and query development, using small graphs and unit tests for continuous validation.
  • Performance testing: Strategies for application and server extension performance testing are discussed to ensure regression safety and scalability.

How does Graph Databases by Ian Robinson address production planning, performance, and scaling?

  • Capacity planning: The book discusses balancing cost, performance, redundancy, and load, with advice on JVM heap sizing, page cache allocation, and disk speed.
  • Clustering: Neo4j supports master-slave clustering for high availability and horizontal read scaling, with recommendations for directing writes and balancing reads.
  • Cache strategies: Techniques like cache sharding and consistent routing are suggested to improve cache locality and performance.
  • Consistency management: Strategies for ensuring read-your-own-write consistency in eventually consistent clusters are explained.

What real-world use cases and case studies are highlighted in Graph Databases by Ian Robinson?

  • Social recommendations: Talent.net uses graph queries to infer social relations and recommend experts based on shared interests and work history.
  • Authorization and access control: TeleGraph Communications manages complex access control for millions of users and resources using fine-grained permission models in a graph.
  • Geospatial logistics: Global Post models parcel delivery networks as graphs with timestamped relationships, supporting route calculation and schema evolution.
  • Business impact: These case studies illustrate how graph databases enable real-time analytics, agility, and business innovation.

What are the best quotes from Graph Databases by Ian Robinson and what do they mean?

  • On graph power: “Graphs are truly remarkable structures... we’re only just beginning to understand how to apply them to our personal, social, and business lives.” This highlights the untapped potential of graph technology.
  • On native processing: “A database engine that utilizes index-free adjacency... acts as a micro-index of other nearby nodes, which is much cheaper than using global indexes.” This explains the performance advantage of native graph databases.
  • On triadic closure: “The empirical evidence... suggests that the tendency toward triadic closure is real and substantial.” This underscores the importance of social graph theory in understanding network evolution.
  • On idiomatic queries: “Idiomatic queries have beneficial side effects... tend to exploit caches better and run faster than nonidiomatic queries.” This emphasizes the value of writing queries that align with graph database architecture for optimal performance.

About the Author

Ian Robinson is an author and technologist known for his work on graph databases. While specific biographical details are limited, he is recognized as one of the creators and core developers of Neo4j, a prominent graph database system. Ian Robinson has contributed significantly to the field of graph database technology through his writing and development work. His expertise in this area is evident in the book "Graph Databases," which he co-authored. Robinson's work focuses on explaining and promoting the use of graph databases in various applications, emphasizing their potential benefits over traditional relational databases for certain types of data modeling and querying.

Download PDF

To save this Graph Databases 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 Graph Databases 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.41 MB     Pages: 27
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...