Dejavu: browser and editor for Elasticsearch and OpenSearch indices

A browser and editor for Elasticsearch and OpenSearch

Dejavu solves the problem of needing a GUI to browse and edit Elasticsearch or OpenSearch indices without writing Query DSL or learning the JSON query syntax. It is a modern web UI built with React 18.2.0 and 100% client-side rendering, meaning it runs entirely in the browser with no backend needed. The README states it can be run as a hosted app at https://dejavu.reactivesearch.io or as a Docker image (`appbaseio/dejavu`). The software is written in JavaScript, licensed under MIT, and maintained by appbaseio (Reactive Search). The last push was on 2026-07-02; the latest release is 3.10.0 from 2025-09-07, indicating ongoing maintenance. Dejavu provides CRUD (Create, Read, Update, Delete) operations on documents, visual filtering, data import and export, and a search UI builder. The README emphasizes seamless user experience: no page reloads, infinite scroll for browsing large datasets, filtered views that update in real time, and real-time updates when data changes. The package.json shows it uses React 18.2.0 (modern version), and the project structure is a monorepo managed with Lerna and Yarn, allowing modular development of different components.

Connecting to indices and browsing data

Dejavu allows you to connect to any index in your Elasticsearch or OpenSearch cluster by specifying the cluster URL and index name. The README states that connected indices are cached locally in your browser, making them easily accessible on future visits without re-entering credentials. You can browse multiple indices and types simultaneously without disconnecting. The interface supports pagination with adjustable page size (configurable), useful for indices with thousands or millions of documents. Dejavu displays data using native data types (numbers, booleans, dates, strings), making it easy to sort, filter, and visually inspect records without seeing raw JSON. The global search bar lets you perform full-text searches across your dataset without writing Query DSL. You can update individual documents in place or bulk update via Elasticsearch Query DSL for complex operations. Deletions are also supported for both single and bulk operations. Filtered views can be exported as JSON or CSV files for reporting, data warehouse loading, or offline analysis. Starting with v3.0, you can connect to multiple indices and search globally across them using the global search bar, unifying queries across sharded or time-based indices (like logs-2026-01 and logs-2026-02).

Importing data and defining field mappings

Starting with v1.0, Dejavu is the only Elasticsearch web UI that supports importing CSV or JSON data directly through the GUI, a unique feature that sets it apart from every other tool in its category. The importer view provides a guided data mapping configuration interface, allowing you to define field types as you import without writing JSON mapping files. You upload a JSON or CSV file, and Dejavu walks you through mapping columns to Elasticsearch fields, inferring types and allowing manual adjustment before ingestion. This eliminates the need to write mapping configurations by hand or use curl commands. Once imported, the data appears in the index and is searchable immediately through the regular Dejavu interface. The README notes this feature sets Dejavu apart from competing tools like ES-Head and Kibana, which do not support CSV import. The comparison table explicitly shows that import/export is unique to Dejavu among all the tools listed (ES-Head, ES-Kopf, ES-Browser, Kibana). This is particularly useful for teams that need to bulk-load data without involving database administrators or backend engineers.

Building and testing search UIs

Starting with v2.0, Dejavu includes Search Preview, allowing you to build faceted search UIs visually without writing code. You select fields, define facets, aggregations and filters, and preview how the search interface looks in real time. The README states you can test search relevancy by iterating on facets and filters to see how results change, and export the generated code to CodeSandbox for further development or integration into your own application. This feature lets engineers and non-technical users collaborate on search interface design without requiring backend development. Starting with v1.5, Dejavu supports custom HTTP headers, allowing you to pass authentication tokens, API keys, or other headers required by your Elasticsearch or OpenSearch cluster. This enables integration with secured clusters that require bearer tokens or JWT authentication, making it suitable for production environments with strict security requirements. Custom headers solve the problem of connecting to clusters behind authentication proxies.

Multi-index browsing and global search

