Settings

The /settings route allows you to customize search settings for the given index. You can either modify all of an index's settings at once using the update settings endpoint, or modify each one individually using the child routes.

For a conceptual overview of index settings, refer to our indexes guide.

Settings object

By default, the settings object looks like this. All fields are modifiable.

{
  "displayedAttributes": [
    "*"
  ],
  "searchableAttributes": [
    "*"
  ],
  "filterableAttributes": [],
  "sortableAttributes": [],
  "rankingRules":
  [
    "words",
    "typo",
    "proximity",
    "attribute",
    "sort",
    "exactness"
  ],
  "stopWords": [],
  "synonyms": {},
  "distinctAttribute": null,
  "typoTolerance": {
    "enabled": true,
    "minWordSizeForTypos": {
      "oneTypo": 5,
      "twoTypos": 9
    },
    "disableOnWords": [],
    "disableOnAttributes": []
  },
  "faceting": {
    "maxValuesPerFacet": 100
  },
  "pagination": {
    "maxTotalHits": 1000
  }
}

All settings

This route allows you to retrieve, configure, or reset all of an index's settings at once.

Get settings

GET

/indexes/{index_uid}/settings

Get the settings of an index.

Path parameters

Name	Type	Description
index_uid *	String	uid of the requested index

Example

curl \
  -X GET 'http://localhost:7700/indexes/movies/settings'

client.index('movies').getSettings()

client.index('movies').get_settings()

$client->index('movies')->getSettings();

client.index("movies").getSettings();

client.index('movies').settings

client.Index("movies").GetSettings()

await client.Index("movies").GetSettingsAsync();

let settings: Settings = client
  .index("movies")
  .get_settings()
  .await
  .unwrap();

client.index("movies").getSettings { (result) in
    switch result {
    case .success(let setting):
        print(setting)
    case .failure(let error):
        print(error)
    }
}

await client.index('movies').getSettings();

Response: 200 Ok

{
  "displayedAttributes": [
    "*"
  ],
  "searchableAttributes": [
    "*"
  ],
  "filterableAttributes": [],
  "sortableAttributes": [],
  "rankingRules":
  [
    "words",
    "typo",
    "proximity",
    "attribute",
    "sort",
    "exactness"
  ],
  "stopWords": [],
  "synonyms": {},
  "distinctAttribute": null,
  "typoTolerance": {
    "enabled": true,
    "minWordSizeForTypos": {
      "oneTypo": 5,
      "twoTypos": 9
    },
    "disableOnWords": [],
    "disableOnAttributes": []
  },
  "faceting": {
    "maxValuesPerFacet": 100
  },
  "pagination": {
    "maxTotalHits": 1000
  }
}

Update settings

PATCH

/indexes/{index_uid}/settings

Update the settings of an index.

Passing null to an index setting will reset it to its default value.

Updates in the settings route are partial. This means that any parameters not provided in the body will be left unchanged.

If the provided index does not exist, it will be created.

Path parameters

Name	Type	Description
index_uid *	String	uid of the requested index

Body

Name	Type	Default value	Description
displayedAttributes	Array of strings	All attributes: ["*"]	Fields displayed in the returned documents
distinctAttribute	String	null	Search returns documents with distinct (different) values of the given field
faceting	Object	Default object	Faceting settings
filterableAttributes	Array of strings	Empty	Attributes to use as filters and facets
pagination	Object	Default object	Pagination settings
rankingRules	Array of strings	["words", "typo", "proximity", "attribute", "sort", "exactness"]	List of ranking rules in order of importance
searchableAttributes	Array of strings	All attributes: ["*"]	Fields in which to search for matching query words sorted by order of importance
sortableAttributes	Array of strings	Empty	Attributes to use when sorting search results
stopWords	Array of strings	Empty	List of words ignored by Meilisearch when present in search queries
synonyms	Object	Empty	List of associated words treated similarly
typoTolerance	Object	Default object	Typo tolerance settings

Example

curl \
  -X PATCH 'http://localhost:7700/indexes/movies/settings' \
  -H 'Content-Type: application/json' \
  --data-binary '{
    "rankingRules": [
      "words",
      "typo",
      "proximity",
      "attribute",
      "sort",
      "exactness",
      "release_date:desc",
      "rank:desc"
    ],
    "distinctAttribute": "movie_id",
    "searchableAttributes": [
      "title",
      "overview",
      "genres"
    ],
    "displayedAttributes": [
      "title",
      "overview",
      "genres",
      "release_date"
    ],
    "stopWords": [
      "the",
      "a",
      "an"
    ],
    "sortableAttributes": [
      "title",
      "release_date"
    ],
    "synonyms": {
      "wolverine": [
        "xmen",
        "logan"
    ],
      "logan": ["wolverine"]
    },
    "typoTolerance": {
      "minWordSizeForTypos": {
        "oneTypo": 8,
        "twoTypos": 10
      },
      "disableOnAttributes": ["title"]
    },
    "pagination": {
      "maxTotalHits": 5000
    },
    "faceting": {
      "maxValuesPerFacet": 200
    }
  }'

client.index('movies').updateSettings({
    rankingRules: [
        'words',
        'typo',
        'proximity',
        'attribute',
        'sort',
        'exactness',
        'release_date:desc',
        'rank:desc'
    ],
    distinctAttribute: 'movie_id',
    searchableAttributes: [
        'title',
        'overview',
        'genres'
    ],
    displayedAttributes: [
        'title',
        'overview',
        'genres',
        'release_date'
    ],
    stopWords: [
        'the',
        'a',
        'an'
    ],
    sortableAttributes: [
      'title',
      'release_date'
    ],
    synonyms: {
        'wolverine': ['xmen', 'logan'],
        'logan': ['wolverine']
    },
    typoTolerance: {
        'minWordSizeForTypos': {
            'oneTypo': 8,
            'twoTypos': 10
        },
        'disableOnAttributes': [
            'title'
        ]
    },
    pagination: {
        maxTotalHits: 5000
    },
    faceting: {
        maxValuesPerFacet: 200
    }
})

client.index('movies').update_settings({
  'rankingRules': [
    'words',
    'typo',
    'proximity',
    'attribute',
    'sort',
    'exactness',
    'release_date:desc',
    'rank:desc'
  ],
  'distinctAttribute': 'movie_id',
  'searchableAttributes': [
    'title',
    'overview',
    'genres'
  ],
  'displayedAttributes': [
    'title',
    'overview',
    'genres',
    'release_date'
  ],
  'sortableAttributes': [
    'title',
    'release_date'
  ],
  'stopWords': [
    'the',
    'a',
    'an'
  ],
  'synonyms': {
    'wolverine': ['xmen', 'logan'],
    'logan': ['wolverine']
  },
  'typoTolerance': {
    'minWordSizeForTypos': {
        'oneTypo': 8,
        'twoTypos': 10
    },
    'disableOnAttributes': ['title']
  },
  'pagination': {
    'maxTotalHits': 5000
  },
  'faceting': {
    'maxValuesPerFacet': 200
  }
})

$client->index('movies')->updateSettings([
  'rankingRules' => [
    'words',
    'typo',
    'proximity',
    'attribute',
    'sort',
    'exactness',
    'release_date:desc',
    'rank:desc'
  ],
  'distinctAttribute' => 'movie_id',
  'searchableAttributes' => [
    'title',
    'overview',
    'genres'
  ],
  'displayedAttributes' => [
    'title',
    'overview',
    'genres',
    'release_date'
  ],
  'stopWords' => [
    'the',
    'a',
    'an'
  ],
  'sortableAttributes' => [
    'title',
    'release_date'
  ],
  'synonyms' => [
    'wolverine' => ['xmen', 'logan'],
    'logan' => ['wolverine']
  ],
  'typoTolerance' => [
      'minWordSizeForTypos' => [
        'oneTypo' => 8,
        'twoTypos' => 10
      ],
      'disableOnAttributes' => ['title']
  ],
  'pagination' => [
    'maxTotalHits' => 5000
  ],
  'faceting' => [
    'maxValuesPerFacet' => 200
  ]
]);

Settings settings = new Settings();
settings.setRankingRules(
  new String[] {
      "words",
      "typo",
      "proximity",
      "attribute",
      "sort",
      "exactness",
      "release_date:desc",
      "rank:desc"
  });
settings.setDistinctAttribute("movie_id");
settings.setSearchableAttributes(
  new String[] {
    "title",
    "overview",
    "genres"
  });
settings.setDisplayedAttributes(
  new String[] {
    "title",
    "overview",
    "genres",
    "release_date"
  });
settings.setStopWords(
  new String[] {
    "the",
    "a",
    "an"
  });
settings.setSortableAttributes(
  new String[] {
    "title",
    "release_date"
  });

HashMap<String, String[]> synonyms = new HashMap<String, String[]>();
synonyms.put("wolverine", new String[] {"xmen", "logan"});
synonyms.put("logan", new String[] {"wolverine"});
settings.setSynonyms(synonyms);

