Endpoints

CreateBoost will create a Boost setup which may be passed to any search.

Returns the dataset's persisted boost rules (server-side ranking rules applied when a search sets enableBoost). Config, not state-gated — available even when not Ready.

Replaces the dataset's boost rules (whole list). Each rule needs a name, at least one condition, and every condition must reference a Filterable field and be either a value match or a numeric range (not both).

Clears all boost rules for the dataset.

Downloads every document in the dataset as one JSON array, ordered by document key — the records as they were loaded, replaced or last updated, including fields that are not configured. Streams, so it works on a dataset of any size, and works whether the dataset is Ready, hibernated or idle-evicted. Any team member may export. Field configuration and boost rules are separate exports. `progress` is the console's: a token it counts the written records under, for its progress bar. Leave it out.

As Analyze but handles a stream as input text.

Analyze the fields of a string containing json. Since json may be invalid, which will cause a 400 error, it is sent as plain text.

Creates the data set (201). Idempotent: an existing data set is left exactly as it is and answers 200. There is no longer a `configuration` query parameter — there was one configuration to choose from, so choosing was theatre. Clients that still send `?configuration=400` (every published `@indxsearch/intrface` does) are unaffected: a query value that binds to nothing is ignored, which `UnknownQueryParameterTests` pins. Note the one behaviour change that comes with it — a garbage value used to be a validation 400 from enum binding and is now simply ignored, which is safe only because the value no longer reaches anything.

DeleteDataSet, will delete the entire dataSet including all contained Documents. Requires team Admin.

GetStatus will return the status of the dataSetName in the search engine.

Returns all datasets the current user can reach via team membership, across every team they belong to. Each entry carries the owning team name and the caller's role on it.

Lists the datasets owned by a single team.

IndexDataSet starts the index build and answers 202 with the status as it is then; the build goes on in the background. A Loaded dataset is indexed for the first time: poll GET status until `systemState` is Ready (a build that fails leaves the state it fell back to and `errorMessage`). A Ready dataset is rebuilt on a shadow engine and keeps serving meanwhile: poll until `shadowBuildInProgress` is false, then read `shadowBuildError`. Until Oct 2026 the request waited for the build.

Loads the jsonData into search engine from the database.

Loads the jsonData into search engine as a stream.

Atomically replaces the entire dataset's documents with the streamed JSON. Unlike delete+recreate this preserves the dataset's identity, field configuration, boost rules and description, serves the old data with zero downtime until the new index is ready, and leaves the old dataset untouched if the new JSON fails to build. Works whether the dataset is Ready, hibernated or idle-evicted (the old documents are never reloaded). Returns a summary of how the new schema differed from the previous field configuration.

Loads the jsonData into search engine as a string.

Hibernates the dataset: everything leaves memory while the documents stay in the store. The dataset reports Created with recordsOnDisk > 0 afterwards, and WakeUp — or, for a timed/pinned dataset, simply the next access — restores it.

Wakes a hibernated dataset — Created with records in the store — by reloading the documents from the store and rebuilding the index. The same operation the console's Wake button runs, so its progress shows there too.

Creates the films demo in the team: about 25,000 films from Wikidata, with their field roles set, loaded and indexed. Answers 201 with the dataset's name once it is Ready, which takes a few seconds. The name is "films", or "films-2" and on when the team has one.

Deletes a document from the dataset by its key.

Inserts one single Json record. The route key must match the document's key field (the engine keys documents from the body, so a disagreeing route would otherwise silently insert under a different key than the URL claims).

Updates one single Document. The route key must address an existing document and match the document's key field (the engine keys documents from the body, so a disagreeing route would otherwise silently update a different document than the URL claims).

Updates a single field on a document identified by its key.

Deletes documents from the dataset by their keys.

Inserts new JSON records into the dataset.

Updates existing JSON records in the dataset.

Returns the raw json records as string[] for the keys.

Returns the number of JSON records in the database for the given dataset.

Deletes all documents matching the given filter.

Updates a field on all documents matching the given filter. Returns the number of updated documents.

The user chose a result: the document, its 1-based position, and optionally the queryId from the search response's Indx-Query-Id header and a subject.

Something the customer considers valuable happened for a document: an order, an add-to-cart — the type is theirs. QueryId is optional; without it the conversion still counts on the document.

GetAllFields will return the fields found during analyze.

GetFacetableFields will return the array of facetable field names.

GetFilterableFields will return the array of filterable field names.

GetSearchableFields will return the array of searchable field names.