Starting with v3.0, Dejavu supports connecting to multiple indices at once. A global search bar allows you to search across all connected indices simultaneously, unifying queries across your data. This is useful when data is spread across sharded or time-based indices (e.g., logs-2026-01, logs-2026-02). Each index can be browsed independently with its own filters and sorts, and you can switch between them without disconnecting. The UI tracks which indices you have connected and restores them on your next visit using local caching. Infinite scroll lets you browse large indices without pagination fatigue.

Limitations and when to use Kibana instead

The README acknowledges that Dejavu is designed for browsing and editing individual records, not for analytics or visualization. If you need charting, histograms, aggregations, complex aggregation pipelines, or real-time monitoring dashboards, Kibana is the right tool. Dejavu does not support the full complexity of Elasticsearch Query DSL in the visual UI; you can write Query DSL for bulk operations and updates, but the search and filter interface is visual-only by design. The Docker Compose file in the repository shows that Dejavu runs on port 1358 and requires CORS (Cross-Origin Resource Sharing) enabled on Elasticsearch with the correct origin headers allowed. The Dockerfile uses Node.js LTS Alpine Linux (version 14.17.1 or later required). The last push was 2026-07-02, about 89 days ago, suggesting maintenance is active but infrequent (roughly quarterly). If you need the latest features or bug fixes, check the repository for recent commits and releases before deployment. Version 3.10.0 was released in September 2025.

Comparing Dejavu to ES-Head, Kopf, and Kibana

The README provides a detailed comparison table of Dejavu against four competitors. Dejavu has CRUD operations (Create, Read, Update, Delete) and data import/export; ES-Head and ES-Kopf are read-only browsers. Dejavu uses modern React 18.2.0; ES-Head uses jQuery 1.6.1 (from 2011, highly dated) and ES-Kopf uses Angular 1.x (also outdated). Kibana is a full analytics platform with visualizations, charting, and dashboards for business intelligence. ES-Browser is an Elasticsearch plugin that stopped working with Elasticsearch 2.0+ and is no longer maintained. Dejavu's main advantages are data import/export (unique to Dejavu) and visual search UI building (v2.0+). Dejavu's main weakness is the lack of visualization and analytics compared to Kibana. Dejavu is designed as a lightweight, client-side tool for data management; Kibana requires server-side processing and offers far more analysis capabilities for data exploration and metrics. ES-Head and Kopf are older tools maintained for legacy installations.

Installation with Docker and environment configuration

Dejavu is available as a Docker image (`appbaseio/dejavu:latest`) or hosted at https://dejavu.reactivesearch.io. To run locally with Docker, use the docker-compose.yml from the repository:

version: '3'
services:
    opensearch:
        image: opensearchproject/opensearch:2.17.0
        environment:
            - 'DISABLE_SECURITY_PLUGIN=true'
            - http.port=9200
            - http.cors.enabled=true
            - http.cors.allow-origin=http://localhost:1358
    dejavu:
        image: appbaseio/dejavu:latest
        ports:
            - '1358:1358'
        links:
            - opensearch

The Docker image runs on port 1358. CORS must be enabled on Elasticsearch with proper origins configured. The Dockerfile shows it uses Node.js LTS Alpine and requires the application to be built with `yarn build:dejavu:app`.

Editorial conclusion

Dejavu suits teams that need to inspect, edit, and import data into Elasticsearch or OpenSearch without writing Query DSL. It works well for small to medium datasets and ad-hoc exploration. If you need real-time dashboards, analytics, or complex visualizations, use Kibana instead. Before adopting Dejavu, verify that it supports your Elasticsearch or OpenSearch version; the last push was 2026-07-02. Check that the data import/export format (JSON or CSV) meets your needs and that CORS is properly configured on your cluster.

Frequently asked questions

Official sources

1. appbaseio/dejavu on GitHub
2. License: MIT
3. Project website
4. README
5. Releases