HashMap<String, Integer> minWordSizeTypos =
  new HashMap<String, Integer>() {
    {
      put("oneTypo", 8);
      put("twoTypos", 10);
    }
  };
TypoTolerance typoTolerance = new TypoTolerance();
typoTolerance.setMinWordSizeForTypos(minWordSizeTypos);
settings.setTypoTolerance(typoTolerance);

client.index("movies").updateSettings(settings);

client.index('movies').update_settings({
  ranking_rules: [
    'words',
    'typo',
    'proximity',
    'attribute',
    'sort',
    'exactness',
    'release_date:desc',
    'rank:desc'
  ],
  distinct_attribute: 'movie_id',
  searchable_attributes: [
    'title',
    'overview',
    'genres'
  ],
  displayed_attributes: [
    'title',
    'overview',
    'genres',
    'release_date'
  ],
  stop_words: [
    'the',
    'a',
    'an'
  ],
  sortable_attributes: [
    'title',
    'release_date'
  ],
  synonyms: {
    wolverine: ['xmen', 'logan'],
    logan: ['wolverine']
  },
  pagination: {
    max_total_hits: 5000
  },
  faceting: {
    max_values_per_facet: 200
  }
})

distinctAttribute := "movie_id"
settings := meilisearch.Settings{
  RankingRules: []string{
    "words",
    "typo",
    "proximity",
    "attribute",
    "sort",
    "exactness",
    "release_date:desc",
    "rank:desc",
  },
  DistinctAttribute: &distinctAttribute,
  SearchableAttributes: []string{
    "title",
    "overview",
    "genres",
  },
  DisplayedAttributes: []string{
    "title",
    "overview",
    "genres",
    "release_date",
  },
  StopWords: []string{
    "the",
    "a",
    "an",
  },
  SortableAttributes: []string{
    "title",
    "release_date",
  },
  Synonyms: map[string][]string{
    "wolverine": []string{"xmen", "logan"},
    "logan":     []string{"wolverine"},
  },
  TypoTolerance: &meilisearch.TypoTolerance{
    MinWordSizeForTypos: meilisearch.MinWordSizeForTypos{
      OneTypo:  8,
      TwoTypos: 10,
    },
    DisableOnAttributes: []string{"title"},
  },
  Pagination: &meilisearch.Pagination{
    MaxTotalHits: 5000,
  },
  Faceting: &meilisearch.Faceting{
    MaxValuesPerFacet: 200,
  },
}
client.Index("movies").UpdateSettings(&settings)

Settings newSettings = new Settings
{
  RankingRules = new string[]
  {
    "words",
    "typo",
    "proximity",
    "attribute",
    "sort",
    "exactness",
    "release_date:desc",
    "rank:desc"
  },
  DistinctAttribute = "movie_id",
  SearchableAttributes = new string[] { "title", "overview", "genres" },
  DisplayedAttributes = new string[] { "title", "overview", "genres", "release_date" },
  SortableAttributes = new string[] { "title", "release_date" },
  StopWords = new string[] { "the", "a", "an" },
  Synonyms = new Dictionary<string, IEnumerable<string>>
  {
    { "wolverine", new string[] { "xmen", "logan" } },
    { "logan", new string[] { "wolverine" } },
  },
  FilterableAttributes = new string[] { },
  TypoTolerance = new TypoTolerance
  {
      DisableOnAttributes = new string[] { "title" },
      MinWordSizeForTypos = new TypoTolerance.TypoSize
      {
          OneTypo = 8,
          TwoTypos = 10
      }
  }
};
TaskInfo task = await client.Index("movies").UpdateSettingsAsync(newFilters);

let mut synonyms = std::collections::HashMap::new();
synonyms.insert(String::from("wolverine"), vec!["xmen", "logan"]);
synonyms.insert(String::from("logan"), vec!["wolverine"]);

let settings = Settings::new()
  .with_ranking_rules([
    "words",
    "typo",
    "proximity",
    "attribute",
    "sort",
    "exactness",
    "release_date:desc",
    "rank:desc"
  ])
  .with_distinct_attribute("movie_id")
  .with_searchable_attributes([
    "title",
    "overview",
    "genres"
  ])
  .with_displayed_attributes([
    "title",
    "overview",
    "genres",
    "release_date"
  ])
  .with_stop_words([
    "the",
    "a",
    "an"
  ])
  .with_sortable_attributes([
    "title",
    "release_date"
  ])
  .with_synonyms(synonyms);

let task: TaskInfo = client
  .index("movies")
  .set_settings(&settings)
  .await
  .unwrap();

let settings = Setting(rankingRules: [
    "words",
    "typo",
    "proximity",
    "attribute",
    "sort",
    "exactness",
    "release_date:desc",
    "rank:desc"
], searchableAttributes: [
    "title",
    "overview",
    "genres"
], displayedAttributes: [
    "title",
    "overview",
    "genres",
    "release_date"
], stopWords: [
    "the",
    "a",
    "an"
], synonyms: [
    "wolverine": ["xmen", "logan"],
    "logan": ["wolverine"]
], distinctAttribute: "movie_id",
sortableAttributes: [
    "title",
    "release_date"
])
client.index("movies").updateSettings(settings) { (result) in
    switch result {
    case .success(let task):
        print(task)
    case .failure(let error):
        print(error)
    }
}

await client.index('movies').updateSettings(IndexSettings(
      rankingRules: [
        'words',
        'typo',
        'proximity',
        'attribute',
        'sort',
        'exactness',
        'release_date:desc',
        'rank:desc'
      ],
      distinctAttribute: 'movie_id',
      searchableAttributes: ['title', 'overview', 'genres'],
      displayedAttributes: ['title', 'overview', 'genres', 'release_date'],
      stopWords: ['the', 'a', 'an'],
      sortableAttributes: ['title', 'release_date'],
      synonyms: {
        'wolverine': ['xmen', 'logan'],
        'logan': ['wolverine'],
      },
    ));

Response: 202 Accepted

{
  "taskUid": 1,
  "indexUid": "movies",
  "status": "enqueued",
  "type": "settingsUpdate",
  "enqueuedAt": "2021-08-11T09:25:53.000000Z"
}

You can use this taskUid to get more details on the status of the task.

Reset settings

DELETE

/indexes/{index_uid}/settings

Reset all the settings of an index to their default value.

Path parameters

Name	Type	Description
index_uid *	String	uid of the requested index

Example

curl \
  -X DELETE 'http://localhost:7700/indexes/movies/settings'

client.index('movies').resetSettings()

client.index('movies').reset_settings()

$client->index('movies')->resetSettings();

client.index("movies").resetSettings();

client.index('movies').reset_settings

client.Index("movies").ResetSettings()

await client.Index("movies").ResetSettingsAsync();

let task: TaskInfo = client
  .index("movies")
  .reset_settings()
  .await
  .unwrap();

client.index("movies").resetSettings { (result) in
    switch result {
    case .success(let task):
        print(task)
    case .failure(let error):
        print(error)
    }
}

await client.index('movies').resetSettings();

Response: 202 Accepted

{
  "taskUid": 1,
  "indexUid": "movies",
  "status": "enqueued",
  "type": "settingsUpdate",
  "enqueuedAt": "2021-08-11T09:25:53.000000Z"
}

You can use this taskUid to get more details on the status of the task.

Displayed attributes

The attributes added to the displayedAttributes list appear in search results. displayedAttributes only affects the search endpoints. It has no impact on the GET documents endpoint.

By default, the displayedAttributes array is equal to all fields in your dataset. This behavior is represented by the value ["*"].

To learn more about displayed attributes, refer to our dedicated guide.

Get displayed attributes

GET

/indexes/{index_uid}/settings/displayed-attributes

Get the displayed attributes of an index.

Path parameters

Name	Type	Description
index_uid *	String	uid of the requested index

Example

curl \
  -X GET 'http://localhost:7700/indexes/movies/settings/displayed-attributes'

client.index('movies').getDisplayedAttributes()

client.index('movies').get_displayed_attributes()

$client->index('movies')->getDisplayedAttributes();

client.index("movies").getDisplayedAttributesSettings();

client.index('movies').get_displayed_attributes

client.Index("movies").GetDisplayedAttributes()

await client.Index("movies").GetDisplayedAttributesAsync();

let displayed_attributes: Vec<String> = client
  .index("movies")
  .get_displayed_attributes()
  .await
  .unwrap();

client.index("movies").getDisplayedAttributes { (result) in
    switch result {
    case .success(let displayedAttributes):
        print(displayedAttributes)
    case .failure(let error):
        print(error)
    }
}

await client.index('movies').getDisplayedAttributes();

Response: 200 Ok

[
  "title",
  "overview",
  "genres",
  "release_date.year"
]

Update displayed attributes

PUT

/indexes/{index_uid}/settings/displayed-attributes

Update the displayed attributes of an index.

Path parameters

Name	Type	Description
index_uid *	String	uid of the requested index

Body

[<String>, <String>, …]

An array of strings. Each string should be an attribute that exists in the selected index.

If an attribute contains an object, you can use dot notation to specify one or more of its keys, for example, "displayedAttributes": ["release_date.year"].

