C Python Shell Other
Failed to load latest commit information.
.github Added ISSUE_TEMPLATE Sep 11, 2017
docs Added ThrottleEvent to docs Jun 2, 2018
examples Complete HTTPS support for schema registry (#90) Jun 25, 2018
tests Complete HTTPS support for schema registry (#90) Jun 25, 2018
tools OpenSSL version bump to 1.0.2o (#410) Jun 26, 2018
.appveyor-disabled.yml Use cibuildwheel for building manylinux and osx wheels on travis Sep 4, 2017
.dir-locals.el Initial version Apr 14, 2016
.gitignore Run system test using Jenkins pipeline May 3, 2018
MANIFEST.in Include all licenses for binary wheels, and rename to LICENSE.txt Sep 8, 2017
Makefile Initial version Apr 14, 2016
README.md Add throttle_cb support (#237) (#377) Jun 2, 2018
setup.py Version v0.11.5rc5 Jun 26, 2018
test-requirements.txt bugfix: wrong invocation of SchemaParseException (#376) May 25, 2018
tox.ini Complete HTTPS support for schema registry (#90) Jun 25, 2018


Confluent's Python Client for Apache KafkaTM

confluent-kafka-python is Confluent's Python client for Apache Kafka and the Confluent Platform.


  • High performance - confluent-kafka-python is a lightweight wrapper around librdkafka, a finely tuned C client.

  • Reliability - There are a lot of details to get right when writing an Apache Kafka client. We get them right in one place (librdkafka) and leverage this work across all of our clients (also confluent-kafka-go and confluent-kafka-dotnet).

  • Supported - Commercial support is offered by Confluent.

  • Future proof - Confluent, founded by the creators of Kafka, is building a streaming platform with Apache Kafka at its core. It's high priority for us that client features keep pace with core Apache Kafka and components of the Confluent Platform.

The Python bindings provides a high-level Producer and Consumer with support for the balanced consumer groups of Apache Kafka >= 0.9.

See the API documentation for more info.

License: Apache License v2.0



from confluent_kafka import Producer

p = Producer({'bootstrap.servers': 'mybroker1,mybroker2'})

def delivery_report(err, msg):
    """ Called once for each message produced to indicate delivery result.
        Triggered by poll() or flush(). """
    if err is not None:
        print('Message delivery failed: {}'.format(err))
        print('Message delivered to {} [{}]'.format(msg.topic(), msg.partition()))

for data in some_data_source:
    # Trigger any available delivery report callbacks from previous produce() calls

    # Asynchronously produce a message, the delivery report callback
    # will be triggered from poll() above, or flush() below, when the message has
    # been successfully delivered or failed permanently.
    p.produce('mytopic', data.encode('utf-8'), callback=delivery_report)

# Wait for any outstanding messages to be delivered and delivery report
# callbacks to be triggered.

High-level Consumer:

from confluent_kafka import Consumer, KafkaError

c = Consumer({
    'bootstrap.servers': 'mybroker',
    'group.id': 'mygroup',
    'default.topic.config': {
        'auto.offset.reset': 'smallest'


while True:
    msg = c.poll(1.0)

    if msg is None:
    if msg.error():
        if msg.error().code() == KafkaError._PARTITION_EOF:

    print('Received message: {}'.format(msg.value().decode('utf-8')))



from confluent_kafka import avro
from confluent_kafka.avro import AvroProducer

value_schema_str = """
   "namespace": "my.test",
   "name": "value",
   "type": "record",
   "fields" : [
       "name" : "name",
       "type" : "string"

key_schema_str = """
   "namespace": "my.test",
   "name": "key",
   "type": "record",
   "fields" : [
       "name" : "name",
       "type" : "string"

value_schema = avro.loads(value_schema_str)
key_schema = avro.loads(key_schema_str)
value = {"name": "Value"}
key = {"name": "Key"}

avroProducer = AvroProducer({
    'bootstrap.servers': 'mybroker,mybroker2',
    'schema.registry.url': 'http://schem_registry_host:port'
    }, default_key_schema=key_schema, default_value_schema=value_schema)

avroProducer.produce(topic='my_topic', value=value, key=key)


from confluent_kafka import KafkaError
from confluent_kafka.avro import AvroConsumer
from confluent_kafka.avro.serializer import SerializerError

c = AvroConsumer({
    'bootstrap.servers': 'mybroker,mybroker2',
    'group.id': 'groupid',
    'schema.registry.url': ''})


while True:
        msg = c.poll(10)

    except SerializerError as e:
        print("Message deserialization failed for {}: {}".format(msg, e))

    if msg is None:

    if msg.error():
        if msg.error().code() == KafkaError._PARTITION_EOF:



See the examples directory for more examples, including how to configure the python client for use with Confluent Cloud.


NOTE: The pre-built Linux wheels do NOT contain SASL Kerberos/GSSAPI support. If you need SASL Kerberos/GSSAPI support you must install librdkafka and its dependencies using the repositories below and then build confluent-kafka from source.

Install self-contained binary wheels for OSX and Linux from PyPi:

$ pip install confluent-kafka

Install AvroProducer and AvroConsumer:

$ pip install confluent-kafka[avro]

Install from source from PyPi (requires librdkafka + dependencies to be installed separately):

$ pip install --no-binary :all: confluent-kafka

For source install, see Prerequisites below.

Broker Compatibility

The Python client (as well as the underlying C library librdkafka) supports all broker versions >= 0.8. But due to the nature of the Kafka protocol in broker versions 0.8 and 0.9 it is not safe for a client to assume what protocol version is actually supported by the broker, thus you will need to hint the Python client what protocol version it may use. This is done through two configuration settings:

  • broker.version.fallback=YOUR_BROKER_VERSION (default
  • api.version.request=true|false (default true)

When using a Kafka 0.10 broker or later you don't need to do anything (api.version.request=true is the default). If you use Kafka broker 0.9 or 0.8 you must set api.version.request=false and set broker.version.fallback to your broker version, e.g broker.version.fallback=

More info here: https://github.com/edenhill/librdkafka/wiki/Broker-version-compatibility


  • Python >= 2.7 or Python 3.x
  • librdkafka >= 0.11.5 (latest release is embedded in wheels)

librdkafka is embedded in the macosx manylinux wheels, for other platforms, SASL Kerberos/GSSAPI support or when a specific version of librdkafka is desired, following these guidelines:


$ python setup.py build

If librdkafka is installed in a non-standard location provide the include and library directories with:

$ C_INCLUDE_PATH=/path/to/include LIBRARY_PATH=/path/to/lib python setup.py ...


Run unit-tests:

In order to run full test suite, simply execute:

$ tox -r

NOTE: Requires tox (please install with pip install tox), several supported versions of Python on your path, and librdkafka installed into tmp-build.

Integration tests:

See tests/README.md for instructions on how to run integration tests.

Generate Documentation

Install sphinx and sphinx_rtd_theme packages:

$ pip install sphinx sphinx_rtd_theme

Build HTML docs:

$ make docs


$ python setup.py build_sphinx

Documentation will be generated in docs/_build/.