<!-- BusyBot node reference — https://busybot.net/tools/aws-sqs/ -->

> Node: AWS SQS (`aws_sqs`) · Action · v1
> Category: Communication · Credentials: AWS SQS (`awsSqsApi`)
> Updated: 2026-08-16

# AWS SQS

> Send, receive, and manage messages in Amazon SQS queues.

## Overview

AWS SQS (Simple Queue Service) is a fully managed message queuing service. This tool supports sending messages (including batch), receiving messages, deleting messages, purging queues, getting queue attributes, listing queues, creating queues, and deleting queues. Supports both Standard and FIFO queues with message attributes, deduplication IDs, and message group IDs.

**Category:** Communication  
**Tool Name:** `aws_sqs`  
**Version:** 1

**Appearance:** Icon: `lucide-MessageSquare` | Color: `#FF9900`

## Node Type

**Action** — processes input items and produces output

## Input / Output

| Direction | Port(s) |
|-----------|--------|
| Input | `Input` |
| Output | `Output`, `Error` |

## Credentials

This tool requires **AWS SQS** credentials.
See the [Credentials Guide](https://busybot.net/credentials/aws-sqs-api/) for setup instructions.

### Operations

| Operation | Value | Description |
|-----------|-------|-------------|
| Send Message | `sendMessage` | Send a message to a queue |
| Send Message Batch | `sendMessageBatch` | Send up to 10 messages in a single batch |
| Receive Message | `receiveMessage` | Receive messages from a queue |
| Delete Message | `deleteMessage` | Delete a message from a queue |
| Purge Queue | `purgeQueue` | Delete all messages in a queue |
| Get Queue Attributes | `getQueueAttributes` | Get attributes of a queue |
| List Queues | `listQueues` | List all SQS queues |
| Create Queue | `createQueue` | Create a new SQS queue |
| Delete Queue | `deleteQueue` | Delete an SQS queue |

### Parameters

#### Send Message (`sendMessage`)

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| Queue URL | `string` | Yes | — | The full URL of the SQS queue (e.g. https://sqs.us-east-1.amazonaws.com/123456789012/my-queue). Find in the AWS Console under SQS > Queues. Supports expressions. |
| Queue Type | `options` | No | `standard` | The type of queue. FIFO queues require MessageGroupId and optionally MessageDeduplicationId. |
| | | | | Options: `standard` (best-effort ordering, at-least-once delivery), `fifo` (exactly-once processing, strict ordering) |
| Send Input Data | `boolean` | No | `true` | Whether to send the input item JSON as the message body. When false, use the Message parameter instead. |
| Message | `string` | Yes | — | The message body to send to the queue. _(shown when Send Input Data is `false`)_ |
| Message Group ID | `string` | Yes | — | Tag that specifies that a message belongs to a specific message group. Required for FIFO queues. _(shown when Queue Type is `fifo`)_ |

#### Send Message Batch (`sendMessageBatch`)

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| Queue URL | `string` | Yes | — | The full URL of the SQS queue (e.g. https://sqs.us-east-1.amazonaws.com/123456789012/my-queue). Find in the AWS Console under SQS > Queues. Supports expressions. |
| Queue Type | `options` | No | `standard` | The type of queue. FIFO queues require MessageGroupId and optionally MessageDeduplicationId. |
| | | | | Options: `standard` (best-effort ordering, at-least-once delivery), `fifo` (exactly-once processing, strict ordering) |
| Message Group ID | `string` | Yes | — | Tag that specifies that a message belongs to a specific message group. Required for FIFO queues. _(shown when Queue Type is `fifo`)_ |

#### Receive Message (`receiveMessage`)

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| Queue URL | `string` | Yes | — | The full URL of the SQS queue (e.g. https://sqs.us-east-1.amazonaws.com/123456789012/my-queue). Find in the AWS Console under SQS > Queues. Supports expressions. |

#### Delete Message (`deleteMessage`)

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| Queue URL | `string` | Yes | — | The full URL of the SQS queue (e.g. https://sqs.us-east-1.amazonaws.com/123456789012/my-queue). Find in the AWS Console under SQS > Queues. Supports expressions. |
| Receipt Handle | `string` | Yes | — | The receipt handle of the message to delete. Obtained from a previous ReceiveMessage call. |

#### Purge Queue (`purgeQueue`)

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| Queue URL | `string` | Yes | — | The full URL of the SQS queue (e.g. https://sqs.us-east-1.amazonaws.com/123456789012/my-queue). Find in the AWS Console under SQS > Queues. Supports expressions. |

#### Get Queue Attributes (`getQueueAttributes`)

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| Queue URL | `string` | Yes | — | The full URL of the SQS queue (e.g. https://sqs.us-east-1.amazonaws.com/123456789012/my-queue). Find in the AWS Console under SQS > Queues. Supports expressions. |

#### List Queues (`listQueues`)

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| Queue Prefix | `string` | No | — | Filter queues whose name begins with this prefix. |

#### Create Queue (`createQueue`)

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| Queue Name | `string` | Yes | — | The name for the new queue. FIFO queue names must end with ".fifo". |
| Queue Type | `options` | No | `standard` | The type of queue. FIFO queues require MessageGroupId and optionally MessageDeduplicationId. |
| | | | | Options: `standard` (best-effort ordering, at-least-once delivery), `fifo` (exactly-once processing, strict ordering) |

#### Delete Queue (`deleteQueue`)

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| Queue URL | `string` | Yes | — | The full URL of the SQS queue (e.g. https://sqs.us-east-1.amazonaws.com/123456789012/my-queue). Find in the AWS Console under SQS > Queues. Supports expressions. |

#### All Operations

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| Region | `string` | No | — | AWS region override. If empty, uses the region from credentials. |
| Options | `collection` | No | `{}` | Additional configuration options. Which of them apply depends on the operation. |
| — Delay Seconds | `number` | No | `0` | The number of seconds to delay message delivery. Only for standard queues (0-900). _(shown when Operation is `sendMessage`, `sendMessageBatch` and Queue Type is `standard`)_ |
| — Message Deduplication ID | `string` | No | — | Token used for deduplication of sent messages. Only for FIFO queues. _(shown when Operation is `sendMessage`, `sendMessageBatch` and Queue Type is `fifo`)_ |
| — Message Attributes | `fixedCollection` | No | `{}` | Custom attributes to attach to the message. _(shown when Operation is `sendMessage`, `sendMessageBatch`)_ |
| — — String: Name | `string` | No | — | Name of the attribute |
| — — String: Value | `string` | No | — | String value of the attribute |
| — — Number: Name | `string` | No | — | Name of the attribute |
| — — Number: Value | `number` | No | `0` | Number value of the attribute |
| — Max Number of Messages | `number` | No | `1` | Maximum number of messages to receive (1-10). _(shown when Operation is `receiveMessage`)_ |
| — Visibility Timeout | `number` | No | `30` | Duration (in seconds) that received messages are hidden from subsequent receive requests (0-43200). _(shown when Operation is `receiveMessage`)_ |
| — Wait Time Seconds | `number` | No | `0` | Duration (in seconds) for long polling. 0 = short polling (0-20). _(shown when Operation is `receiveMessage`)_ |
| — Receive Message Attributes | `boolean` | No | `false` | Whether to include custom message attributes in received messages. _(shown when Operation is `receiveMessage`)_ |
| — Create Queue Attributes | `json` | No | `{}` | JSON object of queue attributes for createQueue. Keys: DelaySeconds, MaximumMessageSize, MessageRetentionPeriod, ReceiveMessageWaitTimeSeconds, VisibilityTimeout, FifoQueue, ContentBasedDeduplication, etc. _(shown when Operation is `createQueue`)_ |
| Max Concurrency | `number` | No | `10` | Maximum number of items to process concurrently. |

## Output Data

One output item per input item. The SQS response is merged into the item JSON — the incoming fields pass through and binary data is forwarded — so a field the response does not set keeps whatever the upstream node put there.

| Operation | Fields added to the item |
|-----------|--------------------------|
| `sendMessage` | `MessageId`, `MD5OfMessageBody`, `MD5OfMessageAttributes`, and `SequenceNumber` on FIFO queues |
| `sendMessageBatch` | `Successful` (one entry per accepted message) and `Failed` (one entry per rejected message) |
| `receiveMessage` | `Messages` and `MessageCount`. Each message keeps its SQS fields (`MessageId`, `ReceiptHandle`, `Body`, `Attributes`, and `MessageAttributes` when Receive Message Attributes is on) and gains `ParsedBody` — the body parsed as JSON, or the raw string when it is not JSON. An empty poll returns `Messages: []` and `MessageCount: 0` |
| `deleteMessage` | `success: true` and `deletedReceiptHandle` |
| `purgeQueue` | `success: true` and `purgedQueueUrl` |
| `getQueueAttributes` | `QueueUrl` and `Attributes` — the full queue attribute set, with numeric attributes such as `ApproximateNumberOfMessages` and `VisibilityTimeout` returned as numbers rather than strings |
| `listQueues` | `QueueUrls` (every page, followed to the end), `QueueCount`, and `Queues` — one `{ url, name }` entry per queue |
| `createQueue` | `QueueUrl` and `QueueName` |
| `deleteQueue` | `success: true` and `deletedQueueUrl` |

List and receive results arrive as arrays on a single item — use a Split Out node on `Messages` or `Queues` to fan them out. Reference any field downstream by expression, e.g. `{{ $json.MessageId }}`.

## Usage Examples

- Send a message to an SQS queue after processing an order
- Receive messages from a queue for batch processing
- Delete a processed message from the queue using its receipt handle
- Purge all messages from a dead-letter queue
- List all SQS queues in an AWS account
- Create a new FIFO queue for ordered processing
- Get queue attributes to check message counts and configuration

## Example Configuration

Send a literal message to a standard queue with custom attributes:

```json
{
  "type": "aws_sqs",
  "parameters": {
    "operation": "sendMessage",
    "queueUrl": "https://sqs.us-east-1.amazonaws.com/123456789012/my-standard-queue",
    "queueType": "standard",
    "sendInputData": false,
    "message": "Hello from AWS SQS!",
    "options": {
      "delaySeconds": 0,
      "messageAttributes": {
        "string": [
          { "name": "Environment", "value": "production" },
          { "name": "Source", "value": "workflow" }
        ],
        "number": [
          { "name": "Priority", "value": 1 }
        ]
      }
    }
  }
}
```

Send the whole input item to a FIFO queue:

```json
{
  "type": "aws_sqs",
  "parameters": {
    "operation": "sendMessage",
    "queueUrl": "https://sqs.us-east-1.amazonaws.com/123456789012/my-fifo-queue.fifo",
    "queueType": "fifo",
    "sendInputData": true,
    "messageGroupId": "{{ $json.customerId }}",
    "options": {
      "messageDeduplicationId": "{{ $json.orderId }}"
    }
  }
}
```

Receive messages with long polling:

```json
{
  "type": "aws_sqs",
  "parameters": {
    "operation": "receiveMessage",
    "queueUrl": "https://sqs.us-east-1.amazonaws.com/123456789012/my-queue",
    "options": {
      "maxNumberOfMessages": 10,
      "visibilityTimeout": 60,
      "waitTimeSeconds": 20,
      "receiveMessageAttributes": true
    }
  }
}
```

Delete a message once it has been processed:

```json
{
  "type": "aws_sqs",
  "parameters": {
    "operation": "deleteMessage",
    "queueUrl": "https://sqs.us-east-1.amazonaws.com/123456789012/my-queue",
    "receiptHandle": "{{ $json.ReceiptHandle }}"
  }
}
```

Create a FIFO queue with content-based deduplication:

```json
{
  "type": "aws_sqs",
  "parameters": {
    "operation": "createQueue",
    "queueName": "my-new-fifo-queue.fifo",
    "queueType": "fifo",
    "options": {
      "createQueueAttributes": "{\"ContentBasedDeduplication\":\"true\",\"VisibilityTimeout\":\"60\"}"
    }
  }
}
```

List queues in another region, filtered by name prefix:

```json
{
  "type": "aws_sqs",
  "parameters": {
    "operation": "listQueues",
    "queuePrefix": "production-",
    "region": "us-west-2"
  }
}
```

Send a batch of up to 10 messages taken from the item's `messages` array:

```json
{
  "type": "aws_sqs",
  "parameters": {
    "operation": "sendMessageBatch",
    "queueUrl": "https://sqs.us-east-1.amazonaws.com/123456789012/my-fifo-queue.fifo",
    "queueType": "fifo",
    "messageGroupId": "batch-group-1"
  }
}
```

### Error Handling

| Mode | Behavior |
|------|----------|
| **stop** | Halts workflow on first error |
| **continue** | Skips failed items, passes successful ones through |
| **errorPort** | Routes failed items to Error output port |

## Tips

AWS SQS sends, receives, and manages messages in Amazon Simple Queue Service queues. Use it for asynchronous message processing, task queuing, and decoupling microservices.

### Behavior notes

- **Send Message Batch reads the item, not a parameter.** It takes the array at `messages` on the input item, or falls back to the item itself as a single entry, and sends at most the first 10.
- **Send Input Data controls the body.** With it on, the whole input item is JSON-stringified as the message body; with it off, the Message parameter is sent as-is.
- **Create Queue and FIFO.** Selecting the FIFO queue type sets the `FifoQueue` attribute for you and appends `.fifo` to the queue name if you left it off.
- **List Queues follows pagination to the end** and returns every matching queue in one item.

### Common patterns

- **Standard queue processing:** receive with long polling (`waitTimeSeconds: 20`), process the messages in your workflow, then delete each one with its receipt handle.
- **FIFO queues:** always set a Message Group ID on send operations, add a Message Deduplication ID when the queue does not use content-based deduplication, and remember that queue names must end with `.fifo`.
- **Queue lifecycle:** create with the attributes you need, monitor with Get Queue Attributes, then clean up with Purge Queue (removes the messages) or Delete Queue (removes the queue itself).
- **Visibility timeout:** set it long enough to cover your processing time, otherwise a message reappears in the queue and is delivered again before you finish with it.