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

> Node: AWS Lambda (`aws_lambda`) · Action · v1
> Category: Development · Credentials: AWS Lambda (`awsLambdaApi`)
> Updated: 2026-08-16

# AWS Lambda

> Invoke AWS Lambda serverless functions

## Overview

The AWS Lambda tool invokes serverless functions on AWS Lambda. It supports synchronous invocation (RequestResponse) where the workflow waits for the function result, and asynchronous invocation (Event) where the function is triggered and the workflow continues immediately. It can also list all available Lambda functions in the configured region. Payloads are sent as JSON and responses are automatically parsed.

**Category:** Development  
**Tool Name:** `aws_lambda`  
**Version:** 1

**Appearance:** Icon: `lucide-Code` | 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 Lambda** credentials.
See the [Credentials Guide](https://busybot.net/credentials/aws-lambda-api/) for setup instructions.

### Operations

| Operation | Value | Description |
|-----------|-------|-------------|
| Invoke | `invoke` | Invoke a Lambda function |
| List Functions | `listFunctions` | List available Lambda functions |

### Parameters

#### Invoke (`invoke`)

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| Function Name | `string` | Yes | — | The Lambda function name, ARN, or partial ARN. Find in the AWS Lambda console. Supports expressions like {{ $json.functionName }}. |
| Qualifier | `string` | No | `$LATEST` | Specify a version or alias to invoke a published version of the function. Use $LATEST for the most recent version. Supports expressions. |
| Invocation Type | `options` | No | `RequestResponse` | Whether to wait for the function result (synchronous) or continue immediately (asynchronous). |
| | | | | Options: `RequestResponse` (Wait for Results — invoke synchronously and wait for the response), `Event` (Continue Workflow — invoke asynchronously and immediately continue the workflow) |
| JSON Input | `json` | No | — | The JSON payload to send to the Lambda function as input. Leave empty for no input. Provide it as a JSON string; supports expressions. |

#### List Functions (`listFunctions`)

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| Return All | `boolean` | No | `false` | Whether to return all functions or only up to a given limit. |
| Limit | `number` | No | `50` | Max number of functions to return. _(shown when Return All is `false`)_ |

#### All Operations

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| Region | `string` | No | — | Override the AWS region from credentials. Leave empty to use the region configured in credentials. Supports expressions. |
| Max Concurrency | `number` | No | `10` | Maximum number of items to process concurrently. |

## Output Data

Each input item produces exactly one output item. The result fields are **merged onto the input item's JSON**, so everything the item arrived with is still addressable downstream, and binary data is forwarded unchanged.

| Operation | Fields added to the item |
|-----------|--------------------------|
| `invoke` | `result` (the decoded function response — parsed JSON when the function returned JSON, otherwise the raw string, or `null` for an empty response), `statusCode` (the HTTP status Lambda returned for the invocation), `executedVersion`, `functionError`, `logResult` (the decoded log tail, or `null`) |
| `listFunctions` | `functions` (an array of function objects) and `count` |

Each entry in `functions` carries `functionName`, `functionArn`, `runtime`, `handler`, `codeSize`, `description`, `timeout`, `memorySize`, `lastModified`, `role`, `version`, `packageType` and `architectures`.

`listFunctions` returns the whole list on **one** item, so add a Split Out node on `functions` when you want one item per function.

Reference the result downstream by expression, e.g. `{{ $json.result }}` or `{{ $json.count }}`.

## Usage Examples

- Invoke a Lambda function with a JSON payload and get the response
- Trigger a Lambda function asynchronously without waiting for results
- List all Lambda functions in a region

## Example Configuration

Invoke a function and wait for its result:

```json
{
  "type": "aws_lambda",
  "parameters": {
    "operation": "invoke",
    "functionName": "my-lambda-function",
    "invocationType": "RequestResponse"
  }
}
```

Send an explicit JSON payload built from the incoming item:

```json
{
  "type": "aws_lambda",
  "parameters": {
    "operation": "invoke",
    "functionName": "data-processor",
    "invocationType": "RequestResponse",
    "payload": "{\"userId\": \"{{ $json.userId }}\", \"action\": \"process\"}"
  }
}
```

Fire and forget — trigger the function and continue immediately:

```json
{
  "type": "aws_lambda",
  "parameters": {
    "operation": "invoke",
    "functionName": "notification-sender",
    "invocationType": "Event",
    "payload": "{\"message\": \"{{ $json.message }}\", \"recipient\": \"{{ $json.email }}\"}"
  }
}
```

Invoke a published alias instead of the latest version:

```json
{
  "type": "aws_lambda",
  "parameters": {
    "operation": "invoke",
    "functionName": "my-production-function",
    "qualifier": "PROD",
    "invocationType": "RequestResponse",
    "payload": "{\"environment\": \"production\"}"
  }
}
```

List every function in the account:

```json
{
  "type": "aws_lambda",
  "parameters": {
    "operation": "listFunctions",
    "returnAll": true
  }
}
```

List only the first 25 functions:

```json
{
  "type": "aws_lambda",
  "parameters": {
    "operation": "listFunctions",
    "returnAll": false,
    "limit": 25
  }
}
```

Invoke a function in a different region than the credential's default:

```json
{
  "type": "aws_lambda",
  "parameters": {
    "operation": "invoke",
    "functionName": "eu-specific-function",
    "region": "eu-west-1",
    "invocationType": "RequestResponse"
  }
}
```

Discover functions in a specific region:

```json
{
  "type": "aws_lambda",
  "parameters": {
    "operation": "listFunctions",
    "returnAll": false,
    "limit": 10,
    "region": "us-east-1"
  }
}
```

Invoke a production alias with a request id and timestamp, throttled to five items at a time:

```json
{
  "type": "aws_lambda",
  "parameters": {
    "operation": "invoke",
    "functionName": "critical-business-logic",
    "qualifier": "PROD",
    "invocationType": "RequestResponse",
    "payload": "{\"requestId\": \"{{ $json.id }}\", \"timestamp\": \"{{ $datetime.iso }}\"}",
    "maxConcurrency": 5
  }
}
```

### 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

Invoke AWS Lambda functions or list available functions -- use for running serverless code in AWS.

### Behavior notes

- **Leave JSON Input empty to forward the item.** When no payload is configured, the incoming item's JSON is sent to the function as the payload instead. Set JSON Input when the function expects a different shape.
- **Write JSON Input as a JSON string**, not as a nested object — the value is evaluated for expressions and sent to Lambda as text.
- **Function failures become node errors.** If the function returns an `errorMessage`, or Lambda reports an unhandled exception, the item fails with that message rather than passing a failed result downstream. Use **continue** or **errorPort** error handling if you want to keep processing the remaining items.
- **`Event` invocations return no function result.** Asynchronous invocation only confirms that Lambda accepted the request, so `result` will be empty — use it for fire-and-forget work.
- **Region resolution.** Leave Region empty to use the region on the credential; set it to target functions in another region with the same credential.