Step verbs reference

Every YAML step verb and field, derived from the authoritative source crates/camel-dsl/src/route_ast.rs. Each verb maps to a struct that Route structure.

Where a verb takes a predicate or value expression, the standard language fields apply: simple, rhai, jsonpath, xpath, or language paired with source. The tables below list them in full.

Step verbs

to

Send the exchange to an endpoint URI.

- to: "log:info"

log

Log the exchange state.

The message field accepts a bare string or an expression object (simple, rhai, jsonpath, xpath, or language+source). level is optional.

- log: "Processing exchange"
- log:
    message: "Body is ${body}"
    level: "DEBUG"

set_header

Set a message header.

- set_header:
    key: "MyHeader"
    value: "hello"

remove_header

Remove a message header from the input message. If the header is absent, the step does nothing (no error). Removal is input-only: output message headers are not changed.

- remove_header:
    key: "CamelHttpPath"

set_property

Set an exchange property. Same expression fields as set_header but keyed by name.

- set_property:
    name: "MyProperty"
    value: 42

set_body

Set the exchange body.

The config form accepts value plus any expression field (simple, rhai, jsonpath, xpath, language+source).

- set_body: "static value"
- set_body:
    value: "Hello World!"
- set_body:
    simple: "${header.foo}"

transform

Alias for set_body. Same forms and fields.

- transform:
    simple: "${body.field}"

filter

Conditionally run child steps. When the predicate is false, the exchange skips the steps list and continues down the pipeline.

- filter:
    simple: "${header.type} == 'important'"
    steps:
      - to: "log:important"

choice

Content-based router. Evaluates when clauses in order and runs the first that matches. otherwise runs when no clause matches.

- choice:
    when:
      - simple: "${header.type} == 'a'"
        steps:
          - to: "log:a"
      - simple: "${header.type} == 'b'"
        steps:
          - to: "log:b"
    otherwise:
      - to: "log:other"

do_try

Protected block with catch and finally clauses.

Each catch entry accepts exception (list of error kinds), when and on_when predicates, disposition (defaults to handled), and steps. The finally object carries an optional on_when and a required steps list.

- do_try:
    steps:
      - to: "direct:fragile"
    catch:
      - exception: ["ProcessorError"]
        steps:
          - to: "log:error"
    finally:
      steps:
        - to: "log:cleanup"

delay

Pause processing.

- delay: 500
- delay:
    delay_ms: 200
    dynamic_header: "X-Delay"

loop

Repeat child steps.

Full-form fields:

The while block accepts the standard predicate fields (simple, rhai, jsonpath, xpath, language+source).

- loop: 3
- loop:
    count: 5
    steps:
      - to: "log:iteration"

split

Split the body into fragments and process each.

- split:
    expression: "body_lines"
    aggregation: "last_wins"
    steps:
      - log: "Split item: ${body}"
      - to: "log:split-item"
- split:
    expression:
      simple: "${header.items}"
    aggregation: "collect_all"
    steps:
      - to: "log:fragment"

aggregate

Group exchanges by correlation key. Emits one combined exchange when a completion condition fires. The combined exchange then continues down the pipeline, so aggregate has no nested steps block.

- aggregate:
    header: "CorrelationId"
    completion_size: 10

marshal

Serialize the body to a data format.

- marshal: "json"

unmarshal

Parse the body from a data format. An optional schema validates the parsed JSON and rejects mismatches.

- unmarshal: "json"

convert_body_to

Convert the body type.

- convert_body_to: json

bean

Invoke a registered bean method.

- bean:
    name: "myBean"
    method: "handle"

script

Run a script inline.

- script:
    language: "rhai"
    source: "1 + 1"

function

Run a function in an external runtime.

- function:
    runtime: "deno"
    source: "export default (ctx) => ctx.body = { processed: true }"

stop

Stop route processing. The exchange returns to the consumer as a successful response.

- stop: true

stream_cache

Materialize a stream body into bytes.

- stream_cache: true
- stream_cache:
    threshold: 65536

wire_tap

Send a fire-and-forget copy of the exchange to another endpoint.

- wire_tap: "log:tap"

multicast

Fan the exchange out to multiple endpoints.

- multicast:
    steps:
      - to: "log:a"
      - to: "log:b"

scatter_gather

Fan out to a fixed set of endpoints and aggregate the results.

- scatter_gather:
    endpoints:
      - "log:a"
      - "log:b"

recipient_list

Resolve recipients from an expression and send to each.

- recipient_list:
    simple: "${header.recipients}"

routing_slip

Route through a list of endpoints carried on the exchange.

- routing_slip:
    simple: "${header.routeSlip}"

dynamic_router

Resolve the next endpoint at each step until the expression returns empty.

- dynamic_router:
    simple: "${header.nextEndpoint}"

throttle

Rate-limit the exchange flow.

- throttle:
    max_requests: 10
    steps:
      - to: "log:throttled"

load_balance

Distribute exchanges across target endpoints.

- load_balance:
    strategy: "round_robin"
    steps:
      - to: "log:a"
      - to: "log:b"

enrich

Enrich the exchange by requesting data from an endpoint.

The full form takes uri (required), strategy, and timeout.

- enrich: "http:my-service/api/data"
- enrich:
    uri: "http:my-service/api/data"
    strategy: "use_enriched_body"
    timeout: 5000

poll_enrich

Enrich the exchange by polling an endpoint. Same fields as enrich.