WARNING

If the field does not exist, no error will be thrown.

Example

curl \
  -X PUT 'http://localhost:7700/indexes/movies/settings/displayed-attributes' \
  -H 'Content-Type: application/json' \
  --data-binary '[
    "title",
    "overview",
    "genres",
    "release_date"
  ]'

client.index('movies').updateDisplayedAttributes([
  'title',
  'overview',
  'genres',
  'release_date'
])

client.index('movies').update_displayed_attributes([
    'title',
    'overview',
    'genres',
    'release_date'
])

$client->index('movies')->updateDisplayedAttributes([
  'title',
  'overview',
  'genres',
  'release_date'
]);

client.index("movies").updateDisplayedAttributesSettings(new String[]
{
  "title",
  "overview",
  "genres",
  "release_date"
});

client.index('movies').update_displayed_attributes([
  'title',
  'overview',
  'genres',
  'release_date'
])

displayedAttributes := []string{
  "title",
  "overview",
  "genres",
  "release_date",
}
client.Index("movies").UpdateDisplayedAttributes(&displayedAttributes)

await client.Index("movies").UpdateDisplayedAttributesAsync(new[]
{
  "title",
  "overview",
  "genres",
  "release_date"
});

let displayed_attributes = [
  "title",
  "overview",
  "genres",
  "release_date"
];

let task: TaskInfo = client
  .index("movies")
  .set_displayed_attributes(&displayed_attributes)
  .await
  .unwrap();

let displayedAttributes: [String] = ["title", "overview", "genres", "release_date"]
client.index("movies").updateDisplayedAttributes(displayedAttributes) { (result) in
    switch result {
    case .success(let task):
        print(task)
    case .failure(let error):
        print(error)
    }
}

await client.index('movies').updateDisplayedAttributes([
  'title',
  'overview',
  'genres',
  'release_date'
]);

Response: 202 Accepted

{
  "taskUid": 1,
  "indexUid": "movies",
  "status": "enqueued",
  "type": "settingsUpdate",
  "enqueuedAt": "2021-08-11T09:25:53.000000Z"
}

You can use this taskUid to get more details on the status of the task.

Reset displayed attributes

DELETE

/indexes/{index_uid}/settings/displayed-attributes

Reset the displayed attributes of the index to the default value.

Path parameters

Name	Type	Description
index_uid *	String	uid of the requested index

Example

curl \
  -X DELETE 'http://localhost:7700/indexes/movies/settings/displayed-attributes'

client.index('movies').resetDisplayedAttributes()

client.index('movies').reset_displayed_attributes()

$client->index('movies')->resetDisplayedAttributes();

client.index("movies").resetDisplayedAttributesSettings();

client.index('movies').reset_displayed_attributes

client.Index("movies").ResetDisplayedAttributes()

await client.Index("movies").ResetDisplayedAttributesAsync();

let task: TaskInfo = client
  .index("movies")
  .reset_displayed_attributes()
  .await
  .unwrap();

client.index("movies").resetDisplayedAttributes { (result) in
    switch result {
    case .success(let task):
        print(task)
    case .failure(let error):
        print(error)
    }
}

await client.index('movies').resetDisplayedAttributes();

Response: 202 Accepted

{
  "taskUid": 1,
  "indexUid": "movies",
  "status": "enqueued",
  "type": "settingsUpdate",
  "enqueuedAt": "2021-08-11T09:25:53.000000Z"
}

You can use this taskUid to get more details on the status of the task.

Distinct attribute

The distinct attribute is a field whose value will always be unique in the returned documents.

WARNING

Updating distinct attributes will re-index all documents in the index, which can take some time. We recommend updating your index settings first and then adding documents as this reduces RAM consumption.

To learn more about the distinct attribute, refer to our dedicated guide.

Get distinct attribute

GET

/indexes/{index_uid}/settings/distinct-attribute

Get the distinct attribute of an index.

Path parameters

Name	Type	Description
index_uid *	String	uid of the requested index

Example

curl \
  -X GET 'http://localhost:7700/indexes/shoes/settings/distinct-attribute'

client.index('shoes').getDistinctAttribute()

client.index('shoes').get_distinct_attribute()

$client->index('shoes')->getDistinctAttribute();

client.index("shoes").getDistinctAttributeSettings();

client.index('shoes').distinct_attribute

client.Index("shoes").GetDistinctAttribute()

string result = await client.Index("shoes").GetDistinctAttributeAsync();

let distinct_attribute: Option<String> = client
  .index("shoes")
  .get_distinct_attribute()
  .await
  .unwrap();

client.index("shoes").getDistinctAttribute { (result) in
    switch result {
    case .success(let distinctAttribute):
        print(distinctAttribute)
    case .failure(let error):
        print(error)
    }
}

await client.index('shoes').getDistinctAttribute();

Response: 200 Ok

"skuid"

Update distinct attribute

PUT

/indexes/{index_uid}/settings/distinct-attribute

Update the distinct attribute field of an index.

Path parameters

Name	Type	Description
index_uid *	String	uid of the requested index

Body

<String>

A string. The string should be an attribute that exists in the selected index.

If an attribute contains an object, you can use dot notation to set one or more of its keys as a value for this setting, for example, "distinctAttribute": "product.skuid".

WARNING

If the field does not exist, no error will be thrown.

To learn more about the distinct attribute, refer to our dedicated guide.

Example

curl \
  -X PUT 'http://localhost:7700/indexes/shoes/settings/distinct-attribute' \
  -H 'Content-Type: application/json' \
  --data-binary '"skuid"'

client.index('shoes').updateDistinctAttribute('skuid')

client.index('shoes').update_distinct_attribute('skuid')

$client->index('shoes')->updateDistinctAttribute('skuid');

client.index("shoes").updateDistinctAttributeSettings("skuid");

client.index('shoes').update_distinct_attribute('skuid')

client.Index("shoes").UpdateDistinctAttribute("skuid")

TaskInfo result = await client.Index("shoes").UpdateDistinctAttributeAsync("skuid");

let task: TaskInfo = client
  .index("shoes")
  .set_distinct_attribute("skuid")
  .await
  .unwrap();

client.index("shoes").updateDistinctAttribute("skuid") { (result) in
    switch result {
    case .success(let task):
        print(task)
    case .failure(let error):
        print(error)
    }
}

await client.index('shoes').updateDistinctAttribute('skuid');

Response: 202 Accepted

{
  "taskUid": 1,
  "indexUid": "movies",
  "status": "enqueued",
  "type": "settingsUpdate",
  "enqueuedAt": "2021-08-11T09:25:53.000000Z"
}

You can use this taskUid to get more details on the status of the task.

Reset distinct attribute

DELETE

/indexes/{index_uid}/settings/distinct-attribute

Reset the distinct attribute of an index to its default value.

Path parameters

Name	Type	Description
index_uid *	String	uid of the requested index

Example

curl \
  -X DELETE 'http://localhost:7700/indexes/shoes/settings/distinct-attribute'

client.index('shoes').resetDistinctAttribute()

client.index('shoes').reset_distinct_attribute()

$client->index('shoes')->resetDistinctAttribute();

client.index("shoes").resetDistinctAttributeSettings();

client.index('shoes').reset_distinct_attribute

client.Index("shoes").ResetDistinctAttribute()

TaskInfo result = await client.Index("shoes").ResetDistinctAttributeAsync();

let task: TaskInfo = client
  .index("shoes")
  .reset_distinct_attribute()
  .await
  .unwrap();

client.index("shoes").resetDistinctAttribute { (result) in
    switch result {
    case .success(let task):
        print(task)
    case .failure(let error):
        print(error)
    }
}

await client.index('shoes').resetDistinctAttribute();

Response: 202 Accepted

{
  "taskUid": 1,
  "indexUid": "movies",
  "status": "enqueued",
  "type": "settingsUpdate",
  "enqueuedAt": "2021-08-11T09:25:53.000000Z"
}

You can use this taskUid to get more details on the status of the task.

Faceting

With Meilisearch, you can create faceted search interfaces. This setting allows you to define the maximum number of values returned by the facets search parameter.

To learn more about filtering and faceting, refer to our dedicated guide.

Faceting object

Name	Type	Default value	Description
maxValuesPerFacet	Integer	100	Maximum number of facet values returned for each facet. Values are sorted in ascending lexicographical order

Get faceting settings

GET

/indexes/{index_uid}/settings/faceting

Get the faceting settings of an index.

Path parameters

Name	Type	Description
index_uid *	String	uid of the requested index

Example

curl \
  -X GET 'http://localhost:7700/indexes/books/settings/faceting'

client.index('books').getFaceting()

$client->index('books')->getFaceting();

index('books').faceting

client.Index("books").GetFaceting()

await client.Index("movies").GetFacetingAsync();

let faceting: FacetingSettings = client
  .index("books")
  .get_faceting()
  .await
  .unwrap();

Response: 200 OK

{
  "maxValuesPerFacet": 100
}

Update faceting settings

PATCH

/indexes/{index_uid}/settings/faceting

