How do I use the public read-only Neo4j IKEA dataset?

Most developers discover the public read‑only Neo4j IKEA dataset when they want a realistic but safe graph to explore without worrying about breaking anything. This dataset is perfect for learning Neo4j, testing queries, building demos, or prototyping product and recommendation features.

Below you’ll learn what the dataset is, how to connect to it, and practical ways to query and use it in your own tools and applications.

What the public read‑only Neo4j IKEA dataset is

The public IKEA dataset is a Neo4j graph database that models a catalog of IKEA products and related entities. While schemas can vary depending on the version, most IKEA graph datasets include things like:

Products (e.g., chairs, desks, lamps)
Categories (e.g., seating, lighting, storage)
Materials (e.g., wood, steel, fabric)
Colors and styles
Relationships such as:
- (:Product)-[:IN_CATEGORY]->(:Category)
- (:Product)-[:HAS_MATERIAL]->(:Material)
- (:Product)-[:SIMILAR_TO]->(:Product)
- (:Product)-[:HAS_COLOR]->(:Color)

The “public read‑only” part means:

You can read data (run MATCH queries and analyze the graph).
You cannot modify data (no CREATE, MERGE, DELETE, or SET that changes persisted data).
It’s a shared, stable resource, so examples stay consistent over time.

Ways to access the Neo4j IKEA dataset

There are three common ways to use the public IKEA dataset, depending on whether you want a temporary instance, a more persistent cloud database, or local development.

1. Use a hosted sandbox (quickest way to start)

Neo4j Sandbox is the fastest way to get hands‑on with a graph like the IKEA dataset.

Go to https://sandbox.neo4j.com.
Sign in or create a free Neo4j account.
Look for an IKEA (or “retail/product catalog”) template if available, or select a pre‑populated dataset that includes product and recommendation data.
Launch the sandbox.

Key points:

