LLM knowledge graph databases

holds a wide lead for building knowledge graphs from unstructured text for LLM querying.

It depends

For ontology-free extraction, its answer points to instead.

Since Jul 5Updated Nov 20, 2026Based on 198 AI answersReviewed by

How we measure

Brands AI mentions

#BrandMentioned in
#1Neo4j89%

Neo4j pairs GraphRAG with graph capabilities, hybrid retrieval, and LLM integration.

Mentioned in, on ChatGPT and Google AI Mode

Key takeaways for LLM knowledge graph databases

  • Vs overall market

    Neo4j leads LLM knowledge graph databases (89%) as well as the overall AI Knowledge Graph Platforms market. View AI Knowledge Graph Platforms

  • Top contenders

    Neo4j (89%) leads runner-up LangChain (63%) by 26 percentage points.

  • Across AI Knowledge Graph Platforms

    Within AI Knowledge Graph Platforms, Neo4j Aura leads Free tier pricing limits, showing AI shifts picks by buyer use case. See Free tier pricing limits

Questions and answers

  • Google AI ModeNov 18, 2026

    1. 1Neo4j
    2. 2LangChain
    3. 3LlamaIndex
    4. 4Microsoft GraphRAG
    5. 5Graphiti
    6. 6Zep
    7. 7FalkorDB
    8. 8Amazon Neptune
    9. 9Kùzu
    10. 10Claude

    Building a knowledge graph (KG) for an LLM means giving the model a structured, multi-hop map of entities and relationships rather than relying solely on flat vector search (RAG).

    To build and query a knowledge graph with an LLM, choose a stack based on your architecture, storage needs, and whether you are building static domain data or dynamic agent memory.

    Step 1: Choose Your Architecture & Framework

    • GraphRAG / Native Graph Engines (Best for heavy reasoning & multi-hop queries):
      • Neo4j + LangChain/LlamaIndex: The industry standard. Use LLMs to extract entities/relationships from text and store them in Neo4j, then query via Cypher generation or graph-aware retrievers.
      • Microsoft GraphRAG: An open-source framework that uses LLMs to extract a hierarchical community-based knowledge graph from raw text corpora, enabling global summarization and local entity queries.
    • Temporal / Agentic Memory Graphs (Best for AI agents & chat history):
      • Graphiti (by Zep): An open-source Python framework that builds and queries real-time temporal context graphs with automatic fact invalidation and multi-backend support (Neo4j, FalkorDB, Amazon Neptune).
    • Lightweight / Embedded Graphs:
      • Kùzu or FalkorDB: High-performance, low-latency graph databases built for modern analytics and LLM embedding workflows.

    Step 2: Choose How the LLM Queries It

    There are three primary patterns for letting an LLM interact with a knowledge graph:

    1. Text-to-Cypher / Text-to-SQL (Dynamic Querying):
      • The LLM is given the graph's schema (node labels, relationship types) in its system prompt.
      • When a user asks a question, the LLM writes a Cypher or SPARQL query, the system executes it against the graph database, and the LLM formats the raw JSON/tabular result into a natural language answer.
    2. Graph Traversal / GraphRAG (Hybrid Retrieval):
      • The system uses vector similarity or keyword search to find a "seed" node, traverses N-hops out from that node to pull related context, and feeds those structured triplets [Entity] -> [Relationship] -> [Entity] into the LLM's context window.
    3. Model Context Protocol (MCP):
      • Expose your graph database as an MCP Server so that compatible AI agents (like Claude Desktop or custom agents) can query, traverse, and mutate the graph safely via standardized tool calls.

    Step 3: Minimal Implementation Pipeline (Python)

    A typical baseline pipeline using Neo4j and LangChain or Graphiti looks like this:

    1. Incision/Extraction: Pass raw documents through an LLM with a strict Pydantic schema or prompt to extract (Subject, Predicate, Object) triplets.
    2. Ingestion: Write those triplets into your graph database (e.g., MERGE (a:Entity {name: $sub})-[:RELATION {type: $pred}]->(b:Entity {name: $obj})).
    3. Ontology Enforcement: Define explicit rules for what node types can link to what to prevent LLM hallucinations.
    4. Retrieval Loop: Combine vector search over entity descriptions with graph neighborhood extraction before final generation.

    To help narrow down the right stack, tell me:

    • What kind of data are you putting into the graph (e.g., PDFs/docs, live database, or agent chat memory)?
    • What is your preferred tech stack or cloud provider?

    ChatGPTNov 18, 2026

    1. 1Neo4j
    2. 2Python
    3. 3Microsoft GraphRAG
    4. 4Apache Jena
    5. 5Amazon Neptune
    6. 6FastAPI
    7. 7OpenAI API
    8. 8OpenAI Embeddings

    You need a Knowledge Graph + LLM Retrieval Architecture (often called GraphRAG) that allows a Large Language Model (LLM) to retrieve information, understand relationships between entities, and answer questions using structured knowledge rather than relying exclusively on vector similarity.

    I would recommend building a system where the knowledge graph is the source of structured truth and the LLM acts as the natural-language query interface.

    1. Recommended architecture

    Data sources

    Documents · Databases · APIs · Enterprise systems

    Knowledge extraction and ingestion

    Entity extraction · Relationship extraction · Entity resolution

    Knowledge Graph

    Entities + Relationships + Properties

    Neo4j / RDF triplestore / Graph database

    Graph Query and Retrieval Layer

    Cypher · SPARQL · Graph traversal · Hybrid search

    LLM Agent

    Natural language → query generation → graph retrieval → reasoning

    Answers with supporting evidence

    Grounded answers · Relationships · Provenance · Citations

    2. Technology recommendations

    Here are the main technologies I would consider.

    • Neo4j Logo Vector Download | Logowik

    1. Neo4j — My recommended starting point

    (Best general-purpose choice)

    • Property graph database.
    • Cypher query language.
    • Vector and full-text search.
    • LLM-generated queries and graph traversal.
    • Official Python GraphRAG integration.

    Documentation: Neo4j GraphRAG ·


    • Microsoft Graph RAG #2

    2. Microsoft GraphRAG

    Particularly interesting when you have large collections of documents and want to discover entities, relationships, communities, and higher-level themes.

    Project:


    • techstacks.io

    3. Apache Jena

    Best suited to semantic knowledge graphs using RDF, OWL ontologies, and SPARQL. A good choice when formal semantics, standards, and interoperability matter.

    Website:


    • Amazon Neptune - Plume

    4. Amazon Neptune

    Managed graph database supporting property graphs and RDF. Worth considering for AWS-centric enterprise deployments.

    Website:

    3. How the LLM should query the graph

    I recommend supporting three complementary retrieval methods:

    MethodPurpose
    Natural language to Cypher/SPARQLAnswer precise questions
    Vector search + graph traversalFind relevant concepts and connected entities
    Multi-hop graph reasoningAnswer questions requiring several relationships

    For example, suppose your graph contains:

    • Company: Acme
    • Person: John
    • Technology: Kubernetes
    • Project: Cloud Migration

    Relationships:

    • John WORKS_FOR Acme
    • John MANAGES Cloud Migration
    • Cloud Migration USES Kubernetes

    The user asks:

    "Which technologies are used by projects managed by people working for Acme?"

    The LLM translates that into a graph query, retrieves the relationships, and produces an answer:

    Answer: Kubernetes.

    The important part is that the answer can be traced back to the actual graph relationships.

    Neo4j's official GraphRAG package supports vector retrieval, hybrid retrieval, graph-enhanced retrieval, and natural-language-to-Cypher approaches.

    4. Suggested implementation stack

    For a practical first implementation, I would use:

    LayerTechnology
    Graph databaseNeo4j
    Graph queryCypher
    BackendPython + FastAPI
    LLMOpenAI API
    Graph integrationNeo4j GraphRAG
    EmbeddingsOpenAI embeddings
    User interfaceChat interface
    Query interfaceREST API or MCP server

    One important design consideration: don't give the LLM unrestricted database access. Use a read-only database account, validate generated queries, enforce query limits, and preserve source provenance.

    5. A few questions to determine the right solution

    I want to understand what kind of knowledge graph you're building, because that changes the recommended architecture considerably.

    1. Where does the knowledge come from?

    • Documents (PDFs, Word, websites)
    • Existing relational databases
    • Existing knowledge graph / RDF data
    • APIs and multiple enterprise systems
    • A combination of these

    2. What do you want the LLM to do?

    • Query facts and relationships.
    • Perform complex multi-hop reasoning.
    • Discover connections that aren't immediately obvious.
    • Answer questions using company-specific knowledge.
    • All of the above.

    3. How do you envision deploying it?

    • Locally / on-premises.
    • Cloud-hosted.
    • Either is acceptable.

    My key question: Are you looking to build a new knowledge graph from existing information, or do you already have a knowledge graph and need to make it accessible to an LLM?

    I can help design the complete architecture, including the graph schema, ingestion pipeline, query interface, and LLM integration.

  • Google AI ModeOct 5, 2026

    1. 1Neo4j LLM Knowledge Graph Builder
    2. 2Neo4j
    3. 3Gemini
    4. 4LangChain
    5. 5LightRAG
    6. 6Microsoft GraphRAG

    When building a knowledge graph from unstructured text without a rigid, pre-defined schema, modern Large Language Model (LLM) pipelines let the extraction model dynamically discover entities and relationships on the fly.

    Top options for schema-free or dynamic-schema text extraction vary from turn-key developer tools to lightweight open-source indexing frameworks:

    • Neo4j LLM Knowledge Graph Builder is a popular open-source web application and framework. It ingests raw PDFs, documents, web pages, or transcripts and uses an LLM (OpenAI, Gemini, Claude, Llama) to dynamically extract entities and relationships directly into a Neo4j instance without demanding a strict upfront ontology.
    • LangChain LLM Graph Transformer provides programmatic primitives (LLMGraphTransformer ) in Python/JS. You pass it unstructured text documents and an LLM, and it automatically parses out nodes and triplets. While you can optionally pass allowed node/relationship types to restrict output, leaving them open allows the model to induce the schema dynamically from the text.
    • LightRAG is an emerging open-source RAG framework that treats a schema-free entity-relationship graph as the core indexing mechanism for raw text. Rather than forcing you to define categories beforehand, it automatically extracts entities, relationships, and dual-level retrieval structures directly from incoming documents on ingestion.
    • Microsoft GraphRAG uses a multi-stage LLM pipeline that reads unstructured text and first builds a comprehensive, schema-free knowledge graph via an automated extraction prompt, subsequently grouping elements into communities for holistic reasoning.

    If you want to narrow this down, tell me:

    • Are you looking for a Python library / code framework or a hosted/UI application?
    • What is your target database or storage (e.g., Neo4j, relational SQL, or file-based)?

    I can point you to the exact code snippet or setup guide for your stack.

    ChatGPTOct 5, 2026

    1. 1Neo4j
    2. 2Graphiti

    Yes. The strongest match I found is Neo4j LLM Knowledge Graph Builder.

    Best matches

    ToolSchema required?Unstructured textBest for
    Neo4j LLM Graph BuilderNo — schema is optional; it can infer entities/relationshipsPDFs, DOCX, TXT, web pages, YouTube, etc.Easiest ready-to-use solution
    GraphitiNo upfront ontology requiredDocuments, conversations, events, agent memoryDevelopers building a continuously evolving/temporal KG
    Knowledge Graph FoundryNo — explicitly discovers the ontologyPDF, DOCX, TXT, MD, JSON, CSV, XLSXSimple CLI/self-hosted pipeline

    1. Neo4j LLM Knowledge Graph Builder — my first choice

    This is almost exactly your requirement. You feed it unstructured sources and the LLM extracts entities, relationships, and properties; defining a schema is explicitly optional. Neo4j also has an experimental automatic-schema capability that can infer the schema using an LLM.

    It supports PDFs, documents, web pages, YouTube transcripts, and other sources, and stores the resulting graph in Neo4j.

    One caveat: completely schema-free extraction can produce a very large number of entity/relationship types. Neo4j itself recommends schema guidance for highly constrained production graphs, although its automatic consolidation can reduce the proliferation of types afterward.

    Good choice if: you want to upload documents and visually inspect the automatically generated graph without building the extraction pipeline yourself.

    2.

    Graphiti is more of a developer framework than a turnkey UI. Its strength is building dynamic/temporal knowledge graphs from continuously arriving information—particularly useful for agent memory, conversations, and changing facts. It supports Neo4j and other graph backends.

    Good choice if: you're embedding the KG into an application rather than just uploading a document corpus.

    3. Knowledge Graph Foundry

    This is an interesting newer CLI option. Its documentation explicitly says “No predefined schema required” and that it discovers the ontology from your data, while still allowing you to seed a schema later. It accepts common document formats and produces a Neo4j graph with provenance.

    Good choice if: you want a lightweight, code/CLI-oriented alternative to Neo4j's UI.

    My recommendation

    If your requirement is literally:

    “Give it arbitrary documents → automatically discover what entities and relationships exist → produce a knowledge graph without me designing an ontology first.”

    I'd start with Neo4j LLM Knowledge Graph Builder. It is the most mature and turnkey fit I found.

    If you tell me whether you want (a) a hosted SaaS, (b) open-source/self-hosted, or (c) a Python/API library, I can narrow this down to the best 3–5 options and compare schema discovery, entity resolution, provenance, temporal support, LLM requirements, and cost.

  • ChatGPTNov 1, 2026

    1. 1Neo4j
    2. 2Cognee
    3. 3Microsoft GraphRAG
    4. 4LlamaIndex
    5. 5LangChain
    6. 6Neo4j LLM Knowledge Graph Builder

    As of November 2026, my top recommendation is Neo4j, specifically its Document Intelligence / Knowledge Graph Builder capabilities.

    It is particularly well suited to automatically extracting entities, relationships, and properties from unstructured text and turning them into an explorable, queryable knowledge graph.

    However, there are several strong alternatives depending on whether you want a no-code tool, an open-source framework, or an enterprise solution.

    Top 5 tools compared

    • Build Real-Time Knowledge Graph For Documents with LLM | CocoIndex

    1. Neo4j

    (Best overall)

    • Automatic entity and relationship extraction.
    • Document ingestion from PDF, DOCX, TXT, Markdown and EPUB.
    • Graph visualization and entity resolution.
    • Supports GraphRAG.

    Best for: Production-ready knowledge graphs and enterprise applications.

    Official website ·


    • How to Give Your AI Agent a Knowledge Graph Memory with Cognee

    2. Cognee

    (Best for automated extraction)

    • Extracts entities and relationships automatically.
    • Builds and maintains knowledge graphs.
    • Supports ontology generation.
    • Designed for AI memory and RAG applications.

    Best for: Automating knowledge graph construction with minimal manual schema design.

    Official website


    • Welcome - GraphRAG

    3. Microsoft GraphRAG

    • Extracts entities and relationships from documents.
    • Builds graph communities and summaries.
    • Supports complex, multi-hop question answering.

    Best for: Large document collections and advanced knowledge discovery.

    GitHub repository


    • LLM knowledge graph builder—First release of 2025

    4. LlamaIndex

    • PropertyGraphIndex for knowledge graph construction.
    • LLM-based entity and relationship extraction.
    • Multiple graph database integrations.
    • Flexible retrieval pipelines.

    Best for: Developers building custom knowledge graph and RAG applications.

    Official website


    • Building Knowledge Graphs with LLM Graph Transformer

    5. LangChain

    • LLMGraphTransformer extracts nodes and relationships.
    • Supports custom entity types and relationship schemas.
    • Integrates with Neo4j.

    Best for: Developers who want control over extraction logic.

    Official website

    Sources:

    Quick comparison

    ToolAutomatic extractionNo-code optionBest use
    Neo4jYesYesEnterprise KG
    CogneeYesMore developer-orientedAutomated KG
    Microsoft GraphRAGYesNoDocument discovery
    LlamaIndexYesNoCustom RAG
    LangChainYesNoCustom extraction

    My recommendation

    I'd narrow the choice to three:

    • Neo4j: If you want to upload documents and get a visual knowledge graph.
    • Cognee: If you want automatic knowledge graph generation, ontology discovery, and ongoing knowledge management.
    • Microsoft GraphRAG: If you want to discover hidden connections across large collections of documents.

    One important distinction: extracting entities and relationships is only the first step. A good system should also support entity deduplication, relationship validation, source-document traceability, and incremental updates.

    One question to narrow down the best tool

    What is your primary objective?

    1. What do you want to accomplish?

    Upload documents and automatically generate a visual knowledge graph

    Extract entities and relationships from millions of documents

    Build a knowledge graph for AI agents and RAG

    Discover hidden connections across documents


    2. What kind of input data?

    PDFs, Word documents and text files

    Websites, articles and research papers

    Emails, conversations and transcripts

    Mixed data sources


    3. Preferred implementation?

    No-code / low-code

    Python / open-source

    Enterprise / managed platform

    No preference

    [Find my best-fit tool]

    Google AI ModeNov 1, 2026

    1. 1Microsoft GraphRAG
    2. 2LlamaIndex
    3. 3Neo4j
    4. 4Neo4j Bloom
    5. 5spaCy
    6. 6scispaCy
    7. 7Relik

    There isn't a single "one-size-fits-all" tool, but rather a few powerhouse frameworks depending on whether you want an out-of-the-box pipeline or a developer-friendly framework powered by Large Language Models (LLMs).

    The industry standards for extracting entities and relationships from unstructured text to build knowledge graphs fall into these top categories:

    1. Microsoft GraphRAG — Best out-of-the-box for deep, holistic extraction
      • How it works: It uses an LLM to automatically parse unstructured text into "TextUnits," extract entities, relationships, and key claims, and then runs hierarchical graph clustering (using the Leiden technique) to generate community summaries.
      • Why it's great: Unlike basic extraction tools that just map A-to-B relationships, Microsoft GraphRAG structures the data hierarchically so you can query high-level thematic questions across massive document sets, not just localized keyword lookups.
    2. LlamaIndex (Knowledge Graph Index) — Best for Python developers building custom RAG pipelines
      • How it works: LlamaIndex provides native abstractions (KnowledgeGraphIndex ) that ingest unstructured documents, slice them, prompt an LLM to extract the triple elements (subject, predicate, object), and store them directly into a graph backend (like Neo4j, FalkorDB, or NetworkX).
      • Why it's great: Highly modular. You can swap out your LLM provider, customize the custom extraction prompts, and choose your preferred graph database destination with minimal boilerplate code.
    3. Neo4j GraphRAG Ecosystem & Python Driver — Best for enterprise storage and visualization
      • How it works: Neo4j provides native pipelines and developer tools that interface with LLMs (via LangChain or their own APOC procedures) to extract entities/relationships and persist them into the Neo4j Graph Database.
      • Why it's great: Once the data is extracted, you get the industry's gold standard graph storage engine, powerful Cypher querying, and enterprise-grade visualization tools (like Neo4j Bloom/Workspace) to actually explore the resulting graph.
    4. spaCy + Scispacy / Relik — Best traditional NLP (Non-LLM) approach
      • How it works: Uses lighter, localized Named Entity Recognition (NER) models and relation extraction pipelines rather than expensive generative LLMs.
      • Why it's great: If you have millions of documents, strict data privacy needs, or a tight budget, running spaCy pipelines is deterministic, lightning-fast, and doesn't require API calls to external LLMs (though it lacks the deep semantic reasoning of an LLM).

    To help narrow down the ideal choice for your project, tell me:

    • What is the approximate scale and format of your unstructured text (e.g., a few PDFs vs. terabytes of data)?
    • Do you prefer a fully automated Python code framework (like LlamaIndex) or a standalone tool/database (like Neo4j)?
  • Google AI ModeSep 25, 2026

    1. 1Neo4j
    2. 2LangChain
    3. 3LlamaIndex
    4. 4FalkorDB
    5. 5OpenAI
    6. 6Anthropic

    For building and querying a knowledge graph (KG) from unstructured text using an LLM, the gold-standard combination in the industry is Neo4j as the graph database, paired with LangChain or LlamaIndex as the LLM orchestration/integration frameworks.

    1. The Best Graph Database: Neo4j

    • Why it wins: Neo4j is the most mature, widely adopted graph database and has heavily invested in the GenAI/LLM ecosystem. It supports native vector indexing alongside property graphs, meaning you can do hybrid searches (combining vector similarity with traditional graph traversals—often called GraphRAG).
    • Key features for LLMs:
      • Cypher Query Language: Highly expressive language for pattern matching that LLMs can easily learn to generate from natural language.
      • Neo4j Aura: Fully managed cloud tier that removes infrastructure overhead for prototyping.
    • Alternative worth mentioning: FalkorDB (built on GraphBLAS/Redis) is exceptionally fast for in-memory traversal workloads if ultra-low latency is your primary constraint.

    2. The Best LLM Integration Frameworks: LlamaIndex or LangChain

    You don’t write raw API calls to parse text into a graph anymore; orchestration frameworks handle the text-splitting, entity extraction, and graph injection pipeline for you.

    • LlamaIndex (Best for Knowledge Graph Construction & Retrieval):
      • Why choose it: LlamaIndex has built-in KnowledgeGraphIndex abstractions specifically designed to ingest unstructured text, use an LLM to extract entities and relationships, and automatically structure them directly into Neo4j. It excels at data-centric operations and advanced GraphRAG indexing.
    • LangChain (Best for Agentic Workflows & Cypher Generation):
      • Why choose it: LangChain provides robust GraphCypherQAChain tools that allow an LLM to dynamically translate a user's natural language question into a Cypher query, execute it against Neo4j, and synthesize an answer. It shines if you want to build conversational agents over your graph.

    Recommended Architecture Stack

    1. Ingestion & Extraction: Use LlamaIndex with your choice of LLM (e.g., OpenAI, Anthropic, or a strong local model via Ollama) to parse and extract triplets (Entity) -> [RELATIONSHIP] -> (Entity) from your raw documents.
    2. Storage: Persist those nodes and edges into Neo4j Aura.
    3. Querying (GraphRAG): Use LlamaIndex for semantic/hybrid retrieval or LangChain to power a text-to-Cypher QA interface.

    If you'd like, tell me more about your project:

    • Is your text data large scale (millions of documents) or small/medium?
    • Do you prefer a fully managed cloud service or a local/open-source setup?
    • Are you leaning toward Python or JavaScript/TypeScript for development?

    I can share a starter code snippet or recommend the exact pipeline configuration for your use case.

    ChatGPTSep 25, 2026

    1. 1Neo4j
    2. 2OpenAI
    3. 3Anthropic
    4. 4Gemini

    My default choice: Neo4j + Neo4j GraphRAG + an LLM with structured output. It currently has a first-party Python GraphRAG package covering KG extraction, embeddings, vector/hybrid retrieval, and natural-language-to-Cypher querying.

    A solid architecture is:

    Documents → chunking → LLM entity/relation extraction → Neo4j → hybrid graph+vector retrieval → LLM

    For querying, combine:

    • Vector/Cypher retrieval for semantic + relationship-aware search.
    • Text2Cypher for questions requiring explicit graph traversal.
    • Structured output during extraction to make entities/relationships conform to your schema.

    Neo4j officially supports OpenAI, Anthropic, Gemini, Mistral, Cohere, and Ollama integrations.

    neo4j.com