Partially update the faceting settings for an index. Any parameters not provided in the body will be left unchanged.

Path parameters

Name	Type	Description
index_uid *	String	uid of the requested index

Body

{maxValuesPerFacet: <Integer>}

Name	Type	Default value	Description
maxValuesPerFacet	Integer	100	Maximum number of facet values returned for each facet. Values are sorted in ascending lexicographical order

For example, suppose a query's search results contain a total of three values for a colors facet: blue, green, and red. If you set maxValuesPerFacet to 2, Meilisearch will only return blue and green in the response body's facetDistribution object.

NOTE

Setting maxValuesPerFacet to a high value might negatively impact performance.

Example

curl \
  -X PATCH 'http://localhost:7700/indexes/books/settings/faceting' \
  -H 'Content-Type: application/json' \
  --data-binary '{
    "maxValuesPerFacet": 2
  }'

client.index('books').updateFaceting({ maxValuesPerFacet: 2 })

client.index('books').update_settings({
  'faceting': {
    'maxValuesPerFacet': 2
  }
})

$client->index('books')->updateFaceting([ 'maxValuesPerFacet' => 2 ]);

index('books').update_faceting({ max_values_per_facet: 2 })

client.Index("books").UpdateFaceting(&meilisearch.Faceting{
    MaxValuesPerFacet: 2,
})

var faceting = new Faceting {
  MaxValuesPerFacet = 2
};
await client.Index("movies").UpdateFacetingAsync(faceting);

let mut faceting = FacetingSettings {
  max_values_per_facet: 2,
};

let task: TaskInfo = client
  .index("books")
  .set_faceting(&faceting)
  .await
  .unwrap();

Response: 202 Accepted

{
  "taskUid": 1,
  "indexUid": "books",
  "status": "enqueued",
  "type": "settingsUpdate",
  "enqueuedAt": "2022-04-14T20:56:44.991039Z"
}

You can use the returned taskUid to get more details on the status of the task.

Reset faceting settings

Reset an index's faceting settings to their default value.

Path parameters

Name	Type	Description
index_uid *	String	uid of the requested index

Example

curl \
  -X DELETE 'http://localhost:7700/indexes/books/settings/faceting'

client.index('books').resetFaceting()

$client->index('books')->resetFaceting();

index('books').reset_faceting

client.Index("books").ResetFaceting()

await client.Index("movies").ResetFacetingAsync();

let task: TaskInfo = client
  .index("books")
  .reset_faceting()
  .await
  .unwrap();

Response: 200 OK

{
  "taskUid": 1,
  "indexUid": "books",
  "status": "enqueued",
  "type": "settingsUpdate",
  "enqueuedAt": "2022-04-14T20:53:32.863107Z"
}

You can use the returned taskUid to get more details on the status of the task.

Filterable attributes

Attributes in the filterableAttributes list can be used as filters or facets.

WARNING

Updating filterable attributes will re-index all documents in the index, which can take some time. We recommend updating your index settings first and then adding documents as this reduces RAM consumption.

To learn more about filterable attributes, refer to our dedicated guide.

Get filterable attributes

GET

/indexes/{index_uid}/settings/filterable-attributes

Get the filterable attributes for an index.

Path parameters

Name	Type	Description
index_uid *	String	uid of the requested index

Example

curl \
  -X GET 'http://localhost:7700/indexes/movies/settings/filterable-attributes'

client.index('movies').getFilterableAttributes()

client.index('movies').get_filterable_attributes()

$client->index('movies')->getFilterableAttributes();

client.index("movies").getFilterableAttributesSettings();

client.index('movies').filterable_attributes

client.Index("movies").GetFilterableAttributes()

IEnumerable<string> attributes = await client.Index("movies").GetFilterableAttributesAsync();

let filterable_attributes: Vec<String> = client
  .index("movies")
  .get_filterable_attributes()
  .await
  .unwrap();

client.index("movies").getFilterableAttributes { (result) in
    switch result {
    case .success(let attributes):
        print(attributes)
    case .failure(let error):
        print(error)
    }
}

await client.index('movies').getFilterableAttributes();

Response: 200 Ok

[
  "genres",
  "director",
  "release_date.year"
]

Update filterable attributes

PUT

/indexes/{index_uid}/settings/filterable-attributes

Update an index's filterable attributes list.

Path parameters

Name	Type	Description
index_uid *	String	uid of the requested index

Body

[<String>, <String>, …]

An array of strings containing the attributes that can be used as filters at query time.

If an attribute contains an object, you can use dot notation to set one or more of its keys as a value for this setting: "filterableAttributes": ["release_date.year"].

WARNING

If the field does not exist, no error will be thrown.

To learn more about filterable attributes, refer to our dedicated guide.

Example

curl \
  -X PUT 'http://localhost:7700/indexes/movies/settings/filterable-attributes' \
  -H 'Content-Type: application/json' \
  --data-binary '[
    "genres",
    "director"
  ]'

client.index('movies')
  .updateFilterableAttributes([
    'genres',
    'director'
  ])

client.index('movies').update_filterable_attributes([
  'genres',
  'director'
])

$client->index('movies')->updateFilterableAttributes([
  'genres',
  'director'
]);

Settings settings = new Settings();
settings.setFilterableAttributes(new String[] {"genres", "director"});
client.index("movies").updateSettings(settings);

client.index('movies').update_filterable_attributes([
  'genres',
  'director'
])

filterableAttributes := []string{
  "genres",
  "director",
}
client.Index("movies").UpdateFilterableAttributes(&filterableAttributes)

List<string> attributes = new() { "genres", "director" };
TaskInfo result = await client.Index("movies").UpdateFilterableAttributesAsync(attributes);

let filterable_attributes = [
  "genres",
  "director"
];

let task: TaskInfo = client
  .index("movies")
  .set_filterable_attributes(&filterable_attributes)
  .await
  .unwrap();

client.index("movies").updateFilterableAttributes(["genre", "director"]) { (result) in
    switch result {
    case .success(let task):
        print(task)
    case .failure(let error):
        print(error)
    }
}

await client.index('movies').updateFilterableAttributes([
  'genres',
  'director'
]);

Response: 202 Accepted

{
  "taskUid": 1,
  "indexUid": "movies",
  "status": "enqueued",
  "type": "settingsUpdate",
  "enqueuedAt": "2021-08-11T09:25:53.000000Z"
}

You can use this taskUid to get more details on the status of the task.

Reset filterable attributes

DELETE

/indexes/{index_uid}/settings/filterable-attributes

Reset an index's filterable attributes list back to its default value.

Path parameters

Name	Type	Description
index_uid *	String	uid of the requested index

Example

curl \
  -X DELETE 'http://localhost:7700/indexes/movies/settings/filterable-attributes'

client.index('movies').resetFilterableAttributes()

client.index('movies').reset_filterable_attributes()

$client->index('movies')->resetFilterableAttributes();

client.index("movies").resetFilterableAttributesSettings();

client.index('movies').reset_filterable_attributes

client.Index("movies").ResetFilterableAttributes()

TaskInfo result = await client.Index("movies").ResetFilterableAttributesAsync();

let task: TaskInfo = client
  .index("movies")
  .reset_filterable_attributes()
  .await
  .unwrap();

client.index("movies").resetFilterableAttributes { (result) in
    switch result {
    case .success(let attributes):
        print(attributes)
    case .failure(let error):
        print(error)
    }
}

await client.index('movies').resetFilterableAttributes();

Response: 202 Accepted

{
  "taskUid": 1,
  "indexUid": "movies",
  "status": "enqueued",
  "type": "settingsUpdate",
  "enqueuedAt": "2021-08-11T09:25:53.000000Z"
}

You can use this taskUid to get more details on the status of the task.

Pagination

To protect your database from malicious scraping, Meilisearch has a default limit of 1000 results per search. This setting allows you to configure the maximum number of results returned per search.

maxTotalHits takes priority over search parameters such as limit, offset, hitsPerPage, and page.

For example, if you set maxTotalHits to 100, you will not be able to access search results beyond 100 no matter the value configured for offset.

To learn more about paginating search results with Meilisearch, refer to our dedicated guide.

Pagination object

Name	Type	Default value	Description
maxTotalHits	Integer	1000	The maximum number of search results Meilisearch can return

Get pagination settings

GET

/indexes/{index_uid}/settings/pagination

Get the pagination settings of an index.

Path parameters

Name	Type	Description
index_uid *	String	uid of the requested index

Example

curl \
  -X GET 'http://localhost:7700/indexes/books/settings/pagination'

client.index('books').getPagination()

$client->index('books')->getPagination();

index('books').pagination

client.Index("books").GetPagination()

await client.Index("movies").GetPaginationAsync();

let pagination: PaginationSetting = client
  .index("books")
  .get_pagination()
  .await
  .unwrap();

Response: 200 OK

{
  "maxTotalHits": 1000
}

Update pagination settings

PATCH

/indexes/{index_uid}/settings/pagination

Partially update the pagination settings for an index.

Path parameters

Name	Type	Description
index_uid *	String	uid of the requested index

Body