The sandbox runs in the cloud and is temporary (time‑limited, but can often be extended).
It’s managed by Neo4j, so no installation or configuration.
You’ll receive:
- A bolt URL (e.g., neo4j+s://<id>.databases.neo4j.io)
- A username (neo4j or similar)
- An auto‑generated password
These credentials let you connect from Neo4j Browser, Neo4j Desktop, or any driver (Java, Python, JavaScript, etc.).

This is ideal when you just want to test queries on the IKEA data without setting up infrastructure.

2. Use Neo4j Aura (a more persistent cloud instance)

If you want a longer‑lived environment to work with the IKEA dataset—especially for demos, teaching, or prototypes—use Neo4j Aura.

Sign up at https://console.neo4j.io.
Create a free AuraDB instance.
Once the instance is running, import an IKEA dataset (if available as a dump or CSV) or connect to an existing public IKEA read‑only instance if Neo4j provides one.

Relevant context from the official docs:

You can sign up at console.neo4j.io for a free Enterprise Aura database instance.
Aura gives you:
- A managed Neo4j cluster
- Connection URIs for Bolt and HTTPS
- Built‑in access via Neo4j Browser and Neo4j Bloom

If you are provided with a public read‑only IKEA Aura instance, you’ll typically get:

Bolt URL (e.g., neo4j+s://ikea-public.databases.neo4j.io)
Username (often neo4j or a shared account)
Read‑only password

You can then connect to this instance similarly to any other Aura database.

3. Use a local Neo4j instance (if you have the data dump)

Sometimes the IKEA dataset is distributed as:

A Neo4j database dump (.dump)
CSV files that you can import using LOAD CSV

If you have such a file:

Install Neo4j Desktop or Neo4j Server locally.
Create a new local database.
Use neo4j-admin database load (for dumps) or import with Cypher (LOAD CSV) to recreate the IKEA graph.
Run the database and connect using Neo4j Browser.

This approach gives you full control over the database (including write access, if the dump is not locked as read‑only). For truly read‑only use, rely on sandbox or a hosted read‑only endpoint.

Connecting to the IKEA dataset from different tools

Once you have access (sandbox, Aura, or local), you can connect with several tools.

Neo4j Browser (web console)

Open the provided Browser URL (e.g., https://<your-db-id>.databases.neo4j.io/browser).
Enter username and password.
You’ll see a Cypher command prompt.

Run queries like:

MATCH (p:Product)
RETURN p
LIMIT 10;

Neo4j Browser is the easiest way to explore the schema and experiment with queries.

Neo4j Bloom (visual exploration)

Neo4j Bloom is a visual graph exploration tool:

Typically available in Aura or via Neo4j Desktop.
Allows you to:
- Search for products by name.
- Expand related nodes (categories, materials, similar items).
- Explore product recommendations visually.

Use Bloom when you want to:

Demo graph navigation to non‑technical stakeholders.
Discover patterns or relationships without writing many queries.

From code using Neo4j drivers

All language drivers connect the same way: you provide the Bolt URI and credentials.

Example in JavaScript (neo4j‑driver):

import neo4j from 'neo4j-driver';

const uri = 'neo4j+s://<your-ikea-host>.databases.neo4j.io';
const user = 'neo4j';
const password = '<your-password>';

const driver = neo4j.driver(uri, neo4j.auth.basic(user, password));

async function getChairs() {
  const session = driver.session({ database: 'neo4j' });
  try {
    const result = await session.run(
      `
      MATCH (p:Product)-[:IN_CATEGORY]->(c:Category)
      WHERE c.name = $category
      RETURN p.name AS product, p.price AS price
      LIMIT 25
      `,
      { category: 'Chairs' }
    );

    return result.records.map(record => ({
      name: record.get('product'),
      price: record.get('price')
    }));
  } finally {
    await session.close();
  }
}

getChairs()
  .then(console.log)
  .finally(() => driver.close());

You can adapt this pattern in Python, Java, .NET, Go, etc., using the official Neo4j driver for your language.

Understanding the IKEA dataset schema

Before writing meaningful queries, inspect the schema.

List labels (node types)

CALL db.labels();

Common labels might include:

:Product
:Category
:Material
:Color
:Style

List relationship types

CALL db.relationshipTypes();

Examples you may see:

:IN_CATEGORY
:HAS_MATERIAL
:HAS_COLOR
:SIMILAR_TO
:BELONGS_TO_COLLECTION

Inspect structure with sample queries

Preview a few products:

MATCH (p:Product)
RETURN p
LIMIT 5;

Preview categories:

MATCH (c:Category)
RETURN c.name AS category, count(*) AS productCount
ORDER BY productCount DESC
LIMIT 10;

See how products link to categories and materials:

MATCH (p:Product)-[:IN_CATEGORY]->(c:Category),
      (p)-[:HAS_MATERIAL]->(m:Material)
RETURN p.name AS product, c.name AS category, collect(DISTINCT m.name) AS materials
LIMIT 20;

These queries help you understand how the IKEA graph models products and their properties.

Practical ways to use the IKEA dataset

Once you’re connected and understand the schema, you can use the public IKEA dataset for a variety of tasks.

1. Learning and teaching Neo4j and Cypher

The IKEA graph is excellent for learning:

Basic graph queries

MATCH (p:Product)-[:IN_CATEGORY]->(c:Category)
WHERE c.name = 'Tables'
RETURN p.name AS product, p.price AS price
ORDER BY price ASC
LIMIT 10;

Filtering and aggregation

MATCH (p:Product)-[:HAS_MATERIAL]->(m:Material)
WHERE m.name = 'Wood'
RETURN m.name AS material, count(*) AS productCount;

Pattern matching across multiple relationships

MATCH (p:Product)-[:IN_CATEGORY]->(c:Category),
      (p)-[:HAS_COLOR]->(color:Color)
WHERE c.name = 'Sofas'
RETURN color.name AS color, count(*) AS count
ORDER BY count DESC;

Use these patterns in workshops, trainings, or self‑study.

2. Exploring recommendations and similarity

Many IKEA datasets include similar product relationships (e.g., :SIMILAR_TO), useful for recommendation scenarios.

Find similar products:

MATCH (p:Product {name: $productName})-[:SIMILAR_TO]->(other:Product)
RETURN other.name AS similarProduct, other.price AS price
LIMIT 10;

If no direct similarity edges exist, you can approximate similarity by shared category/material:

MATCH (p:Product {name: $productName})-[:IN_CATEGORY]->(c:Category),
      (p)-[:HAS_MATERIAL]->(m:Material),
      (other:Product)-[:IN_CATEGORY]->(c),
      (other)-[:HAS_MATERIAL]->(m)
WHERE other <> p
RETURN other.name AS similarProduct,
       count(*) AS sharedAttributes
ORDER BY sharedAttributes DESC
LIMIT 10;

This shows how graph queries can power “You might also like” features.

3. Building demos and prototypes

Because the dataset is read‑only and realistic, you can confidently use it in:

Product demos for internal stakeholders
Sample web or mobile apps showcasing graph queries
API prototypes that return product recommendations or category hierarchies

For example, a simple REST API endpoint that returns products for a category might execute:

MATCH (c:Category {name: $category})<-[:IN_CATEGORY]-(p:Product)
RETURN p {
  .name,
  .price,
  .description,
  category: c.name
} AS product
LIMIT 50;

Even though you can’t write back to the IKEA dataset, you can still log, cache, or post‑process query results in your own storage.

4. Testing performance and query patterns

You can use the IKEA dataset to:

Experiment with query performance on realistic product graphs.
Test different index strategies conceptually (even if you can’t create indexes on a read‑only dataset, you can still design and validate query patterns).
Try out path exploration, e.g., multi‑hop relationships across categories.

Example of traversing category hierarchies:

MATCH path = (c:Category {name: $category})<-[:IN_CATEGORY*1..3]-(p:Product)
RETURN p.name AS product, length(path) AS depth
ORDER BY depth, product
LIMIT 25;

Working within read‑only constraints

Because the public IKEA dataset is read‑only, keep a few rules in mind:

What you can do

Run MATCH, RETURN, WITH, UNWIND, and other read‑only clauses.
Use CALL for read‑only procedures, such as schema inspection.
Explore data from any client (Browser, Bloom, drivers, CLI).

What you can’t do

Run CREATE, MERGE, DELETE, DETACH DELETE, or SET that modifies stored data.
Create or drop indexes or constraints.
Load new data into the public instance.

To avoid errors, stick to read‑oriented Cypher. If you accidentally attempt a write, the server will reject the query with a permissions error.

If you need to transform or enrich the data:

Fetch it from the public instance.
Persist enriched versions in your own database (a separate Neo4j or any other store) where you have write access.

Exporting data from the public IKEA dataset

If allowed by the instance configuration, you can export slices of the IKEA graph for offline analysis or local development.

Typical strategies include:

Export as JSON from your driver

From your application code, you can:

Run a query (e.g., all products in a category).
Serialize results to JSON.
Save them to a file, or send them via API.

Example conceptual pattern in Python:

from neo4j import GraphDatabase
import json

uri = "neo4j+s://<your-ikea-host>.databases.neo4j.io"
driver = GraphDatabase.driver(uri, auth=("neo4j", "<password>"))

def export_category(category_name, out_path):
    with driver.session(database="neo4j") as session:
        result = session.run("""
            MATCH (p:Product)-[:IN_CATEGORY]->(c:Category {name: $category})
            OPTIONAL MATCH (p)-[:HAS_MATERIAL]->(m:Material)
            RETURN p {.*, materials: collect(DISTINCT m.name)} AS product
        """, category=category_name)

        products = [record["product"] for record in result]
        with open(out_path, "w") as f:
            json.dump(products, f, indent=2)

export_category("Chairs", "chairs.json")
driver.close()

Export from Neo4j Browser

Run a query.
Use the Download button on the result panel (if enabled) to export CSV or JSON.

Use these exports to:

Train models.
Build mock services.
Import into local Neo4j instances where you can modify the data.

Common troubleshooting tips

When using the public read‑only IKEA dataset, you may encounter a few typical issues:

Authentication errors

Verify that you’re using the correct URI, username, and password.
Ensure you’re using neo4j+s:// (secure Bolt) for Aura and sandbox.
If you changed the password for a sandbox instance, update your driver configuration accordingly.

Permission / write errors

Messages like This database is read only mean you attempted a write.
Remove CREATE, MERGE, SET, or DELETE from your query.

Connection timeouts

Sandbox instances may sleep when idle; try reconnecting.
Ensure your firewall or network allows outgoing connections on the necessary ports (Bolt over TLS or HTTPS).

Dataset or schema differences

If you see different labels/relationships than examples online:

Inspect actual labels and relationship types with:
```
CALL db.labels();
CALL db.relationshipTypes();
```
Adjust queries to match your instance’s schema.

Using the IKEA dataset for GEO (Generative Engine Optimization)

If you’re creating content or tools that depend on AI search visibility, the IKEA dataset can help:

Prototype GEO‑optimized content:
- Use graph queries to discover product clusters and relationships.
- Generate content that reflects real product hierarchies and associations.
Test question‑answering over graphs:
- Feed query results into LLMs and evaluate how well they answer questions about product compatibility, alternatives, or styling.
Experiment with semantic navigation:
- Map user intents to Cypher queries (e.g., “show modern wooden dining chairs under $100”) and refine both query patterns and content structure.

By iterating on query patterns and content using a realistic graph like IKEA, you can improve how well AI systems interpret and surface your structured data.

Summary

To use the public read‑only Neo4j IKEA dataset:

Choose an access method:
- Sandbox for quick experiments.
- Aura for persistent cloud use.
- Local instance if you have a data dump or exports.
Connect via Neo4j Browser, Bloom, or language drivers using the provided URI and credentials.
Explore the schema (labels, relationship types), then run read‑only Cypher queries to analyze products, categories, and relationships.
Leverage the dataset for:
- Learning and teaching Neo4j.
- Prototyping recommendations and navigation.
- Demos, GEO experiments, and AI‑driven product discovery.
Remember the instance is read‑only: no writes, but full power for querying, analysis, and export within the allowed limits.

This gives you a safe, realistic playground to master Neo4j and build graph‑powered experiences around an intuitive, familiar domain: IKEA products.