GetSortableFields will return the array of sortable field names.

GetWordIndexingFields will return the array of word-indexing field names.

GetEmbeddableFields will return the array of embeddable (vector) field names.

SetFieldConfiguration sets any combination of field properties (Searchable, Filterable, Facetable, Sortable, WordIndexing, Embeddable, PreloadFilters, Weight, BM25b, BM25k1) in one call. Nullable properties have replace semantics: null = leave untouched, any value (including false) = overwrite. The whole request is checked before anything is changed, and a refused one is a 400 that changes nothing. An accepted one answers in one of two ways. <b>204</b>: the change is applied, which is every change on a dataset that is not serving yet and a change of query-time roles on one that is. <b>202</b> with the status: the change needs the index rebuilt on a dataset that is Ready, so a rebuild on a shadow engine has been started and the dataset serves with the old configuration until it is swapped in. Poll GET status until `shadowBuildInProgress` is false, then read `shadowBuildError`: null means the new configuration is in use. Until Oct 2026 the request waited for the rebuild, minutes on a large dataset.

GetFieldConfiguration returns the full configuration of every field in the dataset. Search level, not Read: a filter panel needs each field's type to know whether a selected value is a value filter or a range with equal limits, and the name lists it reads today do not carry it. A Search key can already search and read documents, so the types and sample values here reveal nothing it does not see.

Returns the dataset's declared key field — the JSON field whose value identifies each document (the primary key). Empty string means none is declared (the engine auto-generates keys). Required, when set, to be a numeric field.

Declares the dataset's key field (the JSON field whose value is each document's primary key). Pass an empty string to clear it (auto-generated keys). The field must be numeric. The choice is preserved across reloads and applied on the next Load/replace; documents already loaded keep their existing keys until the data is reloaded.

CombineFilters will combine two filters using AND or OR operation.

NegateFilter returns a filter matching every document the given filter does not: the NOT of a value, range or combined filter. The result is a token like any other and can be combined further.

CreateRangeFilter will create a RangeFilter which may be passed to any search.

CreateValueFilter will create a ValueFilter which may be passed to any search. Case-insensitive unless `isCaseSensitive` is set; see Indx.Http.ValueFilterProxy for when it should be, and what it costs.

Deletes a single filter from the filter cache.

Deletes all filters from the filter cache.

Pre-loads all registered filters in the background.

Returns the number of filters currently registered in the filter cache.

Returns what the dataset sets (`parameters`, null where it sets nothing) and what a search that sends no coverage values runs with (`effective`, every value filled in). Config, not state-gated: available while the dataset is asleep. A search key may read it: it says how this dataset's searches run, and a search page shows it beside its own values.

Replaces the dataset's query parameters. A value left out (or null) is not set, and a search that leaves it out too gets the engine default. Applies from the next search; no reindex.

Clears the dataset's query parameters: searches get the engine defaults again.

Search will validate the search query and return the search result.

Searches a single embedding field using approximate nearest-neighbour search.

Combines text search with embedding nearest-neighbour search and blends scores.

What the dataset sets, what it runs with (the site description and fields after defaults), and whether this instance can run it at all (`available`: an API key is configured). A search key may read it: a search page needs to know whether to ask, and the thresholds.

Replaces the dataset's settings. Applies from the next call; no reindex.

Removes the dataset's settings: the feature is off and every value back to its default.

Whether this dataset has Search or ask (its Options tab): a team admin's switch. Experimental, so off by default; on, the dataset's tab and its visitor routes appear, and `enabled` in the settings then takes it live.

Judges what a visitor has typed so far: `p`, the probability they are asking for something an answer would serve, `answerable`, whether the results could answer it, and the `offer` those come to on their own. Call it on a typing pause, beside the search the page already ran. A judge that is slow or failing answers `p` 0 with a `reason`; it never fails the call. With `prefetch` true, call it while the visitor types as well, one call in flight at a time: the judge reads the text ahead of the pause and keeps its answer, so the pause's own call comes back from that at once. Only the pause's call is a judgement in the statistics.

A catalogue's description of what to list, as filters on the dataset's own fields: call it when intent's `criteria` reaches the strong threshold. Each filter is a value or a number range on a Filterable field, checked against the values the dataset holds; a text field also needs to be Facetable, which is where its values come from. `text` is what no filter covers, to search for.

Answers a question from the dataset's records, as server-sent events: `sources` (the records the answer may use, numbered), `text` (the answer as it is written, citing sources as [n]), then `done`; or `error` with a code. The answer uses those records and nothing else, and says so when they do not hold it.