{maxTotalHits: <Integer>}

Name	Type	Default value	Description
maxTotalHits	Integer	1000	The maximum number of search results Meilisearch can return

WARNING

Setting maxTotalHits to a value higher than the default will negatively impact search performance. Setting maxTotalHits to values over 20000 may result in queries taking seconds to complete.

Example

curl \
  -X PATCH 'http://localhost:7700/indexes/books/settings/pagination' \
  -H 'Content-Type: application/json' \
  --data-binary '{
    "maxTotalHits": 100
  }'

client.index('books').updateSettings({ pagination: { maxTotalHits: 100 }})

client.index('books').update_settings({
  'pagination': {
    'maxTotalHits': 100
  }
})

$client->index('books')->updateSettings([
  'pagination' => [
    'maxTotalHits' => 100
  ]
]);

index('books').update_pagination({ max_total_hits: 100 })

client.Index("books").UpdatePagination(&meilisearch.Pagination{
    MaxTotalHits: 100,
})

var pagination = new Pagination {
  MaxTotalHits = 20
};
await client.Index("movies").UpdatePaginationAsync(pagination);

let pagination = PaginationSetting {max_total_hits:100};

let task: TaskInfo = client
  .index("books")
  .set_pagination(pagination)
  .await
  .unwrap();

Response: 202 Accepted

{
  "taskUid": 1,
  "indexUid": "books",
  "status": "enqueued",
  "type": "settingsUpdate",
  "enqueuedAt": "2022-04-14T20:56:44.991039Z"
}

You can use the returned taskUid to get more details on the status of the task.

Reset pagination settings

Reset an index's pagination settings to their default value.

Path parameters

Name	Type	Description
index_uid *	String	uid of the requested index

Example

curl \
  -X DELETE 'http://localhost:7700/indexes/books/settings/pagination'

client.index('books').resetPagination()

$client->index('books')->resetPagination();

index('books').reset_pagination

client.Index("books").ResetPagination()

await client.Index("movies").ResetPaginationAsync();

let task: TaskInfo = client
  .index("books")
  .reset_pagination()
  .await
  .unwrap();

Response: 202 Accepted

{
  "taskUid": 1,
  "indexUid": "books",
  "status": "enqueued",
  "type": "settingsUpdate",
  "enqueuedAt": "2022-04-14T20:53:32.863107Z"
}

You can use the returned taskUid to get more details on the status of the task.

Ranking rules

Ranking rules are built-in rules that rank search results according to certain criteria. They are applied in the same order in which they appear in the rankingRules array.

To learn more about ranking rules, refer to our dedicated guide.

Ranking rules array

Name	Description
"words"	Sorts results by decreasing number of matched query terms
"typo"	Sorts results by increasing number of typos
"proximity"	Sorts results by increasing distance between matched query terms
"attribute"	Sorts results based on the attribute ranking order
"sort"	Sorts results based on parameters decided at query time
"exactness"	Sorts results based on the similarity of the matched words with the query words

Default order

[
  "words",
  "typo",
  "proximity",
  "attribute",
  "sort",
  "exactness"
]

Get ranking rules

GET

/indexes/{index_uid}/settings/ranking-rules

Get the ranking rules of an index.

Path parameters

Name	Type	Description
index_uid *	String	uid of the requested index

Example

curl \
  -X GET 'http://localhost:7700/indexes/movies/settings/ranking-rules'

client.index('movies').getRankingRules()

client.index('movies').get_ranking_rules()

$client->index('movies')->getRankingRules();

client.index("movies").getRankingRulesSettings();

client.index('movies').ranking_rules

client.Index("movies").GetRankingRules()

await client.Index("movies").GetRankingRulesAsync();

let ranking_rules: Vec<String> = client
  .index("movies")
  .get_ranking_rules()
  .await
  .unwrap();

client.index("movies").getRankingRules { (result) in
    switch result {
    case .success(let rankingRules):
        print(rankingRules)
    case .failure(let error):
        print(error)
    }
}

await client.index('movies').getRankingRules();

Response: 200 Ok

[
  "words",
  "typo",
  "proximity",
  "attribute",
  "sort",
  "exactness",
  "release_date:desc"
]

Update ranking rules

PUT

/indexes/{index_uid}/settings/ranking-rules

Update the ranking rules of an index.

Path parameters

Name	Type	Description
index_uid *	String	uid of the requested index

Body

[<String>, <String>, …]

An array that contains ranking rules in order of importance.

To create a custom ranking rule, give an attribute followed by a colon (:) and either asc for ascending order or desc for descending order.

• To apply an ascending sort (results sorted by increasing value): attribute_name:asc
• To apply a descending sort (results sorted by decreasing value): attribute_name:desc

WARNING

If some documents do not contain the attribute defined in a custom ranking rule, the application of the ranking rule is undefined and the search results might not be sorted as you expected.

Make sure that any attribute used in a custom ranking rule is present in all of your documents. For example, if you set the custom ranking rule desc(year), make sure that all your documents contain the attribute year.

To learn more about ranking rules, refer to our dedicated guide.

Example

curl \
  -X PUT 'http://localhost:7700/indexes/movies/settings/ranking-rules' \
  -H 'Content-Type: application/json' \
  --data-binary '[
    "words",
    "typo",
    "proximity",
    "attribute",
    "sort",
    "exactness",
    "release_date:asc",
    "rank:desc"
  ]'

client.index('movies').updateRankingRules([
    'words',
    'typo',
    'proximity',
    'attribute',
    'sort',
    'exactness',
    'release_date:asc',
    'rank:desc'
])

client.index('movies').update_ranking_rules([
    'words',
    'typo',
    'proximity',
    'attribute',
    'sort',
    'exactness',
    'release_date:asc',
    'rank:desc'
])

$client->index('movies')->updateRankingRules([
  'words',
  'typo',
  'proximity',
  'attribute',
  'sort',
  'exactness',
  'release_date:asc',
  'rank:desc'
]);

Settings settings = new Settings();
settings.setRankingRules(new String[]
{
  "words",
  "typo",
  "proximity",
  "attribute",
  "sort",
  "exactness",
  "release_date:asc",
  "rank:desc"
});
client.index("movies").updateSettings(settings);

client.index('movies').update_ranking_rules([
  'words',
  'typo',
  'proximity',
  'attribute',
  'sort',
  'exactness',
  'release_date:asc',
  'rank:desc'
])

rankingRules := []string{
  "words",
  "typo",
  "proximity",
  "attribute",
  "sort",
  "exactness",
  "release_date:asc",
  "rank:desc",
}
client.Index("movies").UpdateRankingRules(&rankingRules)

await client.Index("movies").UpdateRankingRulesAsync(new[]
{
    "words",
    "typo",
    "proximity",
    "attribute",
    "sort",
    "exactness",
    "release_date:asc",
    "rank:desc"
});

let ranking_rules = [
  "words",
  "typo",
  "proximity",
  "attribute",
  "sort",
  "exactness",
  "release_date:asc",
  "rank:desc",
];

let task: TaskInfo = client
  .index("movies")
  .set_ranking_rules(&ranking_rules)
  .await
  .unwrap();

let rankingRules: [String] = [
    "words",
    "typo",
    "proximity",
    "attribute",
    "sort",
    "exactness",
    "release_date:asc",
    "rank:desc"
]
client.index("movies").updateRankingRules(rankingRules) { (result) in
    switch result {
    case .success(let task):
        print(task)
    case .failure(let error):
        print(error)
    }
}

await client.index('movies').updateRankingRules([
  'words',
  'typo',
  'proximity',
  'attribute',
  'sort',
  'exactness',
  'release_date:asc',
  'rank:desc'
]);

Response: 202 Accepted

{
  "taskUid": 1,
  "indexUid": "movies",
  "status": "enqueued",
  "type": "settingsUpdate",
  "enqueuedAt": "2021-08-11T09:25:53.000000Z"
}

You can use this taskUid to get more details on the status of the task.

Reset ranking rules

DELETE

/indexes/{index_uid}/settings/ranking-rules

Reset the ranking rules of an index to their default value.

TIP

Resetting ranking rules is not the same as removing them. To remove a ranking rule, use the update ranking rules endpoint.

Path parameters

Name	Type	Description
index_uid *	String	uid of the requested index

Example

curl \
  -X DELETE 'http://localhost:7700/indexes/movies/settings/ranking-rules'

client.index('movies').resetRankingRules()

client.index('movies').reset_ranking_rules()

$client->index('movies')->resetRankingRules();

client.index("movies").resetRankingRulesSettings();

client.index('movies').reset_ranking_rules

client.Index("movies").ResetRankingRules()

await client.Index("movies").ResetRankingRulesAsync();

let task: TaskInfo = client
  .index("movies")
  .reset_ranking_rules()
  .await
  .unwrap();

client.index("movies").resetRankingRules { (result) in
    switch result {
    case .success(let task):
        print(task)
    case .failure(let error):
        print(error)
    }
}

await client.index('movies').resetRankingRules();

Response: 202 Accepted

