Hazelcast Python Client

PyPI Github Repository Join the community on Slack License

Hazelcast is an open-source distributed in-memory data store and computation platform that provides a wide variety of distributed data structures and concurrency primitives.

Hazelcast Python client is a way to communicate to Hazelcast IMDG clusters and access the cluster data. The client provides a Future-based asynchronous API suitable for wide ranges of use cases.



import hazelcast

# Connect to Hazelcast cluster.
client = hazelcast.HazelcastClient()

# Get or create the "distributed-map" on the cluster.
distributed_map = client.get_map("distributed-map")

# Put "key", "value" pair into the "distributed-map" and wait for
# the request to complete.
distributed_map.set("key", "value").result()

# Try to get the value associated with the given key from the cluster
# and attach a callback to be executed once the response for the
# get request is received. Note that, the set request above was
# blocking since it calls ".result()" on the returned Future, whereas
# the get request below is non-blocking.
get_future = distributed_map.get("key")
get_future.add_done_callback(lambda future: print(future.result()))

# Do other operations. The operations below won't wait for
# the get request above to complete.

print("Map size:", distributed_map.size().result())

# Shutdown the client.

If you are using Hazelcast IMDG and the Python client on the same machine, the default configuration should work out-of-the-box. However, you may need to configure the client to connect to cluster nodes that are running on different machines or to customize client properties.


import hazelcast

client = hazelcast.HazelcastClient(
        lambda state: print("Lifecycle event >>>", state),

print("Connected to cluster")

See the API documentation of hazelcast.client.HazelcastClient to learn more about supported configuration options.


  • Distributed, partitioned and queryable in-memory key-value store implementation, called Map

  • Eventually consistent cache implementation to store a subset of the Map data locally in the memory of the client, called Near Cache

  • Additional data structures and simple messaging constructs such as Set, MultiMap, Queue, Topic

  • Cluster-wide unique ID generator, called FlakeIdGenerator

  • Distributed, CRDT based counter, called PNCounter

  • Distributed concurrency primitives from CP Subsystem such as FencedLock, Semaphore, AtomicLong

  • Integration with Hazelcast Cloud

  • Support for serverless and traditional web service architectures with Unisocket and Smart operation modes

  • Ability to listen to client lifecycle, cluster state, and distributed data structure events

  • and many more