> ## Documentation Index
> Fetch the complete documentation index at: https://tatallo-docs.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Check that Tatallo is reachable

> Answers `200` whenever the Tatallo PMS API is up. Needs no key, so it tells a network
problem from an authentication problem. Rate-limited per client IP.




## OpenAPI

````yaml /openapi/tatallo-pms-v1.yaml get /v1/health
openapi: 3.1.0
info:
  title: Tatallo PMS API
  version: 1.0.0
  summary: >-
    The server-to-server API a PMS uses to list and read the Tatallo properties
    its hosts have connected.
  description: >
    The Tatallo PMS API is a small, read-only, server-to-server API. A PMS calls
    it with a

    Tatallo-issued PMS credential and sees exactly the properties its hosts have
    connected.


    - Every response carries an `X-Request-Id` header, always a UUID. Send your
    own UUID in
      `X-Request-Id` to have it echoed back.
    - Every error has the shape `{ "error": { "code", "message", "request_id" }
    }`. Messages
      are English and may change; codes never do.
    - Each PMS credential may make 60 requests per minute (`GET /v1/health`: 60
    per minute
      per client IP). Over the limit you get `429` with `Retry-After`.
    - Within `/v1` the contract changes only additively. A breaking change gets
    at least
      6 months' notice on the changelog.
  contact:
    name: Tatallo developer support
    email: developers@tatallo.com
servers:
  - url: https://api.tatallo.com
    description: Production
  - url: https://staging.api.tatallo.com
    description: Staging (synthetic properties only)
security:
  - PmsCredential: []
tags:
  - name: System
    description: Connectivity and the identity of your PMS credential.
  - name: Properties
    description: The Tatallo properties your hosts have connected to your PMS.
paths:
  /v1/health:
    get:
      tags:
        - System
      summary: Check that Tatallo is reachable
      description: >
        Answers `200` whenever the Tatallo PMS API is up. Needs no key, so it
        tells a network

        problem from an authentication problem. Rate-limited per client IP.
      operationId: getHealth
      responses:
        '200':
          description: Tatallo is reachable.
          headers:
            X-Request-Id:
              $ref: '#/components/headers/XRequestId'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Health'
              examples:
                ok:
                  summary: Tatallo is reachable
                  value:
                    status: ok
        '429':
          $ref: '#/components/responses/RateLimited'
      security: []
components:
  headers:
    XRequestId:
      description: >-
        The request's ID, on every response. Your own UUID if you sent a
        well-formed one in `X-Request-Id`, otherwise one Tatallo generated.
        Quote it to support.
      required: true
      schema:
        type: string
        format: uuid
    RetryAfter:
      description: Seconds to wait before the next request.
      required: true
      schema:
        type: integer
        minimum: 1
  schemas:
    Health:
      type: object
      additionalProperties: false
      required:
        - status
      properties:
        status:
          type: string
          enum:
            - ok
    RateLimitedError:
      allOf:
        - $ref: '#/components/schemas/Error'
        - type: object
          properties:
            error:
              type: object
              properties:
                code:
                  const: rate_limited
    Error:
      type: object
      additionalProperties: false
      required:
        - error
      description: >
        The one error shape. Branch on `code`: `unauthorized` (401),
        `insufficient_scope` (403),

        `property_not_found` (404), `invalid_cursor` (400), `invalid_limit`
        (400),

        `rate_limited` (429). `message` is English and may change; codes never
        do.
      properties:
        error:
          type: object
          additionalProperties: false
          required:
            - code
            - message
            - request_id
          properties:
            code:
              type: string
              description: A stable, snake_case error code.
            message:
              type: string
              description: >-
                An English explanation for people. May change; never branch on
                it.
            request_id:
              type: string
              format: uuid
              description: The same value as the `X-Request-Id` header.
  responses:
    RateLimited:
      description: Too many requests in the current minute. Wait for `Retry-After` seconds.
      headers:
        X-Request-Id:
          $ref: '#/components/headers/XRequestId'
        Retry-After:
          $ref: '#/components/headers/RetryAfter'
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/RateLimitedError'
          examples:
            rateLimited:
              summary: More than 60 requests in a minute
              value:
                error:
                  code: rate_limited
                  message: >-
                    Too many requests. Retry after the number of seconds in
                    Retry-After.
                  request_id: c2b7e1d4-8a3f-4e6b-9d2c-7f1a5e9b3c08
  securitySchemes:
    PmsCredential:
      type: http
      scheme: bearer
      description: >
        A PMS credential issued by Tatallo: an opaque key of the form
        `tat_<env>_sk_…`, where

        `<env>` is `stg` on staging and `live` on production. A key works only
        in its own

        environment. Send it as `Authorization: Bearer <key>`, from your servers
        only.

````

This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.