{
  "taskUid": 1,
  "indexUid": "movies",
  "status": "enqueued",
  "type": "settingsUpdate",
  "enqueuedAt": "2021-08-11T09:25:53.000000Z"
}

You can use this taskUid to get more details on the status of the task.

Searchable attributes

The values associated with attributes in the searchableAttributes list are searched for matching query words. The order of the list also determines the attribute ranking order.

By default, the searchableAttributes array is equal to all fields in your dataset. This behavior is represented by the value ["*"].

WARNING

Updating searchable attributes will re-index all documents in the index, which can take some time. We recommend updating your index settings first and then adding documents as this reduces RAM consumption.

To learn more about searchable attributes, refer to our dedicated guide.

Get searchable attributes

GET

/indexes/{index_uid}/settings/searchable-attributes

Get the searchable attributes of an index.

Path parameters

Name	Type	Description
index_uid *	String	uid of the requested index

Example

curl \
  -X GET 'http://localhost:7700/indexes/movies/settings/searchable-attributes'

client.index('movies').getSearchableAttributes()

client.index('movies').get_searchable_attributes()

$client->index('movies')->getSearchableAttributes();

client.index("movies").getSearchableAttributesSettings();

client.index('movies').searchable_attributes

client.Index("movies").GetSearchableAttributes()

await client.Index("movies").GetSearchableAttributesAsync();

let searchable_attributes: Vec<String> = client
  .index("movies")
  .get_searchable_attributes()
  .await
  .unwrap();

client.index("movies").getSearchableAttributes { (result) in
    switch result {
    case .success(let searchableAttributes):
        print(searchableAttributes)
    case .failure(let error):
        print(error)
    }
}

await client.index('movies').getSearchableAttributes();

Response: 200 Ok

[
  "title",
  "overview",
  "genres",
  "release_date.year"
]

Update searchable attributes

PUT

/indexes/{index_uid}/settings/searchable-attributes

Update the searchable attributes of an index.

WARNING

Due to an implementation bug, manually updating searchableAttributes will change the displayed order of document fields in the JSON response. This behavior is inconsistent and will be fixed in a future release.

Path parameters

Name	Type	Description
index_uid *	String	uid of the requested index

Body

[<String>, <String>, …]

An array of strings. Each string should be an attribute that exists in the selected index. The array should be given in order of importance: from the most important attribute to the least important attribute.

If an attribute contains an object, you can use dot notation to set one or more of its keys as a value for this setting: "searchableAttributes": ["release_date.year"].

WARNING

If the field does not exist, no error will be thrown.

To learn more about searchable attributes, refer to our dedicated guide.

Example

curl \
  -X PUT 'http://localhost:7700/indexes/movies/settings/searchable-attributes' \
  -H 'Content-Type: application/json' \
  --data-binary '[
    "title",
    "overview",
    "genres"
  ]'

client.index('movies').updateSearchableAttributes([
  'title',
  'overview',
  'genres'
])

client.index('movies').update_searchable_attributes([
    'title',
    'overview',
    'genres'
])

$client->index('movies')->updateSearchableAttributes([
  'title',
  'overview',
  'genres'
]);

client.index("movies").updateSearchableAttributesSettings(new String[]
{
  "title",
  "overview",
  "genres"
});

client.index('movies').update_searchable_attributes([
  'title',
  'overview',
  'genres'
])

searchableAttributes := []string{
  "title",
  "overview",
  "genres",
}
client.Index("movies").UpdateSearchableAttributes(&searchableAttributes)

await client.Index("movies").UpdateSearchableAttributesAsync(new[] {"title", "overview", "genres"});

let searchable_attributes = [
  "title",
  "overview",
  "genres"
];

let task: TaskInfo = client
  .index("movies")
  .set_searchable_attributes(&searchable_attributes)
  .await
  .unwrap();

let searchableAttributes: [String] = ["title", "overview", "genres"]
client.index("movies").updateSearchableAttributes(searchableAttributes) { (result) in
    switch result {
    case .success(let task):
        print(task)
    case .failure(let error):
        print(error)
    }
}

await client.index('movies').updateSearchableAttributes([
  'title',
  'overview',
  'genres'
]);

In this example, a document with a match in title will be more relevant than another document with a match in overview.

Response: 202 Accepted

{
  "taskUid": 1,
  "indexUid": "movies",
  "status": "enqueued",
  "type": "settingsUpdate",
  "enqueuedAt": "2021-08-11T09:25:53.000000Z"
}

You can use this taskUid to get more details on the status of the task.

Reset searchable attributes

DELETE

/indexes/{index_uid}/settings/searchable-attributes

Reset the searchable attributes of the index to the default value.

Path parameters

Name	Type	Description
index_uid *	String	uid of the requested index

Example

curl \
  -X DELETE 'http://localhost:7700/indexes/movies/settings/searchable-attributes'

client.index('movies').resetSearchableAttributes()

client.index('movies').reset_searchable_attributes()

$client->index('movies')->resetSearchableAttributes();

client.index("movies").resetSearchableAttributesSettings();

client.index('movies').reset_searchable_attributes

client.Index("movies").ResetSearchableAttributes()

await client.Index("movies").ResetSearchableAttributesAsync();

let task: TaskInfo = client
  .index("movies")
  .reset_searchable_attributes()
  .await
  .unwrap();

client.index("movies").resetSearchableAttributes { (result) in
    switch result {
    case .success(let task):
        print(task)
    case .failure(let error):
        print(error)
    }
}

await client.index('movies').resetSearchableAttributes();

Response: 202 Accepted

{
  "taskUid": 1,
  "indexUid": "movies",
  "status": "enqueued",
  "type": "settingsUpdate",
  "enqueuedAt": "2021-08-11T09:25:53.000000Z"
}

You can use this taskUid to get more details on the status of the task.

Sortable attributes

Attributes that can be used when sorting search results using the sort search parameter.

WARNING

Updating sortable attributes will re-index all documents in the index, which can take some time. We recommend updating your index settings first and then adding documents as this reduces RAM consumption.

To learn more about sortable attributes, refer to our dedicated guide.

Get sortable attributes

GET

/indexes/{index_uid}/settings/sortable-attributes

Get the sortable attributes of an index.

Path parameters

Name	Type	Description
index_uid *	String	uid of the requested index

Example

curl \
  -X GET 'http://localhost:7700/indexes/books/settings/sortable-attributes'

client.index('books').getSortableAttributes()

client.index('books').get_sortable_attributes()

$client->index('books')->getSortableAttributes();

client.index("books").getSortableAttributesSettings();

client.index('books').sortable_attributes

client.Index("books").GetSortableAttributes()

await client.Index("books").GetSortableAttributesAsync();

let sortable_attributes: Vec<String> = client
  .index("books")
  .get_sortable_attributes()
  .await
  .unwrap();

client.index("books").getSortableAttributes { (result: Result<Searchable<Book>, Swift.Error>) in
  switch result {
  case .success(let attributes):
    print(attributes)
  case .failure(let error):
    print(error)
  }
}

await client.index('books').getSortableAttributes();

Response: 200 Ok

[
  "price", 
  "author.surname"
]

Update sortable attributes

PUT

/indexes/{index_uid}/settings/sortable-attributes

Update an index's sortable attributes list.

You can read more about sorting at query time on our dedicated guide.

Path parameters

Name	Type	Description
index_uid *	String	uid of the requested index

Body

[<String>, <String>, …]

An array of strings. Each string should be an attribute that exists in the selected index.

If an attribute contains an object, you can use dot notation to set one or more of its keys as a value for this setting: "sortableAttributes": ["author.surname"].

WARNING

If the field does not exist, no error will be thrown.

To learn more about sortable attributes, refer to our dedicated guide.

Example

curl \
  -X PUT 'http://localhost:7700/indexes/books/settings/sortable-attributes' \
  -H 'Content-Type: application/json' \
  --data-binary '[
    "price",
    "author"
  ]'

client.index('books')
  .updateSortableAttributes([
    'price',
    'author'
  ])

client.index('books').update_sortable_attributes([
  'price',
  'author'
])

$client->index('books')->updateSortableAttributes([
  'price',
  'author'
]);

client.index("books").updateSortableAttributesSettings(new String[] {"price", "author"});

client.index('books').update_sortable_attributes([
  'price',
  'author'
])

sortableAttributes := []string{
  "price",
  "author",
}
client.Index("books").UpdateSortableAttributes(&sortableAttributes)

await client.Index("books").UpdateSortableAttributesAsync(new [] { "price", "author" });

let sortable_attributes = [
  "price",
  "author"
];

let task: TaskInfo = client
  .index("books")
  .set_sortable_attributes(&sortable_attributes)
  .await
  .unwrap();

client.index("books").updateSortableAttributes(["price", "author"]) { (result) in
  switch result {
  case .success(let task):
    print(task)
  case .failure(let error):
    print(error)
  }
}

await client.index('books').updateSortableAttributes([
  'price',
  'author'
]);

Response: 202 Accepted

{
  "taskUid": 1,
  "indexUid": "movies",
  "status": "enqueued",
  "type": "settingsUpdate",
  "enqueuedAt": "2021-08-11T09:25:53.000000Z"
}

