canonical: https://jentic.com/apis/nuix.com/nuix

# Nuix RESTful API

Jentic publishes the only available OpenAPI specification for Nuix RESTful API, keeping it validated and agent-ready. Nuix is an investigation and eDiscovery platform used by law firms, regulators, and corporate compliance teams to process, search, tag, and export huge volumes of unstructured evidence. The RESTful API exposes case lifecycle, item access, search, tagging, processing, and export operations against a self-hosted Nuix server. It is deployed inside legal review workflows, internal investigations, and incident-response engagements where defensible audit trails are required.

## For AI agents

Manage Nuix cases, search and tag items, run data processing jobs, and export evidence for review and production.

## Scope

Does not handle SaaS data collection, payments, or messaging - use for Nuix case processing, search, tagging, and export only.

## Capabilities

- Create, list, retrieve, and delete eDiscovery cases on a Nuix server
- Search items inside a case using Nuix's query language
- Tag and untag individual items to organise review batches
- Retrieve item text, binary content, and metadata for review
- Trigger processing jobs that ingest new evidence into a case
- Export case data into review or production deliverables
- Inspect tags applied across an entire case for QC and audit

## Use cases

### eDiscovery Case Setup and Processing

Litigation support teams stand up a new matter by creating a case via POST /cases, then kick off processing through POST `/cases/{caseId}/process` to ingest collected custodian data. Once processing finishes, reviewers search and tag responsive items. The API replaces manual Workbench clicks and lets the workflow run inside automation.

Example prompt: Call POST /cases with the matter name, then POST `/cases/{caseId}/process` with the evidence source path

### Search and Tag Review

Reviewers run keyword and concept searches across a case and tag matching items as responsive, privileged, or hot. The flow uses POST `/cases/{caseId}/search` to pull a result set and POST `/cases/{caseId}/items/{itemId}/tags` to apply tags. Tags retrieved via GET `/cases/{caseId}/tags` drive QC and reporting.

Example prompt: Call POST `/cases/{caseId}/search` with a query, then POST `/cases/{caseId}/items/{itemId}/tags` for each responsive hit

### Production Export

Once review concludes, the case data is exported via POST `/cases/{caseId}/export` to produce load files for opposing counsel or regulators. The export endpoint is the bridge between Nuix's internal database and downstream review platforms or productions.

Example prompt: Call POST `/cases/{caseId}/export` with the export profile and target path to produce the deliverable

### Agent-Driven Investigation

An AI agent assisting a compliance investigator searches a Nuix case, retrieves item text, and tags items that match a fraud pattern. Through Jentic the agent searches for 'search Nuix case', loads the POST `/cases/{caseId}/search` schema, and executes without learning the bespoke Nuix query syntax.

Example prompt: Search Jentic for 'search Nuix case items', load the schema for POST `/cases/{caseId}/search`, and execute with the case ID and query

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| GET | `/cases` | List all cases |
| POST | `/cases` | Create a new case |
| GET | `/cases/{caseId}/items` | List items in a case |
| POST | `/cases/{caseId}/search` | Search items in a case |
| POST | `/cases/{caseId}/items/{itemId}/tags` | Add a tag to an item |
| POST | `/cases/{caseId}/process` | Start data processing |
| POST | `/cases/{caseId}/export` | Export case data |

## Key resources

- **Cases** — Create, list, retrieve, and delete eDiscovery cases
- **Items** — List items in a case and retrieve text, binary, metadata, and tags
- **Search** — Run queries against case items
- **Tags** — Apply, remove, and list tags within a case
- **Processing** — Start jobs to ingest evidence into a case
- **Export** — Export case data for production deliverables

## Why Jentic

- **Setup:** Wiring the Nuix RESTful API by hand means supporting both basic and bearer auth, resolving the self-hosted host and port for each deployment, and mapping the case, search, tagging, and export operations yourself. Through Jentic you install once, import the Nuix RESTful API from the API Directory, store the credentials once, and your agent calls it.
- **Permission scoping:** Nuix puts the case and item ids in the URL path (`/cases/{caseId}/items/{itemId}/tags`), so a rule can pin your agent to one case: it can search and tag within that case and nothing else. You choose the operations it may call, so processing and exporting a case are not included unless you add them.
- **Credential handling:** Your Nuix bearer token and basic credentials are stored once, encrypted, by your own Jentic One instance and injected at execution time. They never enter the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'search a Nuix case' or 'tag responsive items', and Jentic returns the matching Nuix operation with its input schema so the agent calls the right endpoint without browsing the reference docs.

## Related APIs

- **Onna** — Knowledge integration platform with eDiscovery and compliance collection
- **Basecamp** — Project management for coordinating review teams alongside Nuix processing
- **Asana** — Task management for review batch assignment around Nuix workflows

## FAQ

### Why is there no official OpenAPI spec for Nuix RESTful API?

Nuix does not publish an OpenAPI specification. Jentic generates and maintains this spec so that AI agents and developers can call Nuix RESTful API via structured tooling. It is validated against the live API and kept up to date. Get started with Jentic One, the self-hosted execution layer.

### What authentication does the Nuix RESTful API use?

The spec lists two schemes: HTTP basic auth and HTTP bearer token. Most production deployments use bearer tokens issued by the Nuix server. Through Jentic the bearer token is stored encrypted in the vault and injected at execution time.

### Can I tag items in a case through the API?

Yes. POST `/cases/{caseId}/items/{itemId}/tags` adds a tag and DELETE on the same path removes it. Use GET `/cases/{caseId}/tags` to list every tag currently in use across the case for QC and reporting.

### How do I trigger evidence processing through Jentic?

Search Jentic for 'start Nuix processing job', load the schema for POST `/cases/{caseId}/process`, and execute with the case ID and evidence source. Jentic returns the job record so the agent can poll status downstream.

### What are the rate limits for the Nuix RESTful API?

Rate limits are not declared in the OpenAPI spec. Because Nuix runs on customer-managed infrastructure, throughput is bounded by the deployed server and worker capacity rather than a vendor quota. Tune your batching to match the server tier.

### How do I retrieve the text of a specific evidence item?

Call GET `/cases/{caseId}/items/{itemId}/text` with the case and item identifiers. The response returns the extracted text Nuix stored during processing, suitable for review or downstream classification by an agent.

### Can I limit what my agent is allowed to do with the Nuix RESTful API?

Yes. Jentic One runs self-hosted, so your own rules decide which Nuix operations and credentials the agent may use. Because Nuix puts the case and item ids in the URL path, such as `/cases/{caseId}/items/{itemId}/tags`, you can pin the agent to a single case and allow only searching and tagging within it. Since you choose the operations it may call, higher-impact actions like POST `/cases/{caseId}/process` and POST `/cases/{caseId}/export` stay off limits unless you explicitly add them.