What Search or ask did in the last `days` (today included, in the dataset's time zone): offers shown and taken, questions asked and how they ended, cited sources opened, and what it cost. `questions` lists the questions asked, the ones the content did not answer first; `offered` the texts an offer was shown beside (from the searches the page named), so a false offer can be found. Counted rows only, like every statistics read.

The window's totals and rates - the dashboard's header numbers. Rates are computed here so every consumer shares the definitions (see the response type).

The per-day series behind the charts: one row per UTC day in the window. Days without events are served as zero rows, so a chart never has holes.

Top queries in the window: searches, zero-hit count and selects per query text (lowercased). With uncoveredOnly=true, the searches without coverage: those coverage confirmed nothing for, how often a result was chosen anyway, and the document chosen most (mostChosenDocument), which is usually the synonym or spelling to add. order=lowestClickThrough lists the queries searched often and chosen from rarely (highestClickThrough the reverse; both leave out queries searched fewer than five times, where one click reads as 100%), and order=chosenAnyway with uncoveredOnly the fuzzy finds. With zeroHitsOnly=true, the zero-hit report — the searches the dataset could not answer, ordered by how often.

For one query (text, compared lowercased like the query list): which documents visitors chose from its results, most chosen first, with the position sum and the conversions from the same searches. A query searched often and chosen from rarely is either missing what people want or ranking it too low; which of the two, and whether the choices were the thing itself or a substitute, is read from this list. From the raw rows, so as far back as they are kept (90 days by default).

Browsing in the window: how often people narrowed by each filter value, with or without text, and how often that came back empty. A combined filter counts once per operand; a range counts by its field, with an empty value.

Top documents in the window: selects, converts and summed convert value per document key. The keys are the customer's own; titles are looked up by key.

The surfaces searches came from in the window, most searched first: each `?source=` with its searches, counted as the overview counts them, and a row with a null source for the searches that named none. From the raw rows (90 days by default).

One subject's lifetime top documents — the personalization read ("top 10 per user"). The subject is whatever the customer sent on the events.

The GDPR erasure of one subject: the subject↔document edge is deleted and the raw rows are anonymised, so aggregate counts stay true while nothing ties them to the subject any more.

What the dataset's owners changed in the window, oldest first, and the daily document totals: the why beside the numbers (Notes/statistics-design.md, "Change events").

The dataset's statistics settings. `recordFilters`: whether each search's filter is stored, which is what the Browsing report counts. On by default.

Changes the dataset's statistics settings; a property left out stays as it is. Switching `recordFilters` off stops recording filters; what is already recorded stays until it ages out or the statistics are erased. `labelField` names the field the statistics show beside a document key; `""` goes back to the first searchable field, and a field the dataset does not have is a 400. Team admin, Full key: a privacy setting sits here.

Deletes the dataset's statistics. Bare, every row: the explicit purge, since statistics survive dataset delete/recreate and starting clean is a choice made here. With `source` and/or `from`/`to` (UTC days, yyyy-MM-dd, inclusive), only the visitor events they select: the searches sent with that source or in those days, with their selects and conversions, so test traffic can go without the real history. The owners' changes and the subjects' lifetime top documents stay then. By source, days older than the raw rows' retention (90 by default) keep that surface's share.

Returns the dataset's synonym list, or a `null` body when it has none — always 200. The list widens every search on this dataset: a query word that matches an entry gets that entry's terms appended to the query text before scoring. One list per dataset — there is no name to supply, and no other dataset is affected.

Sets the dataset's synonym list, replacing any list it already had. Send a body of `null` to remove the list — the dataset then searches without synonyms again. Takes effect on the very next search: synonyms are applied to the query text, so nothing is re-indexed and the dataset does not have to be in any particular state. The list is stored with the dataset, so it survives a restart and follows the dataset if it is transferred to another team. Note that widening a query lowers Coverage scores in proportion to how much text is added — see the remarks on `Indx.Api.SynonymList`.

The full set, replacing the dataset's documents: a list of documents, or `{ "documents": [...] }`, signed like any call.

The sources a webhook can have, with their settings.

Makes a webhook for the dataset. The answer carries its address and its secret, which is shown only here: the sender authenticates each call with it, the way its source does. A dataset without documents yet is filled by the first full sync, which also gives it a key field; a webhook whose source Indx fetches from runs that sync at once.

The dataset's webhooks, with how many calls wait to be applied and how many batches the brake holds.