You can use this taskUid to get more details on the status of the task.

Reset sortable attributes

DELETE

/indexes/{index_uid}/settings/sortable-attributes

Reset an index's sortable attributes list back to its default value.

Path parameters

Name	Type	Description
index_uid *	String	uid of the requested index

Example

curl \
  -X DELETE 'http://localhost:7700/indexes/books/settings/sortable-attributes'

client.index('books').resetSortableAttributes()

client.index('books').reset_sortable_attributes()

$client->index('books')->resetSortableAttributes();

client.index("books").resetSortableAttributesSettings();

client.index('books').reset_sortable_attributes

client.Index("books").ResetSortableAttributes()

await client.Index("books").ResetSortableAttributesAsync();

let task: TaskInfo = client
  .index("books")
  .reset_sortable_attributes()
  .await
  .unwrap();

client.index("books").resetSortableAttributes() { (result) in
  switch result {
  case .success(let attributes):
    print(attributes)
  case .failure(let error):
    print(error)
  }
}

await client.index('books').resetSortableAttributes();

Response: 202 Accepted

{
  "taskUid": 1,
  "indexUid": "movies",
  "status": "enqueued",
  "type": "settingsUpdate",
  "enqueuedAt": "2021-08-11T09:25:53.000000Z"
}

You can use this taskUid to get more details on the status of the task.

Stop words

Words added to the stopWords list are ignored in future search queries.

WARNING

Updating stop words will re-index all documents in the index, which can take some time. We recommend updating your index settings first and then adding documents as this reduces RAM consumption.

TIP

Stop words are strongly related to the language used in your dataset. For example, most datasets containing English documents will have countless occurrences of the and of. Italian datasets, instead, will benefit from ignoring words like a, la, or il.

This website maintained by a French developer (opens new window) offers lists of possible stop words in different languages. Note that, depending on your dataset and use case, you will need to tweak these lists for optimal results.

Get stop words

GET

/indexes/{index_uid}/settings/stop-words

Get the stop words list of an index.

Path parameters

Name	Type	Description
index_uid *	String	uid of the requested index

Example

curl \
  -X GET 'http://localhost:7700/indexes/movies/settings/stop-words'

client.index('movies').getStopWords()

client.index('movies').get_stop_words()

$client->index('movies')->getStopWords();

client.index("movies").getStopWordsSettings();

client.index('movies').stop_words

client.Index("movies").GetStopWords()

await client.Index("movies").GetStopWordsAsync();

let stop_words: Vec<String> = client
  .index("movies")
  .get_stop_words()
  .await
  .unwrap();

client.index("movies").getStopWords { (result) in
    switch result {
    case .success(let stopWords):
        print(stopWords)
    case .failure(let error):
        print(error)
    }
}

await client.index('movies').getStopWords();

Response: 200 Ok

[
  "of",
  "the",
  "to"
]

Update stop words

PUT

/indexes/{index_uid}/settings/stop-words

Update the list of stop words of an index.

Path parameters

Name	Type	Description
index_uid *	String	uid of the requested index

Body

[<String>, <String>, …]

An array of strings. Each string should be a single word.

If a list of stop words already exists, it will be overwritten (replaced).

Example

curl \
  -X PUT 'http://localhost:7700/indexes/movies/settings/stop-words' \
  -H 'Content-Type: application/json' \
  --data-binary '[
    "the",
    "of",
    "to"
  ]'

client.index('movies').updateStopWords(['of', 'the', 'to'])

client.index('movies').update_stop_words(['of', 'the', 'to'])

$client->index('movies')->updateStopWords(['the', 'of', 'to']);

client.index("movies").updateStopWordsSettings(new String[] {"of", "the", "to"});

client.index('movies').update_stop_words(['of', 'the', 'to'])

stopWords := []string{"of", "the", "to"}
client.Index("movies").UpdateStopWords(&stopWords)

await client.Index("movies").UpdateStopWordsAsync(new[] {"of", "the", "to"});

let stop_words = ["of", "the", "to"];
let task: TaskInfo = client
  .index("movies")
  .set_stop_words(&stop_words)
  .await
  .unwrap();

let stopWords: [String] = ["of", "the", "to"]
client.index("movies").updateStopWords(stopWords) { (result) in
    switch result {
    case .success(let task):
        print(task)
    case .failure(let error):
        print(error)
    }
}

await client.index('movies').updateStopWords(['of', 'the', 'to']);

Response: 202 Accepted

{
  "taskUid": 1,
  "indexUid": "movies",
  "status": "enqueued",
  "type": "settingsUpdate",
  "enqueuedAt": "2021-08-11T09:25:53.000000Z"
}

You can use this taskUid to get more details on the status of the task.

Reset stop words

DELETE

/indexes/{index_uid}/settings/stop-words

Reset the list of stop words of an index to its default value.

Path parameters

Name	Type	Description
index_uid *	String	uid of the requested index

Example

curl \
  -X DELETE 'http://localhost:7700/indexes/movies/settings/stop-words'

client.index('movies').resetStopWords()

client.index('movies').reset_stop_words()

$client->index('movies')->resetStopWords();

client.index("movies").resetStopWordsSettings();

client.index('movies').reset_stop_words

client.Index("movies").ResetStopWords()

await client.Index("movies").ResetStopWordsAsync();

let task: TaskInfo = client
  .index("movies")
  .reset_stop_words()
  .await
  .unwrap();

client.index("movies").resetStopWords { (result) in
    switch result {
    case .success(let task):
        print(task)
    case .failure(let error):
        print(error)
    }
}

await client.index('movies').resetStopWords();

Response: 202 Accepted

{
  "taskUid": 1,
  "indexUid": "movies",
  "status": "enqueued",
  "type": "settingsUpdate",
  "enqueuedAt": "2021-08-11T09:25:53.000000Z"
}

You can use this taskUid to get more details on the status of the task.

Synonyms

The synonyms object contains words and their respective synonyms. A synonym in Meilisearch is considered equal to its associated word for the purposes of calculating search results.

To learn more about synonyms, refer to our dedicated guide.

Get synonyms

GET

/indexes/{index_uid}/settings/synonyms

Get the list of synonyms of an index.

Path parameters

Name	Type	Description
index_uid *	String	uid of the requested index

Example

curl \
  -X GET 'http://localhost:7700/indexes/movies/settings/synonyms'

client.index('movies').getSynonyms()

client.index('movies').get_synonyms()

$client->index('movies')->getSynonyms();

client.index("movies").getSynonymsSettings();

client.index('movies').synonyms

client.Index("movies").GetSynonyms()

await client.Index("movies").GetSynonymsAsync();

let synonyms: HashMap<String, Vec<String>> = client
  .index("movies")
  .get_synonyms()
  .await
  .unwrap();

client.index("movies").getSynonyms { (result) in
    switch result {
    case .success(let synonyms):
        print(synonyms)
    case .failure(let error):
        print(error)
    }
}

await client.index('movies').getSynonyms();

Response: 200 OK

{
  "wolverine": [
    "xmen",
    "logan"
  ],
  "logan": [
    "wolverine",
    "xmen"
  ],
  "wow": [
    "world of warcraft"
  ]
}

Update synonyms

PUT

/indexes/{index_uid}/settings/synonyms

Update the list of synonyms of an index. Synonyms are normalized.

Path parameters

Name	Type	Description
index_uid *	String	uid of the requested index

Body

{
  <String>: [<String>, <String>, …],
  …
}

An object that contains all synonyms and their associated words. Add the associated words in an array to set a synonym for a word.

To learn more about synonyms, refer to our dedicated guide.

Example

curl \
  -X PUT 'http://localhost:7700/indexes/movies/settings/synonyms' \
  -H 'Content-Type: application/json' \
  --data-binary '{
    "wolverine": [
      "xmen",
      "logan"
    ],
    "logan": [
      "wolverine",
      "xmen"
    ],
    "wow": ["world of warcraft"]
  }'

client.index('movies').updateSynonyms({
  wolverine: ['xmen', 'logan'],
  logan: ['wolverine', 'xmen'],
  wow: ['world of warcraft']
})

client.index('movies').update_synonyms({
  'wolverine': ['xmen', 'logan'],
  'logan': ['wolverine', 'xmen'],
  'wow': ['world of warcraft']
})

$client->index('movies')->updateSynonyms([
  'wolverine' => ['xmen', 'logan'],
  'logan' => ['wolverine', 'xmen'],
  'wow' => ['world of warcraft']
]);

HashMap<String, String[]> synonyms = new HashMap<String, String[]>();
synonyms.put("wolverine", new String[] {"xmen", "logan"});
synonyms.put("logan", new String[] {"wolverine"});
client.index("movies").updateSynonymsSettings(synonyms);

client.index('movies').update_synonyms({
  wolverine: ['xmen', 'logan'],
  logan: ['wolverine', 'xmen'],
  wow: ['world of warcraft']
})

