> ## Documentation Index
> Fetch the complete documentation index at: https://algolia.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Search for facet values

> Searches for values of a specified facet attribute on the composition's main source's index.

* By default, facet values are sorted by decreasing count.
  You can adjust this with the `sortFacetValueBy` parameter.
* Searching for facet values doesn't work if you have **more than 65 searchable facets and searchable attributes combined**.

**Required ACL:** `search`


## OpenAPI

````yaml specs/composition.yml post /1/compositions/{compositionID}/facets/{facetName}/query
openapi: 3.1.0
info:
  title: Composition API
  summary: >-
    The Algolia Composition API lets you run composed search requests on your
    Compositions
  description: >
    ## Client libraries


    Use Algolia's API clients and libraries to reliably integrate Algolia's APIs
    with your apps.


    For more information, see [Algolia's
    ecosystem](https://www.algolia.com/doc/libraries).


    ## Base URLs


    Base URLs for the Composition API:


    - `https://{APPLICATION_ID}.algolia.net`

    - `https://{APPLICATION_ID}-dsn.algolia.net`.
      If your subscription includes a [Distributed Search Network](https://dashboard.algolia.com/infra),
      this ensures that requests are sent to servers closest to users.

    Both URLs provide high availability by distributing requests with load
    balancing.


    **All requests must use HTTPS.**


    ## Retry strategy


    To guarantee high availability, implement a retry strategy for all API
    requests using the URLs of your servers as fallbacks:


    - `https://{APPLICATION_ID}-1.algolianet.com`

    - `https://{APPLICATION_ID}-2.algolianet.com`

    - `https://{APPLICATION_ID}-3.algolianet.com`


    These URLs use a different DNS provider than the primary URLs.

    Randomize this list to ensure an even load across the three servers.


    All Algolia API clients implement this retry strategy.


    ## Authentication


    Add these headers to authenticate requests:


    - `x-algolia-application-id`. Your Algolia application ID.

    - `x-algolia-api-key`. An API key with the necessary permissions to make the
    request.
      The required access control list (ACL) to make a request is listed in each endpoint's reference.

    You can find your application ID and API key in the [Algolia
    dashboard](https://dashboard.algolia.com/account/api-keys).


    ## Request format


    Depending on the endpoint, request bodies are either JSON objects or arrays
    of JSON objects.


    ## Parameters


    Parameters are passed in the request body for POST and PUT requests.


    ## Response status and errors


    The Composition API returns JSON responses.

    Since JSON doesn't guarantee any specific ordering, don't rely on the order
    of attributes in the API response.


    Successful responses return `2xx` statuses. Client errors return `4xx`
    statuses. Server errors return `5xx` statuses.

    Error responses have a `message` property with more information.


    ## Version


    The current version of the Composition API is version 1, indicated by the
    `/1/` in each endpoint's URL.
  version: 1.0.0
servers:
  - url: https://{appId}.algolia.net
    variables:
      appId:
        default: ALGOLIA_APPLICATION_ID
  - url: https://{appId}-1.algolianet.com
    variables:
      appId:
        default: ALGOLIA_APPLICATION_ID
  - url: https://{appId}-2.algolianet.com
    variables:
      appId:
        default: ALGOLIA_APPLICATION_ID
  - url: https://{appId}-3.algolianet.com
    variables:
      appId:
        default: ALGOLIA_APPLICATION_ID
  - url: https://{appId}-dsn.algolia.net
    variables:
      appId:
        default: ALGOLIA_APPLICATION_ID
security:
  - appId: []
    apiKey: []
tags:
  - name: Advanced
    description: Advanced endpoints to manage tasks.
  - name: Composition Rules
    description: Manage your compositions rules.
  - name: Compositions
    description: Manage your compositions and composition settings.
  - name: Search
    description: Search one or more indices for matching records or facet values.
paths:
  /1/compositions/{compositionID}/facets/{facetName}/query:
    post:
      tags:
        - Search
      summary: Search for facet values
      description: >
        Searches for values of a specified facet attribute on the composition's
        main source's index.


        - By default, facet values are sorted by decreasing count.
          You can adjust this with the `sortFacetValueBy` parameter.
        - Searching for facet values doesn't work if you have **more than 65
        searchable facets and searchable attributes combined**.
      operationId: searchForFacetValues
      parameters:
        - $ref: '#/components/parameters/compositionID'
        - name: facetName
          description: >
            Facet attribute in which to search for values.


            This attribute must be included in the `attributesForFaceting` index
            setting with the `searchable()` modifier.
          in: path
          required: true
          schema:
            type: string
      requestBody:
        content:
          application/json:
            schema:
              title: searchForFacetValuesRequest
              type: object
              additionalProperties: false
              properties:
                params:
                  title: searchForFacetValuesParams
                  type: object
                  properties:
                    maxFacetHits:
                      $ref: '#/components/schemas/maxFacetHits'
                    query:
                      $ref: '#/components/schemas/query'
                    searchQuery:
                      $ref: '#/components/schemas/params'
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/searchForFacetValuesResponse'
        '400':
          $ref: '#/components/responses/BadRequest'
        '402':
          $ref: '#/components/responses/FeatureNotEnabled'
        '403':
          $ref: '#/components/responses/MethodNotAllowed'
        '404':
          $ref: '#/components/responses/IndexNotFound'
      x-codeSamples:
        - lang: csharp
          label: C#
          source: |-
            // Initialize the client
            var client = new CompositionClient(
              new CompositionConfig("ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY")
            );

            // Call the API
            var response = await client.SearchForFacetValuesAsync(
              "foo",
              "brand",
              new SearchForFacetValuesRequest
              {
                Params = new SearchForFacetValuesParams { MaxFacetHits = 10 },
              }
            );

            // print the response
            Console.WriteLine(response);
        - lang: dart
          label: Dart
          source: |-
            // Initialize the client
            final client = CompositionClient(
                appId: 'ALGOLIA_APPLICATION_ID', apiKey: 'ALGOLIA_API_KEY');

            // Call the API
            final response = await client.searchForFacetValues(
              compositionID: "foo",
              facetName: "brand",
              searchForFacetValuesRequest: SearchForFacetValuesRequest(
                params: SearchForFacetValuesParams(
                  maxFacetHits: 10,
                ),
              ),
            );

            // print the response
            print(response);
        - lang: go
          label: Go
          source: >-
            // Initialize the client

            client, err := composition.NewClient("ALGOLIA_APPLICATION_ID",
            "ALGOLIA_API_KEY")

            if err != nil {
              // The client can fail to initialize if you pass an invalid parameter.
              panic(err)
            }


            // Call the API

            response, err :=
            client.SearchForFacetValues(client.NewApiSearchForFacetValuesRequest(
              "foo", "brand").WithSearchForFacetValuesRequest(
              composition.NewEmptySearchForFacetValuesRequest().SetParams(
                composition.NewEmptySearchForFacetValuesParams().SetMaxFacetHits(10))))
            if err != nil {
              // handle the eventual error
              panic(err)
            }



            // print the response

            print(response)
        - lang: java
          label: Java
          source: >-
            // Initialize the client

            CompositionClient client = new
            CompositionClient("ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY");


            // Call the API

            SearchForFacetValuesResponse response = client.searchForFacetValues(
              "foo",
              "brand",
              new SearchForFacetValuesRequest().setParams(new SearchForFacetValuesParams().setMaxFacetHits(10))
            );


            // print the response

            System.out.println(response);
        - lang: javascript
          label: JavaScript
          source: >-
            // Initialize the client

            const client = compositionClient('ALGOLIA_APPLICATION_ID',
            'ALGOLIA_API_KEY');


            // Call the API

            const response = await client.searchForFacetValues({
              compositionID: 'foo',
              facetName: 'brand',
              searchForFacetValuesRequest: { params: { maxFacetHits: 10 } },
            });



            // print the response

            console.log(response);
        - lang: kotlin
          label: Kotlin
          source: >-
            // Initialize the client

            val client = CompositionClient(appId = "ALGOLIA_APPLICATION_ID",
            apiKey = "ALGOLIA_API_KEY")


            // Call the API

            var response =
              client.searchForFacetValues(
                compositionID = "foo",
                facetName = "brand",
                searchForFacetValuesRequest =
                  SearchForFacetValuesRequest(params = SearchForFacetValuesParams(maxFacetHits = 10)),
              )


            // print the response

            println(response)
        - lang: php
          label: PHP
          source: >-
            // Initialize the client

            $client = CompositionClient::create('ALGOLIA_APPLICATION_ID',
            'ALGOLIA_API_KEY');


            // Call the API

            $response = $client->searchForFacetValues(
                'foo',
                'brand',
                ['params' => ['maxFacetHits' => 10,
                ],
                ],
            );



            // print the response

            var_dump($response);
        - lang: python
          label: Python
          source: >-
            # Initialize the client

            # In an asynchronous context, you can use CompositionClient instead,
            which exposes the exact same methods.

            client = CompositionClientSync("ALGOLIA_APPLICATION_ID",
            "ALGOLIA_API_KEY")


            # Call the API

            response = client.search_for_facet_values(
                composition_id="foo",
                facet_name="brand",
                search_for_facet_values_request={
                    "params": {
                        "maxFacetHits": 10,
                    },
                },
            )



            # print the response

            print(response)
        - lang: ruby
          label: Ruby
          source: >-
            # Initialize the client

            client = Algolia::CompositionClient.create("ALGOLIA_APPLICATION_ID",
            "ALGOLIA_API_KEY")


            # Call the API

            response = client.search_for_facet_values(
              "foo",
              "brand",
              Algolia::Composition::SearchForFacetValuesRequest.new(
                params: Algolia::Composition::SearchForFacetValuesParams.new(max_facet_hits: 10)
              )
            )



            # print the response

            puts(response)
        - lang: scala
          label: Scala
          source: >-
            // Initialize the client

            val client = CompositionClient(appId = "ALGOLIA_APPLICATION_ID",
            apiKey = "ALGOLIA_API_KEY")


            // Call the API

            val response = Await.result(
              client.searchForFacetValues(
                compositionID = "foo",
                facetName = "brand",
                searchForFacetValuesRequest = Some(
                  SearchForFacetValuesRequest(
                    params = Some(
                      SearchForFacetValuesParams(
                        maxFacetHits = Some(10)
                      )
                    )
                  )
                )
              ),
              Duration(100, "sec")
            )


            // print the response

            println(response)
        - lang: swift
          label: Swift
          source: >-
            // Initialize the client

            let client = try CompositionClient(appID: "ALGOLIA_APPLICATION_ID",
            apiKey: "ALGOLIA_API_KEY")


            // Call the API

            let response = try await client.searchForFacetValues(
                compositionID: "foo",
                facetName: "brand",
                searchForFacetValuesRequest: CompositionSearchForFacetValuesRequest(
                    params: SearchForFacetValuesParams(maxFacetHits: 10)
                )
            )


            // print the response

            print(response)
        - lang: cURL
          label: curl
          source: |-
            curl --request POST \
              --url https://algolia_application_id.algolia.net/1/compositions/my_composition_object_id/facets/lorem/query \
              --header 'accept: application/json' \
              --header 'content-type: application/json' \
              --header 'x-algolia-api-key: ALGOLIA_API_KEY' \
              --header 'x-algolia-application-id: ALGOLIA_APPLICATION_ID' \
              --data '
            {
              "params": {
                "query": "",
                "maxFacetHits": 10,
                "searchQuery": {
                  "analytics": true,
                  "analyticsTags": [],
                  "aroundLatLng": "40.71,-74.01",
                  "aroundLatLngViaIP": false,
                  "aroundRadius": 1,
                  "aroundPrecision": 10,
                  "clickAnalytics": false,
                  "enableABTest": true,
                  "enablePersonalization": false,
                  "enableReRanking": true,
                  "enableRules": true,
                  "facetFilters": [
                    [
                      "category:Book",
                      "category:-Movie"
                    ],
                    "author:John Doe"
                  ],
                  "facets": [
                    "category",
                    "disjunctive(brand)",
                    "price"
                  ],
                  "filters": "(category:Book OR category:Ebook) AND _tags:published",
                  "getRankingInfo": false,
                  "hitsPerPage": 20,
                  "injectedItems": {
                    "my-group-key": {
                      "items": [
                        {
                          "objectID": "my-object-1",
                          "metadata": {
                            "my-field": "my-value"
                          }
                        },
                        {
                          "objectID": "my-object-2",
                          "metadata": {
                            "my-field": "my-value-2"
                          }
                        }
                      ]
                    },
                    "my-other-group-key": {
                      "items": [
                        {
                          "objectID": "my-other-object-1"
                        },
                        {
                          "objectID": "my-other-object-2"
                        }
                      ]
                    }
                  },
                  "insideBoundingBox": "lorem",
                  "insidePolygon": [
                    [
                      47.3165,
                      4.9665,
                      47.3424,
                      5.0201,
                      47.32,
                      4.9
                    ],
                    [
                      40.9234,
                      2.1185,
                      38.643,
                      1.9916,
                      39.2587,
                      2.0104
                    ]
                  ],
                  "minimumAroundRadius": 1,
                  "naturalLanguages": [],
                  "numericFilters": [
                    [
                      "inStock = 1",
                      "deliveryDate < 1441755506"
                    ],
                    "price < 1000"
                  ],
                  "optionalFilters": [
                    "category:Book",
                    "author:John Doe"
                  ],
                  "page": 0,
                  "query": "",
                  "queryLanguages": [
                    "es"
                  ],
                  "relevancyStrictness": 90,
                  "ruleContexts": [
                    "mobile"
                  ],
                  "sortBy": "Price (asc)",
                  "userToken": "test-user-123"
                }
              }
            }
            '
components:
  parameters:
    compositionID:
      in: path
      name: compositionID
      description: Unique Composition ObjectID.
      required: true
      schema:
        $ref: '#/components/schemas/compositionObjectID'
  schemas:
    maxFacetHits:
      type: integer
      description: >-
        Maximum number of facet values to return when [searching for facet
        values](https://www.algolia.com/doc/guides/managing-results/refine-results/faceting/#search-for-facet-values).
      maximum: 100
      default: 10
      x-categories:
        - Advanced
    query:
      type: string
      description: Search query.
      default: ''
      x-categories:
        - Search
    params:
      title: Run composition parameters as object
      type: object
      additionalProperties: false
      properties:
        analytics:
          $ref: '#/components/schemas/analytics'
        analyticsTags:
          $ref: '#/components/schemas/analyticsTags'
        aroundLatLng:
          $ref: '#/components/schemas/aroundLatLng'
        aroundLatLngViaIP:
          $ref: '#/components/schemas/aroundLatLngViaIP'
        aroundPrecision:
          $ref: '#/components/schemas/aroundPrecision'
        aroundRadius:
          $ref: '#/components/schemas/aroundRadius'
        clickAnalytics:
          $ref: '#/components/schemas/clickAnalytics'
        enableABTest:
          $ref: '#/components/schemas/enableABTest'
        enablePersonalization:
          $ref: '#/components/schemas/enablePersonalization'
        enableReRanking:
          $ref: '#/components/schemas/enableReRanking'
        enableRules:
          $ref: '#/components/schemas/enableRules'
        facetFilters:
          $ref: '#/components/schemas/facetFilters'
        facets:
          $ref: '#/components/schemas/facets'
        filters:
          $ref: '#/components/schemas/filters'
        getRankingInfo:
          $ref: '#/components/schemas/getRankingInfo'
        hitsPerPage:
          $ref: '#/components/schemas/hitsPerPage'
        injectedItems:
          $ref: '#/components/schemas/injectedItems'
        insideBoundingBox:
          $ref: '#/components/schemas/insideBoundingBox'
        insidePolygon:
          $ref: '#/components/schemas/insidePolygon'
        minimumAroundRadius:
          $ref: '#/components/schemas/minimumAroundRadius'
        naturalLanguages:
          $ref: '#/components/schemas/naturalLanguages'
        numericFilters:
          $ref: '#/components/schemas/numericFilters'
        optionalFilters:
          $ref: '#/components/schemas/optionalFilters'
        page:
          $ref: '#/components/schemas/page'
        query:
          $ref: '#/components/schemas/query'
        queryLanguages:
          $ref: '#/components/schemas/queryLanguages'
        relevancyStrictness:
          $ref: '#/components/schemas/relevancyStrictness'
        ruleContexts:
          $ref: '#/components/schemas/ruleContexts'
        sortBy:
          $ref: '#/components/schemas/sortBy'
        userToken:
          $ref: '#/components/schemas/userToken'
    searchForFacetValuesResponse:
      type: object
      additionalProperties: false
      properties:
        results:
          type: array
          description: Search for facet values results.
          items:
            $ref: '#/components/schemas/searchForFacetValuesResults'
    compositionObjectID:
      type: string
      example: my_composition_object_id
      description: Composition unique identifier.
    analytics:
      type: boolean
      description: Whether this search will be included in Analytics.
      default: true
      x-categories:
        - Analytics
    analyticsTags:
      type: array
      items:
        type: string
      description: >-
        Tags to apply to the query for [segmenting analytics
        data](https://www.algolia.com/doc/guides/search-analytics/guides/segments).
      default: []
    aroundLatLng:
      type: string
      description: >
        Coordinates for the center of a circle, expressed as a comma-separated
        string of latitude and longitude.


        Only records included within a circle around this central location are
        included in the results.

        The radius of the circle is determined by the `aroundRadius` and
        `minimumAroundRadius` settings.

        This parameter is ignored if you also specify `insidePolygon` or
        `insideBoundingBox`.
      example: 40.71,-74.01
      default: ''
      x-categories:
        - Geo-Search
    aroundLatLngViaIP:
      type: boolean
      description: Whether to obtain the coordinates from the request's IP address.
      default: false
      x-categories:
        - Geo-Search
    aroundPrecision:
      description: >
        Precision of a coordinate-based search in meters to group results with
        similar distances.


        The Geo ranking criterion considers all matches within the same range of
        distances to be equal.
      oneOf:
        - type: integer
          default: 10
          description: >
            Distance in meters to group results by similar distances.


            For example, if you set `aroundPrecision` to 100, records wihin 100
            meters to the central coordinate are considered to have the same
            distance,

            as are records between 100 and 199 meters.
        - $ref: '#/components/schemas/aroundPrecisionFromValue'
      x-categories:
        - Geo-Search
    aroundRadius:
      description: >
        Maximum radius for a search around a central location.


        This parameter works in combination with the `aroundLatLng` and
        `aroundLatLngViaIP` parameters.

        By default, the search radius is determined automatically from the
        density of hits around the central location.

        The search radius is small if there are many hits close to the central
        coordinates.
      oneOf:
        - type: integer
          minimum: 1
          description: Maximum search radius around a central location in meters.
        - $ref: '#/components/schemas/aroundRadiusAll'
      x-categories:
        - Geo-Search
    clickAnalytics:
      type: boolean
      description: >
        Whether to include a `queryID` attribute in the response

        The query ID is a unique identifier for a search query and is required
        for tracking [click and conversion
        events](https://www.algolia.com/doc/guides/sending-events/getting-started).
      default: false
      x-categories:
        - Analytics
    enableABTest:
      type: boolean
      description: |
        Whether to enable index level A/B testing for this run request.
        If the composition mixes multiple indices, the A/B test is ignored.
      default: true
      x-categories:
        - Advanced
    enablePersonalization:
      type: boolean
      description: Whether to enable Personalization.
      default: false
      x-categories:
        - Personalization
    enableReRanking:
      type: boolean
      description: >
        Whether this search will use [Dynamic
        Re-Ranking](https://www.algolia.com/doc/guides/algolia-ai/re-ranking)

        This setting only has an effect if you activated Dynamic Re-Ranking for
        this index in the Algolia dashboard.
      default: true
      x-categories:
        - Filtering
    enableRules:
      type: boolean
      description: Whether to enable composition rules.
      default: true
      x-categories:
        - Composition Rules
    facetFilters:
      description: >
        Filter the search by facet values, so that only records with the same
        facet values are retrieved.


        **Prefer using the `filters` parameter, which supports all filter types
        and combinations with boolean operators.**


        - `[filter1, filter2]` is interpreted as `filter1 AND filter2`.

        - `[[filter1, filter2], filter3]` is interpreted as `filter1 OR filter2
        AND filter3`.

        - `facet:-value` is interpreted as `NOT facet:value`.


        While it's best to avoid attributes that start with a `-`, you can still
        filter them by escaping with a backslash:

        `facet:\-value`.
      example:
        - - category:Book
          - category:-Movie
        - author:John Doe
      oneOf:
        - type: array
          items:
            $ref: '#/components/schemas/facetFilters'
        - type: string
      x-categories:
        - Filtering
    facets:
      type: array
      items:
        type: string
      description: >
        Facets for which to retrieve facet values that match the search criteria
        and the number of matching facet values

        To retrieve all facets, use the wildcard character `*`.

        To retrieve disjunctive facets lists, annotate any facets with the
        `disjunctive` modifier.

        For more information, see
        [facets](https://www.algolia.com/doc/guides/managing-results/refine-results/faceting/#contextual-facet-values-and-counts)
        and [disjunctive faceting for Smart
        Groups](https://www.algolia.com/doc/guides/managing-results/compositions/search-based-groups#facets-including-disjunctive-faceting).
      default: []
      example:
        - category
        - disjunctive(brand)
        - price
      examples:
        - - category
          - disjunctive(brand)
          - price
        - - '*'
        - - '*'
          - disjunctive(brand)
      x-categories:
        - Faceting
    filters:
      type: string
      description: >
        Filter expression to only include items that match the filter criteria
        in the response.


        You can use these filter expressions:


        - **Numeric filters.** `<facet> <op> <number>`, where `<op>` is one of
        `<`, `<=`, `=`, `!=`, `>`, `>=`.

        - **Ranges.** `<facet>:<lower> TO <upper>`, where `<lower>` and
        `<upper>` are the lower and upper limits of the range (inclusive).

        - **Facet filters.** `<facet>:<value>`, where `<facet>` is a facet
        attribute (case-sensitive) and `<value>` a facet value.

        - **Tag filters.** `_tags:<value>` or just `<value>` (case-sensitive).

        - **Boolean filters.** `<facet>: true | false`.


        You can combine filters with `AND`, `OR`, and `NOT` operators with the
        following restrictions:


        - You can only combine filters of the same type with `OR`.
          **Not supported:** `facet:value OR num > 3`.
        - You can't use `NOT` with combinations of filters.
          **Not supported:** `NOT(facet:value OR facet:value)`
        - You can't combine conjunctions (`AND`) with `OR`.
          **Not supported:** `facet:value OR (facet:value AND facet:value)`

        Use quotes if the facet attribute name or facet value contains spaces,
        keywords (`OR`, `AND`, `NOT`), or quotes.

        If a facet attribute is an array, the filter matches if it matches at
        least one element of the array.


        For more information, see
        [Filters](https://www.algolia.com/doc/guides/managing-results/refine-results/filtering).
      example: (category:Book OR category:Ebook) AND _tags:published
      x-categories:
        - Filtering
    getRankingInfo:
      type: boolean
      description: Whether the run response should include detailed ranking information.
      default: false
      x-categories:
        - Advanced
    hitsPerPage:
      type: integer
      description: Number of hits per page.
      default: 20
      minimum: 1
      maximum: 1000
      x-categories:
        - Pagination
    injectedItems:
      type: object
      additionalProperties:
        $ref: '#/components/schemas/externalInjectedItem'
      description: >
        An object containing keys corresponding to the `key`s from an
        injection's `injectedItems` and values containing a list of hits to
        inject.
      default: {}
      x-categories:
        - Retail Media Network
      example:
        my-group-key:
          items:
            - objectID: my-object-1
              metadata:
                my-field: my-value
            - objectID: my-object-2
              metadata:
                my-field: my-value-2
        my-other-group-key:
          items:
            - objectID: my-other-object-1
            - objectID: my-other-object-2
    insideBoundingBox:
      oneOf:
        - type: string
        - type: 'null'
        - $ref: '#/components/schemas/insideBoundingBoxArray'
    insidePolygon:
      type: array
      items:
        type: array
        minItems: 6
        maxItems: 20000
        items:
          type: number
          format: double
      description: >
        Coordinates of a polygon in which to search.


        Polygons are defined by 3 to 10,000 points. Each point is represented by
        its latitude and longitude.

        Provide multiple polygons as nested arrays.

        For more information, see [filtering inside
        polygons](https://www.algolia.com/doc/guides/managing-results/refine-results/geolocation/#filtering-inside-rectangular-or-polygonal-areas).

        This parameter is ignored if you also specify `insideBoundingBox`.
      example:
        - - 47.3165
          - 4.9665
          - 47.3424
          - 5.0201
          - 47.32
          - 4.9
        - - 40.9234
          - 2.1185
          - 38.643
          - 1.9916
          - 39.2587
          - 2.0104
      x-categories:
        - Geo-Search
    minimumAroundRadius:
      type: integer
      description: >-
        Minimum radius (in meters) for a search around a location when
        `aroundRadius` isn't set.
      minimum: 1
      x-categories:
        - Geo-Search
    naturalLanguages:
      type: array
      items:
        $ref: '#/components/schemas/supportedLanguage'
      description: >
        ISO language codes that adjust settings that are useful for processing
        natural language queries (as opposed to keyword searches)

        - Sets `removeStopWords` and `ignorePlurals` to the list of provided
        languages.

        - Sets `removeWordsIfNoResults` to `allOptional`.

        - Adds a `natural_language` attribute to `ruleContexts` and
        `analyticsTags`.
      default: []
      x-categories:
        - Languages
    numericFilters:
      description: >
        Filter by numeric facets.


        **Prefer using the `filters` parameter, which supports all filter types
        and combinations with boolean operators.**


        You can use numeric comparison operators: `<`, `<=`, `=`, `!=`, `>`,
        `>=`.

        Comparisons are precise up to 3 decimals.

        You can also provide ranges: `facet:<lower> TO <upper>`. The range
        includes the lower and upper boundaries.

        The same combination rules apply as for `facetFilters`.
      example:
        - - inStock = 1
          - deliveryDate < 1441755506
        - price < 1000
      oneOf:
        - type: array
          items:
            $ref: '#/components/schemas/numericFilters'
        - type: string
      x-categories:
        - Filtering
    optionalFilters:
      description: >
        Filters to promote or demote records in the search results.


        Optional filters work like facet filters, but they don't exclude records
        from the search results.

        Records that match the optional filter rank before records that don't
        match.

        If you're using a negative filter `facet:-value`, matching records rank
        after records that don't match.


        - Optional filters are applied _after_ sort-by attributes.

        - Optional filters are applied _before_ custom ranking attributes (in
        the default
        [ranking](https://www.algolia.com/doc/guides/managing-results/relevance-overview/in-depth/ranking-criteria)).

        - Optional filters don't work with numeric attributes.

        - On virtual replicas, optional filters are applied _after_ the
        replica's [relevant
        sort](https://www.algolia.com/doc/guides/managing-results/refine-results/sorting/in-depth/relevant-sort).
      example:
        - category:Book
        - author:John Doe
      oneOf:
        - type: array
          items:
            $ref: '#/components/schemas/optionalFilters'
        - type: string
      x-categories:
        - Filtering
    page:
      type: integer
      description: Page of search results to retrieve.
      default: 0
      minimum: 0
      x-categories:
        - Pagination
    queryLanguages:
      type: array
      items:
        $ref: '#/components/schemas/supportedLanguage'
      example:
        - es
      description: >
        Languages for language-specific query processing steps such as plurals,
        stop-word removal, and word-detection dictionaries.

        This setting sets a default list of languages used by the
        `removeStopWords` and `ignorePlurals` settings.

        This setting also sets a dictionary for word detection in the
        logogram-based
        [CJK](https://www.algolia.com/doc/guides/managing-results/optimize-search-results/handling-natural-languages-nlp/in-depth/normalization/#normalization-for-logogram-based-languages-cjk)
        languages.

        To support this, place the CJK language **first**.

        **Always specify a query language.**

        If you don't specify an indexing language, the search engine uses all
        [supported
        languages](https://www.algolia.com/doc/guides/managing-results/optimize-search-results/handling-natural-languages-nlp/in-depth/supported-languages),

        or the languages you specified with the `ignorePlurals` or
        `removeStopWords` parameters.

        This can lead to unexpected search results.

        For more information, see [Language-specific
        configuration](https://www.algolia.com/doc/guides/managing-results/optimize-search-results/handling-natural-languages-nlp/in-depth/language-specific-configurations).
      default: []
      x-categories:
        - Languages
    relevancyStrictness:
      type: integer
      example: 90
      description: >
        Relevancy threshold below which less relevant results aren't included in
        the results

        You can only set `relevancyStrictness` on [virtual replica
        indices](https://www.algolia.com/doc/guides/managing-results/refine-results/sorting/in-depth/replicas/#what-are-virtual-replicas).

        Use this setting to strike a balance between the relevance and number of
        returned results.
      default: 100
      x-categories:
        - Ranking
    ruleContexts:
      type: array
      items:
        type: string
      description: >
        Assigns a rule context to the run query

        [Rule
        contexts](https://www.algolia.com/doc/guides/managing-results/rules/rules-overview/how-to/customize-search-results-by-platform/#whats-a-context)
        are strings that you can use to trigger matching rules.
      default: []
      example:
        - mobile
      x-categories:
        - Composition Rules
    sortBy:
      type: string
      description: >
        Indicates which sorting strategy to apply for the request.

        The value must match one of the labels defined in the "sortingStrategy"
        mapping. For example, "Price (asc)", see Upsert Composition.

        At runtime, this label is used to look up the corresponding index or
        replica configured in "sortingStrategy", and the query is executed using
        that index instead of main's.


        In addition to "sortingStrategy", this parameter is also used to apply a
        matching Composition Rule that contains a condition defined to trigger
        on "sortBy", see Composition Rules.


        If no value is provided or an invalid value, no sorting strategy is
        applied.
      default: ''
      example: Price (asc)
    userToken:
      type: string
      description: >
        Unique pseudonymous or anonymous user identifier.


        This helps with analytics and click and conversion events.

        For more information, see [user
        token](https://www.algolia.com/doc/guides/sending-events/concepts/usertoken).
      example: test-user-123
      x-categories:
        - Personalization
    searchForFacetValuesResults:
      type: object
      additionalProperties: false
      required:
        - facetHits
        - exhaustiveFacetsCount
        - indexName
      x-discriminator-fields:
        - facetHits
      properties:
        exhaustiveFacetsCount:
          type: boolean
          description: >
            Whether the facet count is exhaustive (true) or approximate (false).

            For more information, see [Why are my facet and hit counts not
            accurate](https://support.algolia.com/hc/articles/4406975248145-Why-are-my-facet-and-hit-counts-not-accurate).
        facetHits:
          type: array
          description: Matching facet values.
          items:
            title: facetHits
            type: object
            additionalProperties: false
            required:
              - value
              - highlighted
              - count
            properties:
              count:
                description: >-
                  Number of records with this facet value. [The count may be
                  approximated](https://support.algolia.com/hc/articles/4406975248145-Why-are-my-facet-and-hit-counts-not-accurate).
                type: integer
              highlighted:
                $ref: '#/components/schemas/highlightedValue'
              value:
                description: Facet value.
                example: Mobile phone
                type: string
        indexName:
          type: string
        processingTimeMS:
          $ref: '#/components/schemas/processingTimeMS'
    ErrorBase:
      description: Error.
      type: object
      x-keep-model: true
      additionalProperties: true
      properties:
        message:
          type: string
          example: Invalid Application-Id or API-Key
    aroundPrecisionFromValue:
      title: range objects
      type: array
      items:
        title: range
        type: object
        description: >-
          Range object with lower and upper values in meters to define custom
          ranges.
        properties:
          from:
            type: integer
            description: >-
              Lower boundary of a range in meters. The Geo ranking criterion
              considers all records within the range to be equal.
            example: 20
          value:
            type: integer
            description: >-
              Upper boundary of a range in meters. The Geo ranking criterion
              considers all records within the range to be equal.
    aroundRadiusAll:
      title: all
      type: string
      description: >-
        Return all records with a valid `_geoloc` attribute. Don't filter by
        distance.
      enum:
        - all
    externalInjectedItem:
      type: object
      description: |
        Contains a list of objects to inject from an external source.
      properties:
        items:
          type: array
          items:
            title: externalInjection
            type: object
            additionalProperties: false
            properties:
              objectID:
                type: string
                description: >-
                  An objectID injected from an external source and also present
                  in the targeted index.
              metadata:
                type: object
                additionalProperties: true
                description: >
                  User-defined key-values that will be added to the injected
                  item in the response.

                  This is identical to Hits metadata defined in Composition or
                  Composition Rule,

                  with the benefit of being set at runtime.
                example:
                  my-field: my-value
            required:
              - objectID
            example:
              objectID: my-object-1
              metadata':
                my-field: my-value
      required:
        - items
    insideBoundingBoxArray:
      type: array
      items:
        type: array
        minItems: 4
        maxItems: 4
        items:
          type: number
          format: double
      description: >
        Coordinates for a rectangular area in which to search.


        Each bounding box is defined by the two opposite points of its diagonal,
        and expressed as latitude and longitude pair:

        `[p1 lat, p1 long, p2 lat, p2 long]`.

        Provide multiple bounding boxes as nested arrays.

        For more information, see [rectangular
        area](https://www.algolia.com/doc/guides/managing-results/refine-results/geolocation/#filtering-inside-rectangular-or-polygonal-areas).
      example:
        - - 47.3165
          - 4.9665
          - 47.3424
          - 5.0201
        - - 40.9234
          - 2.1185
          - 38.643
          - 1.9916
      x-categories:
        - Geo-Search
    supportedLanguage:
      type: string
      description: ISO code for a supported language.
      enum:
        - af
        - ar
        - az
        - bg
        - bn
        - ca
        - cs
        - cy
        - da
        - de
        - el
        - en
        - eo
        - es
        - et
        - eu
        - fa
        - fi
        - fo
        - fr
        - ga
        - gl
        - he
        - hi
        - hu
        - hy
        - id
        - is
        - it
        - ja
        - ka
        - kk
        - ko
        - ku
        - ky
        - lt
        - lv
        - mi
        - mn
        - mr
        - ms
        - mt
        - nb
        - nl
        - 'no'
        - ns
        - pl
        - ps
        - pt
        - pt-br
        - qu
        - ro
        - ru
        - sk
        - sq
        - sv
        - sw
        - ta
        - te
        - th
        - tl
        - tn
        - tr
        - tt
        - uk
        - ur
        - uz
        - zh
    highlightedValue:
      type: string
      description: Highlighted attribute value, including HTML tags.
      example: <em>George</em> <em>Clo</em>oney
    processingTimeMS:
      type: integer
      description: Time the server took to process the request, in milliseconds.
      example: 20
  responses:
    BadRequest:
      description: Bad request or request arguments.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ErrorBase'
    FeatureNotEnabled:
      description: This feature is not enabled on your Algolia account.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ErrorBase'
    MethodNotAllowed:
      description: Method not allowed with this API key.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ErrorBase'
    IndexNotFound:
      description: Index not found.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ErrorBase'
  securitySchemes:
    appId:
      type: apiKey
      in: header
      name: x-algolia-application-id
      description: Your Algolia application ID.
    apiKey:
      type: apiKey
      in: header
      name: x-algolia-api-key
      description: >
        Your Algolia API key with the necessary permissions to make the request.

        Permissions are controlled through access control lists (ACL) and access
        restrictions.

        The required ACL to make a request is listed in each endpoint's
        reference.

````