---
alias: user-guide-automation-task-rabbitMQ-publish-to-exchange
tags:
- automation tasks
- rabbitMQ
description: "This task publishes messages to a RabbitMQ exchange, directing data based on configured routing keys and exchange types"
---

# RabbitMQ Publish to Exchange

:iot-messagebus-send-lg:

This task publishes a message to a specified RabbitMQ exchange with a given routing key. It allows you to send data to different parts of your RabbitMQ infrastructure based on your configured exchanges and bindings.

![Publish to Exchange Task](../images/rabbitmq_publishtoexchange.png)

## Inputs

| Name                   | Data Type | Description                                                                                                          |
|------------------------|-----------|----------------------------------------------------------------------------------------------------------------------|
| Exchange Name          | `String`  | The name of the RabbitMQ exchange to publish the message to.                                                         |
| Exchange Type          | `String`  | The type of the exchange (e.g., `direct`, `topic`, `fanout`, `headers`). See **Settings** for details.               |
| Key                    | `String`  | The routing key to use when publishing the message.                                                                  |
| Message                | `String`  | The message content to be published to the exchange.                                                                 |
| Wait For Confirmation? | `Boolean` | If `true`, the task will wait for confirmation from RabbitMQ that the message has been received. Defaults to `true`. |
| Activate               | `any`     | Triggers the task to publish the message to the exchange.                                                            |

## Outputs

| Name    | Data Type | Description                                                                         |
|---------|-----------|-------------------------------------------------------------------------------------|
| Success | `Boolean` | Emits `true` when the message is successfully published (and optionally confirmed). |
| Error   | `Error`   | Emits an `Error` object if publishing the message fails.                            |

## Settings

On the *General Tab*, you have the usual settings and the following settings:

| Name                   | Data Type | Default           | Description                                                                                          |
|------------------------|-----------|-------------------|------------------------------------------------------------------------------------------------------|
| Exchange Name          | `String`  | `defaultExchange` | The identifier of RabbitMQ connection to use.                                                         |
| Exchange Type          | Enum      | `fanout`          | The type of the RabbitMQ exchange. Available options are: `direct`, `topic`, `fanout`, and `custom`. |
| Custom Exchange Type   | `String`  |                   | If **Exchange Type** is set to `custom`, you must specify the custom exchange type here.             |
| Key                    | `String`  | `defaultKey`      | The topic key to publish to.                                                                         |
| Message                | `String`  |                   | The message to be sent.                                                                              |
| Wait For Confirmation? | `Boolean` | false             | Should the system wait for confirmation.                                                             |

## Behavior

The `RabbitMQ Publish to Exchange` task sends a message to a RabbitMQ Exchange for a particular topic. It also supports sending a message and expecting a confirmation from the RabbitMQ when `Wait For Confirmation?` is set to true.

When the `Activate` input is triggered, this task retrieves the configured exchange name, exchange type (potentially using the custom type if specified), routing key, and message from its input properties.

 The `Wait For Confirmation?` setting determines whether the task waits for an acknowledgement from the RabbitMQ broker before emitting the `Success` output.

If the message is published successfully (and confirmed if `Wait For Confirmation` is `true`), the `Success` output emits `true`. If any error occurs during the publishing process (e.g., connection issues with RabbitMQ, invalid exchange name, routing errors), the `error` output will emit an `Error` object containing details about the failure.

## Remarks

* This task is fundamental for sending messages within a RabbitMQ-based system. By configuring the exchange name, type, and routing key, you can precisely control where your messages are delivered.

* Understanding the different RabbitMQ exchange types (`direct`, `topic`, `fanout`, `headers`) is crucial for correctly configuring this task.

    * **Direct:** Messages are routed to the queue(s) whose binding key exactly matches the routing key of the message.
    * **Topic:** Messages are routed to the queue(s) whose binding key matches a pattern. The routing key and binding key can contain wildcards (`*` for a single word, `#` for zero or more words).
    * **Fanout:** Messages are routed to all queues that are bound to the exchange, regardless of the routing key.
    * **Headers:** Messages are routed based on the headers attributes in the message. This type is less common and not directly exposed as a standard option in the settings but can be used via the "custom" exchange type if needed.

* The "Custom Exchange Type" setting allows you to use exchange types not explicitly listed (like `headers` or any custom exchange type your RabbitMQ server might have).
* Enabling "Wait for Confirmation" adds a layer of reliability, ensuring that your task is aware if a message was successfully received by the broker. However, it can slightly impact performance due to the added network round-trip.
* It's important to handle the `error` output of this task to gracefully manage potential issues with RabbitMQ connectivity or message routing.