synonyms := map[string][]string{
  "wolverine": []string{"xmen", "logan"},
  "logan":     []string{"wolverine", "xmen"},
  "wow":       []string{"world of warcraft"},
}
client.Index("movies").UpdateSynonyms(&synonyms)

var synonyms = new Dictionary<string, IEnumerable<string>>
{
	{ "wolverine", new string[] { "xmen", "logan" } },
	{ "logan", new string[] { "wolverine", "xmen" } },
  { "wow", new string[] { "world of warcraft" } }
};
await client.Index("movies").UpdateSynonymsAsync(synonyms);

let mut synonyms = std::collections::HashMap::new();
synonyms.insert(String::from("wolverine"), vec![String::from("xmen"), String::from("logan")]);
synonyms.insert(String::from("logan"), vec![String::from("xmen"), String::from("wolverine")]);
synonyms.insert(String::from("wow"), vec![String::from("world of warcraft")]);

let task: TaskInfo = client
  .index("movies")
  .set_synonyms(&synonyms)
  .await
  .unwrap();

let synonyms: [String: [String]] = [
    "wolverine": ["xmen", "logan"],
    "logan": ["wolverine", "xmen"],
    "wow": ["world of warcraft"]
]
client.index("movies").updateSynonyms(synonyms) { (result) in
    switch result {
    case .success(let task):
        print(task)
    case .failure(let error):
        print(error)
    }
}

await client.index('movies').updateSynonyms(
  {
    'wolverine': ['xmen', 'logan'],
    'logan': ['wolverine', 'xmen'],
    'wow': ['world of warcraft']
  }
);

Response: 202 Accepted

{
  "taskUid": 1,
  "indexUid": "movies",
  "status": "enqueued",
  "type": "settingsUpdate",
  "enqueuedAt": "2021-08-11T09:25:53.000000Z"
}

You can use this taskUid to get more details on the status of the task.

Reset synonyms

DELETE

/indexes/{index_uid}/settings/synonyms

Reset the list of synonyms of an index to its default value.

Path parameters

Name	Type	Description
index_uid *	String	uid of the requested index

Example

curl \
  -X DELETE 'http://localhost:7700/indexes/movies/settings/synonyms'

client.index('movies').resetSynonyms()

client.index('movies').reset_synonyms()

$client->index('movies')->resetSynonyms();

client.index("movies").resetSynonymsSettings();

client.index('movies').reset_synonyms

client.Index("movies").ResetSynonyms()

await client.Index("movies").ResetSynonymsAsync();

let task: TaskInfo = client
  .index("movies")
  .reset_synonyms()
  .await
  .unwrap();

client.index("movies").resetSynonyms { (result) in
    switch result {
    case .success(let task):
        print(task)
    case .failure(let error):
        print(error)
    }
}

await client.index('movies').resetSynonyms();

Response: 202 Accepted

{
  "taskUid": 1,
  "indexUid": "movies",
  "status": "enqueued",
  "type": "settingsUpdate",
  "enqueuedAt": "2021-08-11T09:25:53.000000Z"
}

You can use this taskUid to get more details on the status of the task.

Typo tolerance

Typo tolerance helps users find relevant results even when their search queries contain spelling mistakes or typos. This setting allows you to configure the minimum word size for typos and disable typo tolerance for specific words or attributes.

To learn more about typo tolerance, refer to our dedicated guide.

Typo tolerance object

Name	Type	Default Value	Description
enabled	Boolean	true	Whether typo tolerance is enabled or not
minWordSizeForTypos.oneTypo	Integer	5	The minimum word size for accepting 1 typo; must be between 0 and twoTypos
minWordSizeForTypos.twoTypos	Integer	9	The minimum word size for accepting 2 typos; must be between oneTypo and 255
disableOnWords	Array of strings	Empty	An array of words for which the typo tolerance feature is disabled
disableOnAttributes	Array of strings	Empty	An array of attributes for which the typo tolerance feature is disabled

Get typo tolerance settings

GET

/indexes/{index_uid}/settings/typo-tolerance

Get the typo tolerance settings of an index.

Path parameters

Name	Type	Description
index_uid *	String	uid of the requested index

Example

curl \
  -X GET 'http://localhost:7700/indexes/books/settings/typo-tolerance'

client.index('books').getTypoTolerance()

client.index('books').get_typo_tolerance()

$client->index('books')->getTypoTolerance();

client.index("books").getTypoToleranceSettings();

index('books').typo_tolerance

client.Index("books").GetTypoTolerance()

await client.Index("books").GetTypoToleranceAsync();

Response: 200 OK

{
  "enabled": true,
  "minWordSizeForTypos": {
    "oneTypo": 5,
    "twoTypos": 9
  },
  "disableOnWords": [],
  "disableOnAttributes": []
}

Update typo tolerance settings

PATCH

/indexes/{index_uid}/settings/typo-tolerance

Partially update the typo tolerance settings for an index.

Path parameters

Name	Type	Description
index_uid *	String	uid of the requested index

Body

{
  "enabled": <Boolean>,
  "minWordSizeForTypos": {
    "oneTypo": <Integer>,
    "twoTypos": <Integer>
  },
  "disableOnWords": [<String>, <String>, …],
  "disableOnAttributes": [<String>, <String>, …]
}

Name	Type	Default Value	Description
enabled	Boolean	true	Whether typo tolerance is enabled or not
minWordSizeForTypos.oneTypo	Integer	5	The minimum word size for accepting 1 typo; must be between 0 and twoTypos
minWordSizeForTypos.twoTypos	Integer	9	The minimum word size for accepting 2 typos; must be between oneTypo and 255
disableOnWords	Array of strings	Empty	An array of words for which the typo tolerance feature is disabled
disableOnAttributes	Array of strings	Empty	An array of attributes for which the typo tolerance feature is disabled

Example

curl \
  -X PATCH 'http://localhost:7700/indexes/books/settings/typo-tolerance' \
  -H 'Content-Type: application/json' \
  --data-binary '{
    "minWordSizeForTypos": {
      "oneTypo": 4,
      "twoTypos": 10
    },
    "disableOnAttributes": ["title"]
  }'

client.index('books').updateTypoTolerance({
  minWordSizeForTypos: {
      oneTypo: 4,
      twoTypos: 10
    },
    disableOnAttributes: [
      'title'
  ]
})

client.index('books').update_typo_tolerance({
  'minWordSizeForTypos': {
      'oneTypo': 4,
      'twoTypos': 10
    },
    'disableOnAttributes': [
       'title'
    ]
})

$client->index('books')->updateTypoTolerance([
  'minWordSizeForTypos' => [
      'oneTypo' => 4,
      'twoTypos' => 10
    ],
    'disableOnAttributes' => [
      'title'
  ]
]);

TypoTolerance typoTolerance = new TypoTolerance();
HashMap<String, Integer> minWordSizeTypos =
        new HashMap<String, Integer>() {
            {
                put("oneTypo", 4);
                put("twoTypos", 10);
            }
        };

typoTolerance.setMinWordSizeForTypos(minWordSizeTypos);
typoTolerance.setDisableOnAttributes(new String[] {"title"});

client.index("books").updateTypoToleranceSettings(typoTolerance);

index('books').update_typo_tolerance({
  min_word_size_for_typos: {
    one_typo: 4,
    two_typos: 10
  },
  disable_on_attributes: ['title']
})

client.Index("books").UpdateTypoTolerance(&meilisearch.TypoTolerance{
  MinWordSizeForTypos: meilisearch.MinWordSizeForTypos{
      OneTypo: 4,
      TwoTypos: 10,
    },
    DisableOnAttributes: []string{"title"},
})

var typoTolerance = new TypoTolerance {
  DisableOnAttributes = new string[] { "title" },
  MinWordSizeTypos = new TypoTolerance.TypoSize {
      OneTypo = 4,
      TwoTypos = 10
  }
};

await client.Index("books").UpdateTypoToleranceAsync(typoTolerance);

Response: 202 Accepted

{
  "taskUid": 1,
  "indexUid": "books",
  "status": "enqueued",
  "type": "settingsUpdate",
  "enqueuedAt": "2022-04-14T20:56:44.991039Z"
}

You can use the returned taskUid to get more details on the status of the task.

Reset typo tolerance settings

DELETE

/indexes/{index_uid}/settings/typo-tolerance

Reset an index's typo tolerance settings to their default value.

Path parameters

Name	Type	Description
index_uid *	String	uid of the requested index

Example

curl \
  -X DELETE 'http://localhost:7700/indexes/books/settings/typo-tolerance'

client.index('books').resetTypoTolerance()

client.index('books').reset_typo_tolerance()

$client->index('books')->resetTypoTolerance();

client.index("books").resetTypoToleranceSettings();

index('books').reset_typo_tolerance

client.Index("books").ResetTypoTolerance()

await client.Index("books").ResetTypoToleranceAsync();

Response: 202 Accepted

{
  "taskUid": 1,
  "indexUid": "books",
  "status": "enqueued",
  "type": "settingsUpdate",
  "enqueuedAt": "2022-04-14T20:53:32.863107Z"
}

You can use the returned taskUid to get more details on the status of the task.