Connect Node.js to RabbitMQ with amqplib (2026)

Node.js and RabbitMQ: A Surprisingly Simple Dance

The most surprising thing about connecting Node.js to RabbitMQ is how little boilerplate is actually required once you understand the core concepts. You can have a basic producer and consumer running in under 50 lines of code, and the complexity ramps up elegantly, not exponentially.

Let’s see it in action. We’ll set up a simple scenario: a producer sending messages to a queue, and a consumer listening for those messages.

First, make sure you have RabbitMQ running. If you’re on macOS, brew install rabbitmq and brew services start rabbitmq is usually enough. On other systems, consult the RabbitMQ installation guide.

Next, install the amqplib library:

npm install amqplib

Now, let’s write the producer. This script will connect to RabbitMQ, assert a queue named my_queue, and send a message to it.

// producer.js
const amqp = require('amqplib');

async function produceMessage() {
    const connection = await amqp.connect('amqp://localhost');
    const channel = await connection.createChannel();

    const queue = 'my_queue';
    await channel.assertQueue(queue, { durable: false });
    const message = 'Hello, RabbitMQ!';

    channel.sendToQueue(queue, Buffer.from(message));
    console.log(` [x] Sent "${message}"`);

    setTimeout(() => {
        connection.close();
        process.exit(0);
    }, 500);
}

produceMessage();

Run this from your terminal: node producer.js. You should see [x] Sent "Hello, RabbitMQ!".

Now for the consumer. This script will connect, assert the same queue, and then start consuming messages from it.

// consumer.js
const amqp = require('amqplib');

async function consumeMessage() {
    const connection = await amqp.connect('amqp://localhost');
    const channel = await connection.createChannel();

    const queue = 'my_queue';
    await channel.assertQueue(queue, { durable: false });

    console.log(" [*] Waiting for messages in %s. To exit press CTRL+C", queue);

    channel.consume(queue, (msg) => {
        if (msg.content) {
            console.log(` [x] Received "${msg.content.toString()}"`);
        }
    }, { noAck: true }); // noAck: true means the message is acknowledged automatically
}

consumeMessage();

Run this in a separate terminal window: node consumer.js. You should see [*] Waiting for messages in my_queue. To exit press CTRL+C.

When you run the producer, the consumer will immediately pick up the message and print [x] Received "Hello, RabbitMQ!".

This demonstrates the fundamental pattern: connect to the broker, createChannel to interact with it, assertQueue to ensure your queue exists (idempotent, so safe to call repeatedly), and then either sendToQueue (for simple routing) or consume (to receive).

The amqp://localhost string is your connection URL. It specifies the protocol (amqp), hostname (localhost), and default port (5672). For more complex setups, you might see amqps:// for TLS, or include username/password: amqp://user:password@host:port/vhost.

assertQueue is crucial. If the queue doesn’t exist, it’s created. The { durable: false } option means the queue will be lost if RabbitMQ restarts. For persistent messages, you’d use { durable: true }.

sendToQueue is the simplest way to send. It implicitly routes to the default exchange, which then sends to the queue specified. For more advanced routing, you’d use publish with exchanges and routing keys.

channel.consume is where the magic happens. The callback function receives a message object. msg.content is a Buffer, so we toString() it. The noAck: true option is convenient for simple examples, but in production, you’ll want noAck: false and explicitly call channel.ack(msg) after processing to ensure messages aren’t lost if your consumer crashes.

The real power of RabbitMQ lies in its exchanges and binding. While sendToQueue uses the default exchange, you can create different types of exchanges (direct, topic, fanout, headers) and bind queues to them with specific routing keys. This allows for complex message routing patterns, like sending a message to multiple queues based on a pattern or to a specific queue based on a key.

Understanding how exchanges act as message distributors, and how bindings connect queues to exchanges with routing rules, is the next step in leveraging RabbitMQ effectively.