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

# Retrieve servers

> Retrieves the servers that belong to clusters.

The response depends on whether you authenticate your API request:

* With authentication, the response lists the servers assigned to your
  Algolia application's cluster.

* Without authentication, the response lists the servers for all Algolia
  clusters.


## OpenAPI

````yaml specs/monitoring.yml get /1/inventory/servers
openapi: 3.1.0
info:
  title: Algolia Monitoring API
  summary: The Monitoring API lets you check the status of your Algolia infrastructure
  description: >
    The metrics exposed by this API are based on results from external
    monitoring probes checking Algolia’s infrastructure.

    These metrics **reflect the overall infrastructure status and don’t
    represent the performance of the specific APPID** used for authentication.


    ## Base URLs


    Base URL for the Monitoring API:


    - `https://status.algolia.com`


    **All requests must use HTTPS.**


    ## Availability and authentication


    Access to the Infrastructure endpoints

    is available as part of the [Premium or Elevate
    plans](https://www.algolia.com/pricing).


    To authenticate requests to the Infrastructure endpoints, add these headers:


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

    - `x-algolia-api-key`. Your Monitoring API key.


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


    Other endpoints don't require authentication.


    ## Response status and errors


    The Monitoring 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 Monitoring API is version 1, indicated by the
    `/1/` in each endpoint's URL.
  version: 1.0.0
servers:
  - url: https://status.algolia.com
security: []
tags:
  - name: incidents
    description: List the known incidents.
    x-displayName: Incidents
  - name: infrastructure
    description: >-
      Return information about the Algolia infrastructure used by your
      application.
    x-displayName: Infrastructure
  - name: monitoring-tag
    description: >-
      Report search and indexing times for your clusters, and get a list of
      servers.
    x-displayName: Monitoring
  - name: status
    description: Report the status of Algolia clusters.
    x-displayName: Status
paths:
  /1/inventory/servers:
    get:
      tags:
        - monitoring-tag
      summary: Retrieve servers
      description: |
        Retrieves the servers that belong to clusters.

        The response depends on whether you authenticate your API request:

        - With authentication, the response lists the servers assigned to your
        Algolia application's cluster.

        - Without authentication, the response lists the servers for all Algolia
        clusters.
      operationId: getServers
      responses:
        '200':
          $ref: '#/components/responses/InventoryResponse'
        '403':
          $ref: '#/components/responses/ForbiddenResponse'
      security:
        - appId: []
        - apiKey: []
      x-codeSamples:
        - lang: csharp
          label: C#
          source: |-
            // Initialize the client
            var client = new MonitoringClient(
              new MonitoringConfig("ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY")
            );

            // Call the API
            var response = await client.GetServersAsync();

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

            client, err := monitoring.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.GetServers()

            if err != nil {
              // handle the eventual error
              panic(err)
            }



            // print the response

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

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


            // Call the API

            InventoryResponse response = client.getServers();


            // print the response

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

            const client = algoliasearch('ALGOLIA_APPLICATION_ID',
            'ALGOLIA_API_KEY').initMonitoring();


            // Call the API

            const response = await client.getServers();



            // print the response

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

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


            // Call the API

            var response = client.getServers()



            // print the response

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

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


            // Call the API

            $response = $client->getServers();



            // print the response

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

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

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


            # Call the API

            response = client.get_servers()



            # print the response

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

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


            # Call the API

            response = client.get_servers



            # print the response

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

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


            // Call the API

            val response = Await.result(
              client.getServers(
              ),
              Duration(100, "sec")
            )


            // print the response

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

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


            // Call the API

            let response = try await client.getServers()


            // print the response

            print(response)
        - lang: cURL
          label: curl
          source: |-
            curl --request GET \
              --url https://status.algolia.com/1/inventory/servers \
              --header 'accept: application/json' \
              --header 'x-algolia-application-id: ZHVtbXkgYmluYXJ5IHNhbXBsZQA='
components:
  responses:
    InventoryResponse:
      description: OK
      content:
        application/json:
          schema:
            title: inventoryResponse
            type: object
            properties:
              inventory:
                type: array
                items:
                  $ref: '#/components/schemas/Server'
          examples:
            Success:
              value:
                inventory:
                  - name: c16-de-3
                    region: de
                    is_slave: false
                    is_replica: false
                    cluster: c16-de
                    status: PRODUCTION
                    type: cluster
                  - name: c16-de-2
                    region: de
                    is_slave: false
                    is_replica: false
                    cluster: c16-de
                    status: PRODUCTION
                    type: cluster
                  - name: c16-de-1
                    region: de
                    is_slave: false
                    is_replica: false
                    cluster: c16-de
                    status: PRODUCTION
                    type: cluster
    ForbiddenResponse:
      description: Forbidden
      content:
        application/json:
          schema:
            title: forbidden
            type: object
            additionalProperties: false
            properties:
              reason:
                type: string
          examples:
            Forbidden:
              value:
                reason: invalid credentials
  schemas:
    Server:
      title: server
      type: object
      additionalProperties: false
      properties:
        cluster:
          type: string
          description: Name of the cluster to which this server belongs.
          example: c16-de
        is_replica:
          type: boolean
          default: false
          description: Whether this server is a replica of another server.
          example: false
        is_slave:
          type: boolean
          default: false
          deprecated: true
          description: |
            Included to support legacy applications.
            Use `is_replica` instead.
          example: false
        name:
          type: string
          description: Server name.
          example: c16-de-1
        region:
          $ref: '#/components/schemas/Region'
        status:
          $ref: '#/components/schemas/ServerStatus'
        type:
          $ref: '#/components/schemas/Type'
    Region:
      title: region
      type: string
      description: Region where the cluster is located.
      enum:
        - au
        - br
        - ca
        - de
        - eu
        - hk
        - in
        - jp
        - sg
        - uae
        - uk
        - usc
        - use
        - usw
        - za
      example: de
    ServerStatus:
      title: status
      type: string
      enum:
        - PRODUCTION
    Type:
      title: type
      type: string
      enum:
        - cluster
  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 Monitoring API key.

````