# Service status

**GET /status**

Whether the API is serving, what it depends on to serve, and which
contract version it is currently on. Reaching this operation at all
proves the process is up and routing; `status` and `dependencies` say
whether it is up in a useful sense.

Every check is shallow. It proves that a dependency answers, not that
it answers correctly, so read a `down` as a reason to stop retrying and
never an `up` as a guarantee that a write elsewhere will land.

The answer is deliberately coarse. Because this operation is
unauthenticated, it reports capability names and states and nothing
else: no vendor, no free text, and no distinction between a dependency
that failed its probe and one this deployment cannot reach at all.

Unauthenticated, and the one operation that ignores `Commune-Version`,
since it describes the service rather than a resource. Because it takes
no credential there is no key to count against, so the per-key budgets
described under Rate limits do not apply to it and it carries no
`RateLimit-*` headers. It can still be refused by whatever sits in front
of this service, which is why the `429` stays declared.



## Servers
- Production. There is no separate sandbox host.
: https://api.usecommune.com (Production. There is no separate sandbox host.
)



## Parameters




## Responses
### 200
The service is serving traffic. Read `status` before trusting it to
serve every operation: a `200` here reports a degradation rather
than hiding it.


#### Body: application/json (object)
- **object** (string)
  Always `service_status`.

- **status** (string)
  The whole service in one word, driven by the required dependencies
  alone. `ok` when every required dependency is up, `degraded` when
  one answered slowly or partially, and `down` when one is
  unreachable. A `degraded` service still answers `200` here, because
  the point of this operation is to say so.

  An optional dependency being `down` does not move this. Every
  operation in the current contract is a read served out of the
  database, so none of them depends on one. Read `dependencies` for
  the individual states.

- **version** (string(date))
  The newest contract version this service serves, as a release date.
  A request that sends no `Commune-Version` header is not
  necessarily on it: an existing key stays pinned to the version that
  was current when it was issued. Compare the two to find out whether
  an integration has a newer contract available to move to.

- **dependencies** (array[object])
  Every dependency the API checks, whatever its state. The set is
  fixed by this contract rather than by the deployment, so the list
  is the same length on every response from every environment. Order
  is not meaningful; match on `name`.


### 429
Too many requests. Back off and retry after the interval named by the
`Retry-After` response header.

#### Headers

- **Retry-After** (integer)
  Seconds to wait before retrying.


#### Body: application/json (object)
- **error** (object)


### 500
Something failed inside Commune. The request may be retried.

#### Body: application/json (object)
- **error** (object)



[Powered by Bump.sh](https://bump.sh)