cloudparts

Apache Camel

A Java integration framework that moves and transforms messages between systems with routes built from Enterprise Integration Patterns, written in Java, XML or YAML, with over 350 connectors.

Apache · Top-level project
What it is
ETL & ELT pipelines
Type
Open source
Made by
Apache Software Foundation
Foundation
The Apache Software Foundation, top-level project
License
Apache 2.0
Facts checked
24 October 2026
Website Source code

What it is

Camel is a library, not a server: it runs inside your Java application, a Spring Boot or Quarkus service, or from the camel command line built on JBang. A CamelContext holds routes. Each route has exactly one input endpoint and any number of outputs, and endpoints are written as URIs such as kafka:orders, aws2-s3://bucket, jms:queue:invoices or timer:tick?period=1s; the part before the colon picks a component, the plugin that knows how to talk to that system. Between input and output, processors implement the Enterprise Integration Patterns from Hohpe and Woolf’s 2003 book: content-based routers, message filters, splitters, aggregators, content enrichers, idempotent consumers, dead-letter channels and dozens more, each with the same name in every DSL. Pluggable data formats convert message bodies, and expression languages such as Simple read headers and bodies.

Where NiFi gives you a drawn graph on a server, Camel gives you code that lives in your repository and deploys like any other service. Around the core sit Camel Spring Boot and Camel Quarkus for running routes as microservices, Kamelets (reusable, parameterised route snippets used as connectors), the Camel Kafka Connector, which exposes Camel components as Kafka Connect connectors, Camel K for running integrations on Kubernetes, and Karavan, a visual designer for routes. Camel 4.23.0 came out in October 2026 and runs on Java 17, 21 or 25; 4.22 and 4.18 are long-term-support lines.

Why teams pick it

  • A very large catalogue of components, from HTTP, JMS, Kafka and S3 to SaaS APIs, files and databases, all used through the same URI and route model
  • Integration patterns such as splitting, aggregation, retries and dead-letter handling come built in, with consistent names across Java, XML and YAML
  • Routes are code: they live in Git, are reviewed and unit-tested, and run inside an ordinary Spring Boot or Quarkus service
  • Small embeddable core that scales from a CLI script to many microservices

Watch out for

  • A Java ecosystem: you need a JVM, and Java skills to debug, extend or tune it
  • Each route runs where you deploy it; there is no central server with back pressure, queues on disk or provenance like NiFi’s, so durability depends on the brokers you route through
  • The breadth is also a learning curve: hundreds of components, several DSLs and runtimes, and many subprojects to choose between
  • Frequent releases; staying supported means tracking the LTS lines (in October 2026, 4.18 until February 2027 and 4.22 until August 2027)

Specs

Compare with alternatives →
Written in
Java
Ways to run it
A library in Java apps, Spring Boot or Quarkus; Camel K on Kubernetes; JBang CLI

Alternatives

What all etl & elt pipelines have in common →Compare side by side →
Apache NiFiOpen sourceA Java dataflow server you program by drawing a graph of processors in a web UI, with buffered queues, back pressure and a record of where every piece of data went.Redpanda ConnectRenamedOpen sourceFormerly Benthos: one Go binary that runs a YAML pipeline of inputs, processors and outputs, with at-least-once delivery and no disk state of its own.AirbyteCommercialAn ELT platform you can host yourself: hundreds of connectors, each a Docker image speaking one JSON protocol, scheduled by services on Kubernetes.MeltanoOpen sourceA command-line ELT tool that runs Singer taps and targets from a meltano.yml project kept in git.OLakeOpen sourceAn open-source tool in Go that copies databases, Kafka topics and S3 files into Apache Iceberg tables (or plain Parquet), with full loads, incremental syncs and CDC, and no Kafka, Debezium, Spark or Flink in between.DebeziumOpen sourceOpen-source change data capture: connectors that read a database’s transaction log and emit every committed insert, update and delete as an event, usually into Kafka.StreambedPreviewOpen sourceA small Go program that copies Postgres changes into Iceberg or DuckLake tables on S3 through logical replication, and answers SQL over them through a Postgres-compatible server built on DuckDB.

How it fits with other technologies

A YAML route: filter messages and log both paths (run it with `camel run route.yaml`) · yaml

- route:
    from:
      uri: "direct:start"
      steps:
        - filter:
            expression:
              simple: "${in.header.continue} == true"
            steps:
              - to:
                  uri: "log:filtered"
        - to:
            uri: "log:original"

See it in a real stack

No architecture uses Apache Camel yet. Drop it into the playground and wire it up yourself.Open playground →
Where it came from2003–2026

Gregor Hohpe and Bobby Woolf’s book Enterprise Integration Patterns (Addison-Wesley, 2003) named 65 recurring ways that messages are routed, split, merged and transformed between systems, and spurred a generation of open-source integration products. James Strachan checked in the first code of the Camel routing library on 19 March 2007, inside the Apache ActiveMQ project’s repository: the patterns as a small Java library with a routing DSL, rather than a separate server.

Camel became a top-level Apache project in December 2008. Camel 2.0 followed in August 2009 and 3.0 in November 2019. Camel 4.0, published in August 2023 as a long-term-support release, required Java 17, moved from javax to Jakarta EE 10 APIs and targeted Spring Boot 3 and Quarkus 3. The project now ships a feature release roughly every month or two, with two LTS lines supported at a time.

Why it’s built this way

A library, not a server
Integration usually meant deploying an enterprise service bus; a small library with few dependencies lets the same patterns run inside any Java application, test or container.
Endpoints as URIs
A URI names both the component and its options in one string, and the API is the same whatever the transport, so switching from files to S3 or from JMS to Kafka changes the URI, not the route.
Name things after Enterprise Integration Patterns
A shared vocabulary from the book makes routes readable across teams, and every DSL uses the same pattern names.

Timeline

  1. 2003

    Hohpe and Woolf publish Enterprise Integration Patterns

  2. 2007

    James Strachan checks in the Camel routing library on 19 March, inside ActiveMQ’s repository

  3. 2008

    Becomes a top-level Apache project in December

  4. 2009

    Camel 2.0 in August

  5. 2019

    Camel 3.0 in November

  6. 2023

    Camel 4.0 in August: Java 17, Jakarta EE 10, Spring Boot 3

  7. 2026

    Camel 4.23.0 in October, supporting Java 25

Sources8 · facts checked 24 October 2026

Improve this page on GitHub