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

# Test the reachability of clusters

> Test whether clusters are reachable or not.



## OpenAPI

````yaml specs/monitoring.yml get /1/reachability/{clusters}/probes
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/reachability/{clusters}/probes:
    get:
      tags:
        - monitoring-tag
      summary: Test the reachability of clusters
      description: Test whether clusters are reachable or not.
      operationId: getReachability
      parameters:
        - $ref: '#/components/parameters/Clusters'
      responses:
        '200':
          $ref: '#/components/responses/ReachabilityResponse'
        '400':
          $ref: '#/components/responses/BadRequestResponse'
      security: []
      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.GetReachabilityAsync("c1-de");

            // 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.GetReachability(client.NewApiGetReachabilityRequest(
              "c1-de"))
            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

            Map response = client.getReachability("c1-de");


            // 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.getReachability({ clusters: 'c1-de'
            });



            // 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.getReachability(clusters = "c1-de")



            // 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->getReachability(
                'c1-de',
            );



            // 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_reachability(
                clusters="c1-de",
            )



            # 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_reachability("c1-de")



            # 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.getReachability(
                clusters = "c1-de"
              ),
              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.getReachability(clusters: "c1-de")


            // print the response

            print(response)
        - lang: cURL
          label: curl
          source: |-
            curl --request GET \
              --url https://status.algolia.com/1/reachability/c1-de%2Cc2-de%2Cc3-de/probes \
              --header 'accept: application/json'
components:
  parameters:
    Clusters:
      name: clusters
      in: path
      required: true
      description: Subset of clusters, separated by commas.
      schema:
        type: string
        example: c1-de,c2-de,c3-de
  responses:
    ReachabilityResponse:
      description: OK
      content:
        application/json:
          schema:
            title: reachabilityResponse
            type: object
            additionalProperties:
              $ref: '#/components/schemas/Probes'
              x-additionalPropertiesName: cluster
          examples:
            Success:
              value:
                c16-de:
                  sdn-probe-frankfurt: false
                  monitoring-2: false
                  sdn-probe-awswest1: false
    BadRequestResponse:
      description: Bad Request.
      content:
        application/json:
          schema:
            title: badRequest
            type: object
            additionalProperties: false
            properties:
              reason:
                type: string
          examples:
            BadRequest:
              value:
                reason: Unknown servers
  schemas:
    Probes:
      title: probes
      description: Probes and their response.
      type: object
      additionalProperties:
        x-additionalPropertiesName: probe
        type: boolean
        description: >-
          Key-value pair with the probe name as the key and the reachability
          status as the value.

````