- poll_enrich: "file:data"

validate

Assert a predicate over the exchange. A failed assertion fails the exchange.

- validate: "${body.field} != null"

idempotent_consumer

Deduplicate exchanges by message ID.

- idempotent_consumer:
    repository: "memory"
    expression: "${header.messageId}"
    steps:
      - to: "log:first-time"

claim_check

Stash or retrieve the message body in a claim check repository.

- claim_check:
    repository: "memory"
    operation: "set"
    key: "${header.claimKey}"

cache

Cache a computed body by key with TTL. On hit, serves the cached body. On miss, runs the on_miss sub-pipeline and stores the result.

- cache:
    key: "${header.cacheKey}"
    ttl: "5s"
    on_miss:
      - set_body: "computed"

With coalesce_misses: true, concurrent misses on the same key run the on_miss sub-pipeline once. The first miss leads. The rest wait and share the leader's body and error.

cache_invalidate

Remove a single entry or a namespace from the cache repository. Set key for an exact-key removal or key_prefix for a namespace purge. Exactly one of the two is required.

On success the step sets the CamelCacheInvalidatedCount exchange property: 1 for an exact key, the removed count for a prefix. A backend without key iteration (memory) fails closed on key_prefix.

- cache_invalidate:
    key: "${header.cacheKey}"
- cache_invalidate:
    key_prefix: "user-profile-"

cache_clear

Remove every entry from the cache repository.

- cache_clear: {}
- cache_clear:
    repository: "persistent"

cache_stats

Replace the body with a JSON snapshot of the cache repository statistics.

- cache_stats: {}

The snapshot holds repository, hits, misses, evictions, entries, peek_stale_served, invalidations, and bytes. The bytes field is the stored payload size when the backend reports it (null for the memory backend).

cache_peek_stale

Serve a cached entry, ignoring its in-band expiry. Used as a stale-read fallback.

on_miss does not have the same meaning as the on_miss field of cache. In cache, the field holds a sub-pipeline. In cache_peek_stale, the field holds a policy word. Do not write a step list under cache_peek_stale.on_miss.

- cache_peek_stale:
    key: "${header.cacheKey}"
    on_miss: continue

sampling

Process one exchange out of every N.

- sampling: 5
- sampling:
    period: 10

sort

Sort the body array by a key expression.

- sort:
    expression: "${body.field}"
    reverse: true

resequence

Reorder exchanges by sequence number. Batch mode collects and sorts; stream mode is reserved for future use.

The completion object accepts size, timeout, and size_or_timeout.

- resequence:
    batch:
      correlation: "${header.seq}"
      sort: "asc"
      completion:
        size: 100
        timeout: 5000

Route-level config

These objects attach to a route. See Route structure for where each one goes.

Error handler config

Redelivery policy

OnException clause

Circuit breaker config

The fallback list holds a sub-pipeline of steps. The breaker runs it instead of rejecting the exchange while the circuit is open. See Circuit breaker for the full surface.

Security policy config

Choose exactly one form: roles, scopes, ref, wasm, or permission.

Top-level blocks

A route file also accepts these top-level keys alongside routes.

REST DSL

The rest key defines REST API blocks.

REST operation:

Operations bind in one of two modes. The default json mode accepts JSON-essence media types for consumes and produces: bare application/json, parameterized forms such as application/json; charset=utf-8, and +json suffixes such as application/problem+json. It unmarshals requests, marshals responses, and validates declared schemas automatically. Any other media type in json mode fails route load. The raw mode accepts any RFC 9110 type/subtype media type, leaves the request as Body::Stream with no automatic unmarshal or marshal, and sends the trimmed produces value as the response Content-Type. request_schema and response.schema are rejected in raw mode. The default success status is injected in both modes; a raw POST returns 201 with the declared produces type.

- method: post
  path: /ingest
  binding: raw
  consumes: application/octet-stream
  produces: text/plain
  to: direct:ingest

Raw binding streaming contract

raw operations own the stream semantics of their request and reply bodies. The contract:

• No pipeline caching. Lowering injects no unmarshal/marshal, so no StreamCacheService-wrapped processor compiles ahead of the user steps. The request Body::Stream reaches the first user step unpollied; the injected Content-Type and default-status steps never read it.
• Single consumption. The request stream is consumed at most once. A second consumption attempt fails with AlreadyConsumed and propagates as a route error — never a panic. A reply whose stream was already consumed returns HTTP 500 with an empty body.
• Metadata preservation. The HTTP consumer records the request Content-Type and Content-Length in the stream metadata before the exchange enters the route, and the pipeline never alters them.
• Original or new reply stream. A route may reply with the original request stream (echo) or a newly generated Body::Stream; both are streamed to the wire under the route-supplied Content-Type.
• Request limits fail closed. A request with Content-Length over max_request_body is rejected 413 before the stream opens. A chunked request over the cap fails with the limit error when consumed.
• Response limits cover materialized bytes only. max_response_body caps materialized reply bodies — an over-cap materialized reply is replaced with HTTP 500 (Response body exceeds configured limit). A streamed reply is not byte-capped: capping a stream mid-flight would truncate an already-committed response, so routes that need response caps must materialize the body first.
• Client disconnects do not fail the consumer. If a client drops the connection during a streamed reply, the server keeps serving subsequent requests.

Template declaration

Templated route instantiation

Reference: DSL crate