# Ping (/sdks/python/how-to/connection/ping)



## Overview [#overview]

A ping is a lightweight liveness check — you call it to confirm the broker is actually reachable before sending real traffic, without standing up a publisher, subscriber, or queue client just to find out. It's the tool of choice for startup readiness checks, container liveness/readiness probes, and connection-health dashboards that need a fast, cheap go/no-go signal.

`await client.ping()` issues a minimal gRPC health-check request to the server and returns a `ServerInfo` dataclass (host, version, uptime) confirming the broker answered. It works over the same connection regardless of which messaging pattern you use elsewhere on that client — events, queues, commands, or queries — and doesn't touch any channel.

**Gotchas:** a failed `ping()` doesn't close the client — the SDK's reconnect logic keeps retrying in the background, so catch the raised exception yourself rather than assume the client tears itself down. A successful ping only confirms the broker process answered, not that a specific channel or queue exists or has capacity. And since the gRPC channel is often established lazily, the first call you make is what actually triggers the connection, so a ping right after opening the client can still surface setup errors.

## Prerequisites [#prerequisites]

* KubeMQ server running on `localhost:50000`
* Python SDK installed (`pip install kubemq`)

## Code [#code]

```python title="ping.py"
"""Example: Ping — check server health and retrieve server information."""

from __future__ import annotations

import asyncio

from kubemq import AsyncQueuesClient


async def main() -> None:
    async with AsyncQueuesClient(
        address="localhost:50000",
        client_id="python-connection-ping-client",
    ) as client:
        server_info = await client.ping()
        print(f"Server host: {server_info.host}")
        print(f"Server version: {server_info.version}")
        print(f"Server uptime: {server_info.server_up_time_seconds}s")
        print(f"Server is reachable: True")


if __name__ == "__main__":
    asyncio.run(main())

```

## How It Works [#how-it-works]

`client.ping()` sends a gRPC health-check request and returns a `ServerInfo` dataclass. The fields printed here — `host`, `version`, and `server_up_time_seconds` — are all available on that object. The `async with` block ensures `close()` is called even if ping raises, so no connection is leaked.

## Related [#related]

* [Python SDK Reference](/sdks/python/reference)
* [Connect](/sdks/python/tutorials/connect)
* [Close](/sdks/python/how-to/connection/close)