API Reference / API Methods / Dictionaries / Search dictionary entries

Nov. 12, 2020

Search Dictionary Entries

Required API Key:

Method signature

$client->searchDictionaryEntries(
  string dictionary,
  string query,
  // any params and/or requestOptions
);

client.search_dictionary_entries(
  string dictionary
  string query,
  # any params and/or requestOptions
)

client.searchDictionaryEntries(
  dictionary: DictionaryName,
  query: __string,
  requestOptions: RequestOptions
)

client.search_dictionary_entries(
  string dictionary
  string query,
  # + any requestOptions
)

client.searchDictionaryEntries<Dictionary: CustomDictionary>(
  in dictionary: Dictionary.Type,
  query: DictionaryQuery // includes params,
  requestOptions: RequestOptions? = nil
)

client.searchDictionaryEntries(
    dictionary: Dictionary<T>,
    query: Query,
    requestOptions: RequestOptions? = null
)

Not implemented yet.

dictionaryClient.SearchDictionaryEntries(
  AlgoliaDictionary algoliaDictionary,
  Query query,
  RequestOptions requestOptions
);

client.searchDictionaryEntries(
  Dictionary dictionary,
  Query query,
  RequestOptions requestOptions
)

client.SearchDictionaryEntries(
  dictionary DictionaryName,
  query string,
  opts ...interface{}
)

search into dictionary query query

See code examples

About this method

You are currently reading the JavaScript API client v4 documentation. Check our migration guide to learn how to upgrade from v3 to v4. You can still access the v3 documentation.

You are currently reading the Ruby API client v2 documentation. Check our migration guide to learn how to upgrade from v1 to v2. You can still access the v1 documentation.

Search for entries in a given dictionary

Examples

Search stopword entries

Copy

1
2
3
4
$client->searchDictionaryEntries('stopwords', 'und');
$client->searchDictionaryEntries('stopwords', 'und',
  array('language' => 'de')
);

1
2
3
4
5
6
7
8
let query = DictionaryQuery(query: "und")
  .set(\.language, to: .german)

client.searchDictionaryEntries(in: StopwordsDictionary.self, query: query) { result in
  if case .success(let response) = result {
    print("Response: \(response)")
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
Query query = new Query("und") { QueryLanguages = new List<String>() { "de"} };

AlgoliaDictionary algoliaDictionary = new AlgoliaDictionary
{
  Name = AlgoliaDictionaryType.Stopwords
};

// Synchronous
DictionaryClient.SearchDictionaryEntries<String>(algoliaDictionary, query);

// Asynchronous
var SearchDictionaryResponse = await DictionaryClient.SearchDictionaryEntriesAsync<string>(algoliaDictionary, query);

1
2
3
4
5
Query query = new Query("und").setQueryLanguages(Collections.singletonList("de"));
// Synchronous
client.searchDictionaryEntries(Dictionary.STOPWORDS, query);
// Asynchronous
client.searchDictionaryEntriesAsync(Dictionary.STOPWORDS, query);

1
2
3
4
5
6
7
val response = client.searchDictionaryEntries(
    dictionary = Dictionary.Stopwords,
    query = Query("und", queryLanguages = listOf(Language.Dutch)))
// or using extension function:
val response = client.searchStopwordEntries(
    query = Query("und", queryLanguages = listOf(Language.Dutch))
)

Parameters

`dictionary`	type: string Required Type of the dictionary entries you want to search. Can be either `stopword`, `plural` or `compound`
`query`	type: string Required Term to search in the dictionary. st
`params`	type: dictionary_search_parameter Optional Structure containing specific dictionary_search_parameter
`requestOptions`	type: key-value mapping default: No request options Optional A mapping of `requestOptions` to send along with the request.

dictionary_search_parameter

`page`	type: integer default: 0 Optional Page to fetch.
`hitsPerPage`	type: integer default: 0 Optional Number of hits retrieved per page. Accepted range: [1, 1000].
`language`	type: string Optional Language ISO code supported by the dictionary (for example “en” for English).

Response

In this section we document the JSON response returned by the API. Each language will encapsulate this response inside objects specific to the language and/or the implementation. So the actual type in your language might differ from what is documented.

JSON format

Copy
{
  "hits": [
    {
      "objectID": "under",
      "language": "en",
      "word": "under",
      "type": "custom"
    },
    {
      // ...
    }
  ],
  "nbHits": 2,
  "page": 0
  "nbPages": 1
}

`hits`	list of stopword_entry\|plural_entry\|compound_entry An array of dictionary entries. Can contain either a list of stopword_entry, plural_entry or compound_entry.
`nbHits`	integer Number of entries matching the query.
`page`	integer Returned page number (zero-based).
`nbPages`	integer Total number of pages.

dictionary_entry ➔ stopword_entry

`objectID`	string Unique identifier of the entry.
`language`	string Language ISO code supported by the dictionary (for example “en” for English).
`word`	string The stopword you want to add or update. When `word` already exists in the standard dictionary provided by Algolia, the entry can be overridden by the one provided by the user.
`state`	string The state of the entry: `enabled`: enable the current stopword `disabled`: disable the current stopword
`type`	string Set to “standard” if it’s a default Algolia entry. Otherwise set to “custom”.

dictionary_entry ➔ plural_entry

`objectID`	string Unique identifier of the entry.
`language`	string Language ISO code supported by the dictionary (for example “en” for English).
`words`	string Required List of word declensions. The entry overrides existing entries when any of these words exist in the standard dictionary provided by Algolia.
`type`	string Set to “standard” if it’s a default Algolia entry. Otherwise set to “custom”.

dictionary_entry ➔ compound_entry

`objectID`	string Unique identifier of the entry.
`language`	string Language ISO code supported by the dictionary (for example `de` for German).
`word`	string When `decomposition` is empty: adds `word` as a compound atom. For example, atom “kino” decomposes the query “kopfkino” into “kopf” and “kino”. When `decomposition` isn’t empty: creates a decomposition exception. For example, when `decomposition` is set to `["hund", "hutte"]`exception “hundehutte” decomposes the word into “hund” and “hutte”, discarding the linking morpheme “e”.
`decomposition`	string array When empty, the key `word` is considered as a compound atom. Otherwise, it’s the decomposition of `word`.
`type`	string Set to “standard” if it’s a default Algolia entry. Otherwise set to “custom”.

Building Search UI

Building Search UI

Building Search UI

Building Search UI

Building Search UI

Building Search UI

PHP

Ruby

JavaScript

Python

Swift

Kotlin

Android

.NET

Java

Golang

Scala

InstantSearch.js

React InstantSearch

Vue InstantSearch

Angular InstantSearch

InstantSearch iOS

InstantSearch Android

Autocomplete

Crawler Configuration API

Index settings and search parameters

A full reference of API Endpoints

Rails

Symfony

Django

Laravel

Crawler

Magento 2

WordPress

Shopify

Salesforce Commerce Cloud B2C

Netlify

Search Dictionary Entries

About this method

Examples

Search stopword entries

Parameters

dictionary_search_parameter

Response

JSON format

dictionary_entry ➔ stopword_entry

dictionary_entry ➔ plural_entry

dictionary_entry ➔ compound_entry

Did you find this page helpful?

On this page