# Kafka SDK list

*Find the right Kafka client library for your programming language in 10 minutes*

Apache Kafka only officially provides a Java SDK. For other languages, community implementations are available with varying levels of maturity and feature support.

**What you'll learn:**
- How to evaluate Kafka client libraries
- Recommended libraries by programming language
- Key considerations: librdkafka, Schema Registry support, security

> **Feedback?**
> Something looks wrong? Send us an email at feedback [at] conduktor [dot] io

---

## How to choose a Kafka client library

![Decision flowchart for evaluating a Kafka client library: first decide pure (easier deployment, no native dependencies) versus librdkafka-based (high performance, build complexity); then check Schema Registry support (yes means verify Avro/JSON/Protobuf, no means custom serializers may be needed); then review security mechanisms; finally test performance](https://www.conduktor.io/assets/kafka/diagrams/kafka-sdk-list.svg)

```mermaid
flowchart TD
    Start["Evaluate library"] --> Q1{{"Pure or librdkafka<br/>based?"}}

    Q1 -->|"Pure"| Pure["Easier deployment<br/>No native dependencies"]
    Q1 -->|"librdkafka"| Lib["High performance<br/>Build complexity"]

    Pure --> Q2{{"Schema Registry<br/>support?"}}
    Lib --> Q2

    Q2 -->|"Yes"| Schema["Check Avro/JSON/Protobuf"]
    Q2 -->|"No"| NoSchema["May need custom serializers"]

    Schema --> Q3{{"Security mechanisms?"}}
    NoSchema --> Q3

    Q3 --> Final["Test performance"]
```

| Consideration | What to check |
|---------------|---------------|
| Implementation type | Pure vs [librdkafka](https://github.com/edenhill/librdkafka) wrapper (affects deployment) |
| Security | SSL, SASL (PLAIN, SCRAM, GSSAPI, OAUTHBEARER, MSK IAM) |
| Schema Registry | Confluent Schema Registry support (Avro, JSON, Protobuf) |
| Performance | Benchmark with realistic workloads |

---

## Kafka client libraries SDK list

Here you can find a list of libraries that has been compiled to ensure you have some pointers on when to start with your implementation:

*   Java

    *   [The official client library](https://mvnrepository.com/artifact/org.apache.kafka/kafka-clients): low-level client

    *   [The official Kafka Streams client library](https://mvnrepository.com/artifact/org.apache.kafka/kafka-streams): to create your Kafka Streams application

    *   [Kafka for Spring Boot](https://spring.io/projects/spring-kafka): applies Spring concepts to Kafka development

    *   [Spring Cloud Stream](https://spring.io/projects/spring-cloud-stream): bindings for Kafka Stream

    *   [Akka Streams](https://doc.akka.io/docs/akka/current/stream/index.html) & [Alpakka Kafka](https://doc.akka.io/docs/alpakka-kafka/current/home.html)

*   Scala

    *   [FS2 Kafka](https://fd4s.github.io/fs2-kafka/): Functional Kafka Producer and Consumer

    *   [ZIO Kafka](https://github.com/zio/zio-kafka): Kafka Client for ZIO

    *   [Kafka Streams Scala](https://mvnrepository.com/artifact/org.apache.kafka/kafka-streams-scala): the official kafka-streams library has Scala [since Kafka 2.0](https://issues.apache.org/jira/browse/KAFKA-6670)

    *   [Alpakka Kafka](https://doc.akka.io/docs/alpakka-kafka/current/home.html)

*   C/C++

    *   [librdkafka](https://github.com/edenhill/librdkafka): low-level implementation of the Kafka client, many other higher level language libraries are a wrapper around this library. Supports all kind of security, and [most KIPs](https://github.com/edenhill/librdkafka/blob/master/INTRODUCTION.md#supported-kips)

    *   [CPP Kafka](https://github.com/mfontanini/cppkafka): based on librdkafka

    *   [Modern CPP Kafka](https://github.com/morganstanley/modern-cpp-kafka): based on librdkafka

*   Golang

    *   [Confluent Kafka Go](https://github.com/confluentinc/confluent-kafka-go): wrapper of librdkafka, currently [no Schema Registry support](https://github.com/confluentinc/confluent-kafka-go/issues/69)

    *   [Schema Registry Client for Go](https://github.com/riferrei/srclient): compatible with Confluent Kafka Go

    *   [Segment's Kafka Go](https://github.com/segmentio/kafka-go): pure Go implementation of the Kafka Client, good support

    *   [Franz Go](https://github.com/twmb/franz-go): Pure go implementation, supports most KIPs

    *   others if you're curious: [Sarama](https://github.com/Shopify/sarama), [Goka](https://github.com/lovoo/goka)

*   Python

    *   [Confluent Kafka Python](https://github.com/confluentinc/confluent-kafka-python): based on librdkafka, includes an Admin client, Avro support with the Confluent Schema Registry

    *   [Kafka Python](https://github.com/dpkp/kafka-python): not active, use at your own risk

*   Javascript / Node.js

    *   [KafkaJS](https://kafka.js.org/): no external dependencies, good performance, support for [Schema Registry](https://github.com/kafkajs/confluent-schema-registry)

    *   [Blizzard Node rdkafka](https://github.com/Blizzard/node-rdkafka): Node.js wrapper for librdkafka, low maintenance activity

*   .NET / C#

    *   [Confluent Kafka DotNet](https://github.com/confluentinc/confluent-kafka-dotnet): wrapper around librdkafka, full Schema Registry support (Avro, JSON, Protobuf)

*   Rust

    *   [Rust rdkafka](https://github.com/fede1024/rust-rdkafka): Rust wrapper for librdkafka, good performance

    *   [Rust Schema Registry Converter](https://github.com/gklijs/schema_registry_converter): compatible with Rust rdkafka

    *   [Kafka Rust](https://github.com/kafka-rust/kafka-rust): pure Rust implementation, low maintenance activity

*   REST API

    *   [Confluent REST Proxy](https://github.com/confluentinc/kafka-rest): REST API for Kafka. Deploy with a reverse proxy sidecar to implement the security mechanism you need. Historically needed, but now that client library support for Kafka is quite good, you migh not have a use case for it.

*   Kotlin

    *   simply use the standard Java library

*   Haskell

    *   [HW Kafka Client](https://github.com/haskell-works/hw-kafka-client): based on librdkafka

    *   [HW Kafka Avro](https://github.com/haskell-works/hw-kafka-avro): support for Schema Registry

*   Ruby

    *   [rdkafka-ruby](https://github.com/appsignal/rdkafka-ruby): based on librdkafka

    *   [Ruby Kafka](https://github.com/zendesk/ruby-kafka): limited support for new API

> **See it in practice with Conduktor**
> [Conduktor Console](https://docs.conduktor.io/guide/manage-kafka) works with applications built in any language. Use it to inspect messages, monitor consumer groups, and debug your Kafka applications regardless of which SDK you choose.

## Next steps

- [Set up a Java project](https://www.conduktor.io/kafka/java-kafka-programming) with Kafka dependencies
- [Build a producer](https://www.conduktor.io/kafka/complete-kafka-producer-with-java) in Java
- [Build a consumer](https://www.conduktor.io/kafka/complete-kafka-consumer-with-java) in Java