LLM knowledge graph databases: common questions

Which brands does AI recommend for LLM knowledge graph databases?
AI most often mentions Neo4j (89%), LangChain (63%), LlamaIndex (51%), Neo4j LLM Knowledge Graph Builder (33%) and Amazon Neptune (33%) for LLM knowledge graph databases in AI Knowledge Graph Platforms.
Does the LLM knowledge graph databases leader match the overall AI Knowledge Graph Platforms market?
Neo4j leads LLM knowledge graph databases (89%) as well as the overall AI Knowledge Graph Platforms market.
What questions do buyers ask AI about LLM knowledge graph databases?
Common buyer questions include "I need a knowledge graph that can be queried by a Large Language Model.", "I need a knowledge graph builder that ingests unstructured text and does not require a pre-defined schema.", "What is the best tool for creating a knowledge graph by automatically extracting entities and relationships from unstructured text?".
For agents: this page as Markdown, parse.gl/topics/graph-database-for-llm-knowledge-graph-integration.md.

This page

Reuse: Figures and tables on this page are free to republish with attribution: a link to https://parse.gl/topics/graph-database-for-llm-knowledge-graph-integration beside them. A standard followed link (dofollow) is preferred.

Read and search

Every brand's share on this topic, with 95% ranges: GET agent.parse.gl/v1/tools/query_metrics?args=%7B%22measures%22%3A%5B%22share_named%22%5D%2C%22by%22%3A%5B%22brand%22%5D%2C%22filter%22%3A%7B%22topic%22%3A%5B%22top_deab0980-5873-485e-83d8-43b1c0d6529a%22%5D%7D%7D
Search the index: GET parse.gl/api/public/search?q=<words>

Connect

Connect an assistant: agent.parse.gl/mcp

An agent can save work before signup: POST https://agent.parse.gl/v1/workspaces

What it costs

No account: Public figures and up to 5 examples per list, about 120 brands a day per address.
Free account: $5 in credit, your brand's first check (20 buyer questions) and a free weekly check.
After your first top-up: Exports and deeper search results. The first top-up starts at $5.
Live checks: $0.01 per question per engine ($0.05 on Gemini and Claude).
Full public answers and pages: 25 free per day, then $0.005 each.
Public answers older than 90 days: $0.001 each the first time your workspace counts or lists one, then yours.