# Amazon DynamoDB

> Read and write items in Amazon DynamoDB tables - get, put, update, query, scan, batches, transactions and PartiQL - and create, configure and tag tables.

App · Databases · 20 actions. Web page: https://docs.lodol.com/docs/integrations/amazon-dynamodb

## Actions

### Batch get items

Read up to 100 items of one table by key in one step. Items come back in no particular order; keys with no item are listed in missing_keys.

**Inputs**

- Table (`table`, text, required): Pick a table, or enter its name, ARN or DynamoDB console address. It must be in the region you connected with.
- Keys (`keys`, list, required): A list of keys, each an object like {"pk": "customer#1", "sk": 1}. At most 100.
- Attributes to return (`attributes`, list): Only return these attributes (use a.b for a nested one). Leave empty for every attribute.
- Consistent read (`consistent_read`, true/false): Read the latest committed data (costs twice the read capacity). Not available on a global secondary index. Default: `false`.

**Outputs**

- `result` (object)

**Example output**

```json
{
  "result": {
    "count": 1,
    "items": [
      {
        "lines": [
          "book",
          "pen"
        ],
        "pk": "customer#1",
        "sk": 1,
        "status": "paid",
        "total": 42.5
      }
    ],
    "missing_keys": [
      {
        "pk": "customer#1",
        "sk": 9
      }
    ],
    "unprocessed_keys": []
  }
}
```

### Batch write items

Put and/or delete up to 25 items of one table in one step. Each write stands alone (it is not a transaction) and takes no conditions.

**Inputs**

- Table (`table`, text, required): Pick a table, or enter its name, ARN or DynamoDB console address. It must be in the region you connected with.
- Items to put (`put_items`, list): Items to create or replace, each an object including its key.
- Keys to delete (`delete_keys`, list): Keys of items to delete, each an object.

**Outputs**

- `result` (object)

**Example output**

```json
{
  "result": {
    "delete_count": 0,
    "put_count": 2,
    "unprocessed": [],
    "unprocessed_count": 0
  }
}
```

### Create table

Create a table with a partition key and optional sort key, then wait until it is ready. Provisioned capacity (default 5 read / 5 write) is covered by the AWS free tier; on-demand is billed per request.

**Inputs**

- Table name (`table_name`, text, required): 3-255 letters, digits, '_', '-' and '.'. Unique in the region.
- Partition key name (`partition_key_name`, text, required): The attribute every item is looked up by, for example 'pk' or 'customer_id'.
- Partition key type (`partition_key_type`, text): The partition key's type. One of: `S` (String), `N` (Number), `B` (Binary). Default: `S`.
- Sort key name (`sort_key_name`, text): Optional second key that orders items sharing a partition key, for example 'created_at'.
- Sort key type (`sort_key_type`, text): The sort key's type. One of: `S` (String), `N` (Number), `B` (Binary). Default: `S`.
- Billing mode (`billing_mode`, text): Provisioned capacity is covered by the free tier (25 read and 25 write units per region); on-demand bills every request. One of: `PROVISIONED` (Provisioned capacity (covered by the free tier)), `PAY_PER_REQUEST` (On-demand (billed per request)). Default: `PROVISIONED`.
- Read capacity units (`read_capacity_units`, number): Provisioned billing only. Reads per second (4 KB each, strongly consistent). The free tier covers 25 in total per region. From 1 to 40000.
- Write capacity units (`write_capacity_units`, number): Provisioned billing only. Writes per second (1 KB each). The free tier covers 25 in total per region. From 1 to 40000.
- Table class (`table_class`, text): Standard suits most tables; Infrequent Access costs less to store and more to read and write. One of: `STANDARD`, `STANDARD_INFREQUENT_ACCESS` (Standard - Infrequent Access).
- Deletion protection (`deletion_protection`, true/false): Block Delete table until this is turned off again.
- Tags (`tags`, object): Cost-allocation tags as key: value pairs.
- Wait until ready (`wait_until_active`, true/false): Wait (up to about 90 seconds) until the table is ACTIVE, so the next step can use it straight away. Default: `true`.

**Outputs**

- `result` (object)

**Example output**

```json
{
  "result": {
    "active": true,
    "table": {
      "billing_mode": "PROVISIONED",
      "created_at": "2026-09-28T08:00:00Z",
      "deletion_protection_enabled": false,
      "encryption_type": null,
      "global_secondary_indexes": [
        {
          "index_arn": "arn:aws:dynamodb:us-east-1:123456789012:table/orders/index/by-status",
          "index_name": "by-status",
          "item_count": 3,
          "partition_key": {
            "name": "status",
            "type": "S"
          },
          "projection_type": "ALL",
          "size_bytes": 312,
          "sort_key": null,
          "status": "ACTIVE"
        }
      ],
      "item_count": 3,
      "latest_stream_arn": null,
      "local_secondary_indexes": [],
      "partition_key": {
        "name": "pk",
        "type": "S"
      },
      "read_capacity_units": 5,
      "size_bytes": 312,
      "sort_key": {
        "name": "sk",
        "type": "N"
      },
      "status": "ACTIVE",
      "stream_enabled": false,
      "table_arn": "arn:aws:dynamodb:us-east-1:123456789012:table/orders",
      "table_class": "STANDARD",
      "table_id": "4b6c1e3a-2f0d-4f7e-9c35-6d1f2a8b7e10",
      "table_name": "orders",
      "write_capacity_units": 5
    }
  }
}
```

### Delete item

Delete one item by its key, and report whether there was one to delete.

**Inputs**

- Table (`table`, text, required): Pick a table, or enter its name, ARN or DynamoDB console address. It must be in the region you connected with.
- Key (`key`, object, required): The item's full primary key: its partition key, plus its sort key if the table has one. For example pk: customer#1, sk: 42.
- Only if it exists (`only_if_exists`, true/false): Fail when no item has this key. Default: `false`.
- Condition expression (`condition_expression`, text): Only write if this is true, for example '#s = :expected'. Put the names and values it uses in the two fields below.
- Expression attribute names (`expression_attribute_names`, object): Placeholders for attribute names in your expressions, for example #s: status. Needed for reserved words such as 'status' or 'name'.
- Expression attribute values (`expression_attribute_values`, object): Placeholders for values in your expressions, for example :expected: paid.

**Outputs**

- `result` (object)

**Example output**

```json
{
  "result": {
    "deleted": true,
    "deleted_item": {
      "lines": [
        "book",
        "pen"
      ],
      "pk": "customer#1",
      "sk": 1,
      "status": "paid",
      "total": 42.5
    },
    "key": {
      "pk": "customer#1",
      "sk": 1
    }
  }
}
```

### Delete table

Delete a table and every item in it. There is no undo. A table with deletion protection on must have it turned off first.

**Inputs**

- Table (`table`, text, required): Pick a table, or enter its name, ARN or DynamoDB console address. It must be in the region you connected with.

**Outputs**

- `result` (object)

**Example output**

```json
{
  "result": {
    "deleted": true,
    "status": "DELETING",
    "table_arn": "arn:aws:dynamodb:us-east-1:123456789012:table/orders",
    "table_name": "orders"
  }
}
```

### Describe table

Read a table's key, status, capacity, indexes and approximate item count and size (DynamoDB refreshes those two periodically).

**Inputs**

- Table (`table`, text, required): Pick a table, or enter its name, ARN or DynamoDB console address. It must be in the region you connected with.

**Outputs**

- `result` (object)

**Example output**

```json
{
  "result": {
    "table": {
      "billing_mode": "PROVISIONED",
      "created_at": "2026-09-28T08:00:00Z",
      "deletion_protection_enabled": false,
      "encryption_type": null,
      "global_secondary_indexes": [
        {
          "index_arn": "arn:aws:dynamodb:us-east-1:123456789012:table/orders/index/by-status",
          "index_name": "by-status",
          "item_count": 3,
          "partition_key": {
            "name": "status",
            "type": "S"
          },
          "projection_type": "ALL",
          "size_bytes": 312,
          "sort_key": null,
          "status": "ACTIVE"
        }
      ],
      "item_count": 3,
      "latest_stream_arn": null,
      "local_secondary_indexes": [],
      "partition_key": {
        "name": "pk",
        "type": "S"
      },
      "read_capacity_units": 5,
      "size_bytes": 312,
      "sort_key": {
        "name": "sk",
        "type": "N"
      },
      "status": "ACTIVE",
      "stream_enabled": false,
      "table_arn": "arn:aws:dynamodb:us-east-1:123456789012:table/orders",
      "table_class": "STANDARD",
      "table_id": "4b6c1e3a-2f0d-4f7e-9c35-6d1f2a8b7e10",
      "table_name": "orders",
      "write_capacity_units": 5
    }
  }
}
```

### Get item

Read one item by its full primary key. A missing item returns found: false rather than failing.

**Inputs**

- Table (`table`, text, required): Pick a table, or enter its name, ARN or DynamoDB console address. It must be in the region you connected with.
- Key (`key`, object, required): The item's full primary key: its partition key, plus its sort key if the table has one. For example pk: customer#1, sk: 42.
- Attributes to return (`attributes`, list): Only return these attributes (use a.b for a nested one). Leave empty for every attribute.
- Consistent read (`consistent_read`, true/false): Read the latest committed data (costs twice the read capacity). Not available on a global secondary index. Default: `false`.

**Outputs**

- `result` (object)

**Example output**

```json
{
  "result": {
    "found": true,
    "item": {
      "lines": [
        "book",
        "pen"
      ],
      "pk": "customer#1",
      "sk": 1,
      "status": "paid",
      "total": 42.5
    },
    "key": {
      "pk": "customer#1",
      "sk": 1
    }
  }
}
```

### Get Time to Live

Check whether expired items are deleted automatically, and which attribute holds their expiry time.

**Inputs**

- Table (`table`, text, required): Pick a table, or enter its name, ARN or DynamoDB console address. It must be in the region you connected with.

**Outputs**

- `result` (object)

**Example output**

```json
{
  "result": {
    "attribute_name": "expires_at",
    "enabled": true,
    "status": "ENABLED",
    "table": "orders"
  }
}
```

### List table tags

Read a table's tags as key: value pairs.

**Inputs**

- Table (`table`, text, required): Pick a table, or enter its name, ARN or DynamoDB console address. It must be in the region you connected with.
- Next token (`next_token`, text): The 'next_token' from a previous page, to read the next one.

**Outputs**

- `result` (object)

**Example output**

```json
{
  "result": {
    "count": 1,
    "has_more": false,
    "next_token": null,
    "table_arn": "arn:aws:dynamodb:us-east-1:123456789012:table/orders",
    "tags": {
      "team": "billing"
    }
  }
}
```

### List tables

List the names of the tables in the connected region.

**Inputs**

- Limit (`limit`, number): How many table names per page, 1-100. Default 100. From 1 to 100.
- Next token (`next_token`, text): The 'next_token' from a previous page, to read the next one.

**Outputs**

- `result` (object)

**Example output**

```json
{
  "result": {
    "count": 2,
    "has_more": false,
    "next_token": null,
    "table_names": [
      "customers",
      "orders"
    ]
  }
}
```

### Put item

Create an item, or replace the whole item that has the same key. Turn on 'Only if new' to never overwrite.

**Inputs**

- Table (`table`, text, required): Pick a table, or enter its name, ARN or DynamoDB console address. It must be in the region you connected with.
- Item (`item`, object, required): The item's attributes, including its key. Values can be text, numbers, true/false, lists or objects.
- Only if new (`only_if_new`, true/false): Fail instead of overwriting an existing item. Default: `false`.
- Condition expression (`condition_expression`, text): Only write if this is true, for example '#s = :expected'. Put the names and values it uses in the two fields below.
- Expression attribute names (`expression_attribute_names`, object): Placeholders for attribute names in your expressions, for example #s: status. Needed for reserved words such as 'status' or 'name'.
- Expression attribute values (`expression_attribute_values`, object): Placeholders for values in your expressions, for example :expected: paid.
- Return (`return_values`, text): Also return the item this one replaced. One of: `NONE` (Nothing), `ALL_OLD` (The whole item as it was before). Default: `NONE`.

**Outputs**

- `result` (object)

**Example output**

```json
{
  "result": {
    "item": {
      "lines": [
        "book",
        "pen"
      ],
      "pk": "customer#1",
      "sk": 1,
      "status": "paid",
      "total": 42.5
    },
    "key": {
      "pk": "customer#1",
      "sk": 1
    },
    "old_item": null,
    "written": true
  }
}
```

### Query items

Read the items that share a partition key, optionally narrowed by the sort key, in sort-key order. Only the key values are needed; the key names come from the table.

**Inputs**

- Table (`table`, text, required): Pick a table, or enter its name, ARN or DynamoDB console address. It must be in the region you connected with.
- Partition key value (`partition_key_value`, text, required): The partition key value to read, for example customer#1.
- Sort key condition (`sort_key_operator`, text): Narrow by the sort key. Leave empty for every item. One of: `=` (equals), `<` (less than), `<=` (less than or equal to), `>` (greater than), `>=` (greater than or equal to), `begins_with` (begins with), `between` (between (inclusive)).
- Sort key value (`sort_key_value`, text): The sort key value to compare with.
- Sort key value (end) (`sort_key_value_end`, text): With 'between': the upper bound (inclusive).
- Index (`index_name`, text): Read a secondary index instead of the table. Leave empty for the table.
- Filter expression (`filter_expression`, text): Drop items that do not match, for example '#s = :s'. Applied after reading, so filtered-out items still use read capacity.
- Expression attribute names (`expression_attribute_names`, object): Placeholders for attribute names in your expressions, for example #s: status. Needed for reserved words such as 'status' or 'name'.
- Expression attribute values (`expression_attribute_values`, object): Placeholders for values in your expressions, for example :expected: paid.
- Attributes to return (`attributes`, list): Only return these attributes (use a.b for a nested one). Leave empty for every attribute.
- Newest / highest first (`descending`, true/false): Return items in descending sort-key order. Default: `false`.
- Consistent read (`consistent_read`, true/false): Read the latest committed data (costs twice the read capacity). Not available on a global secondary index. Default: `false`.
- Count only (`count_only`, true/false): Return only how many items match, not the items. Default: `false`.
- Limit (`limit`, number): Stop after evaluating this many items (before the filter). A page also stops at 1 MB. From 1 to 1000000.
- Next token (`next_token`, text): The 'next_token' from a previous page, to read the next one.

**Outputs**

- `result` (object)

**Example output**

```json
{
  "result": {
    "count": 1,
    "has_more": true,
    "items": [
      {
        "lines": [
          "book",
          "pen"
        ],
        "pk": "customer#1",
        "sk": 1,
        "status": "paid",
        "total": 42.5
      }
    ],
    "last_evaluated_key": {
      "pk": "customer#1",
      "sk": 1
    },
    "next_token": "eyJwayI6eyJTIjoiY3VzdG9tZXIjMSJ9LCJzayI6eyJOIjoiMiJ9fQ==",
    "scanned_count": 1
  }
}
```

### Run PartiQL statement

Run one PartiQL (SQL-compatible) statement: a SELECT, or an INSERT, UPDATE or DELETE of a single item. Use '?' for values and list them in Parameters.

**Inputs**

- Statement (`statement`, text, required): The statement. Put the table name in double quotes and text values in single quotes, or use '?'.
- Parameters (`parameters`, list): The values for each '?', in order.
- Consistent read (`consistent_read`, true/false): Read the latest committed data (costs twice the read capacity). Not available on a global secondary index. Default: `false`.
- Limit (`limit`, number): SELECT only: stop after evaluating this many items. From 1 to 1000000.
- Next token (`next_token`, text): The 'next_token' from a previous page, to read the next one.

**Outputs**

- `result` (object)

**Example output**

```json
{
  "result": {
    "count": 1,
    "has_more": false,
    "items": [
      {
        "lines": [
          "book",
          "pen"
        ],
        "pk": "customer#1",
        "sk": 1,
        "status": "paid",
        "total": 42.5
      }
    ],
    "next_token": null
  }
}
```

### Scan table

Read every item in a table or index, a page (up to 1 MB) at a time. Every item read uses read capacity, even ones the filter drops - prefer Query items when you know the partition key.

**Inputs**

- Table (`table`, text, required): Pick a table, or enter its name, ARN or DynamoDB console address. It must be in the region you connected with.
- Index (`index_name`, text): Read a secondary index instead of the table. Leave empty for the table.
- Filter expression (`filter_expression`, text): Drop items that do not match, for example '#s = :s'. Applied after reading, so filtered-out items still use read capacity.
- Expression attribute names (`expression_attribute_names`, object): Placeholders for attribute names in your expressions, for example #s: status. Needed for reserved words such as 'status' or 'name'.
- Expression attribute values (`expression_attribute_values`, object): Placeholders for values in your expressions, for example :expected: paid.
- Attributes to return (`attributes`, list): Only return these attributes (use a.b for a nested one). Leave empty for every attribute.
- Consistent read (`consistent_read`, true/false): Read the latest committed data (costs twice the read capacity). Not available on a global secondary index. Default: `false`.
- Count only (`count_only`, true/false): Return only how many items match, not the items. Default: `false`.
- Limit (`limit`, number): Stop after evaluating this many items (before the filter). A page also stops at 1 MB. From 1 to 1000000.
- Next token (`next_token`, text): The 'next_token' from a previous page, to read the next one.

**Outputs**

- `result` (object)

**Example output**

```json
{
  "result": {
    "count": 1,
    "has_more": true,
    "items": [
      {
        "lines": [
          "book",
          "pen"
        ],
        "pk": "customer#1",
        "sk": 1,
        "status": "paid",
        "total": 42.5
      }
    ],
    "last_evaluated_key": {
      "pk": "customer#1",
      "sk": 1
    },
    "next_token": "eyJwayI6eyJTIjoiY3VzdG9tZXIjMSJ9LCJzayI6eyJOIjoiMiJ9fQ==",
    "scanned_count": 1
  }
}
```

### Set Time to Live

Turn automatic deletion of expired items on or off. The attribute must hold the expiry time as a number of epoch seconds. Deletion is free and typically happens within two days of expiry. A table allows one change per hour.

**Inputs**

- Table (`table`, text, required): Pick a table, or enter its name, ARN or DynamoDB console address. It must be in the region you connected with.
- Enabled (`enabled`, true/false, required): On to delete expired items, off to stop. Default: `true`.
- Expiry attribute (`attribute_name`, text): The attribute holding the expiry time, for example 'expires_at'. When turning off, leave empty to use the current one.

**Outputs**

- `result` (object)

**Example output**

```json
{
  "result": {
    "attribute_name": "expires_at",
    "enabled": true,
    "table": "orders"
  }
}
```

### Tag table

Add tags to a table, or change existing ones' values (up to 50 tags per table).

**Inputs**

- Table (`table`, text, required): Pick a table, or enter its name, ARN or DynamoDB console address. It must be in the region you connected with.
- Tags (`tags`, object, required): Tags as key: value pairs.

**Outputs**

- `result` (object)

**Example output**

```json
{
  "result": {
    "table_arn": "arn:aws:dynamodb:us-east-1:123456789012:table/orders",
    "tagged": true,
    "tags": {
      "team": "billing"
    }
  }
}
```

### Transact write items

Apply up to 100 puts, updates, deletes and condition checks all-or-nothing, across tables in the region. If any condition fails, nothing is written and the step names the operation that failed. Costs twice the write capacity.

**Inputs**

- Operations (`operations`, list, required): A list of operations, each an object with 'action' (put, update, delete or condition_check), 'table', and 'item' (put) or 'key' (the others). Updates take 'set_attributes' or 'update_expression'; any of them can take 'condition_expression', 'expression_attribute_names' and 'expression_attribute_values'.
- Client request token (`client_request_token`, text): Optional, up to 36 characters: repeating a transaction with the same token shortly afterwards does not apply it twice.

**Outputs**

- `result` (object)

**Example output**

```json
{
  "result": {
    "committed": true,
    "operation_count": 2,
    "operations": [
      {
        "action": "update",
        "table": "stock"
      },
      {
        "action": "update",
        "table": "stock"
      }
    ]
  }
}
```

### Untag table

Remove tags from a table by key. Missing keys are ignored.

**Inputs**

- Table (`table`, text, required): Pick a table, or enter its name, ARN or DynamoDB console address. It must be in the region you connected with.
- Tag keys (`tag_keys`, list, required): The tag keys to remove.

**Outputs**

- `result` (object)

**Example output**

```json
{
  "result": {
    "removed_tag_keys": [
      "team"
    ],
    "table_arn": "arn:aws:dynamodb:us-east-1:123456789012:table/orders",
    "untagged": true
  }
}
```

### Update item

Set or remove some attributes of an item, leaving the rest. Creates the item if the key is new, unless 'Only if it exists' is on.

**Inputs**

- Table (`table`, text, required): Pick a table, or enter its name, ARN or DynamoDB console address. It must be in the region you connected with.
- Key (`key`, object, required): The item's full primary key: its partition key, plus its sort key if the table has one. For example pk: customer#1, sk: 42.
- Set attributes (`set_attributes`, object): Attributes to set, as name: new value.
- Remove attributes (`remove_attributes`, list): Attribute names to remove from the item.
- Update expression (`update_expression`, text): Advanced, instead of the two fields above: a DynamoDB update expression, for example 'ADD #n :one'.
- Only if it exists (`only_if_exists`, true/false): Fail instead of creating an item that is not there. Default: `false`.
- Condition expression (`condition_expression`, text): Only write if this is true, for example '#s = :expected'. Put the names and values it uses in the two fields below.
- Expression attribute names (`expression_attribute_names`, object): Placeholders for attribute names in your expressions, for example #s: status. Needed for reserved words such as 'status' or 'name'.
- Expression attribute values (`expression_attribute_values`, object): Placeholders for values in your expressions, for example :expected: paid.
- Return (`return_values`, text): What to return. Default: the whole item as it is now. One of: `NONE` (Nothing), `ALL_OLD` (The whole item as it was before), `UPDATED_OLD` (Only the changed attributes, before), `ALL_NEW` (The whole item as it is now), `UPDATED_NEW` (Only the changed attributes, now). Default: `ALL_NEW`.

**Outputs**

- `result` (object)

**Example output**

```json
{
  "result": {
    "item": {
      "lines": [
        "book",
        "pen"
      ],
      "pk": "customer#1",
      "sk": 1,
      "status": "paid",
      "total": 42.5
    },
    "key": {
      "pk": "customer#1",
      "sk": 1
    },
    "updated": true
  }
}
```

### Update table

Change a table's billing mode, capacity, table class or deletion protection, then wait until it is ready. Only the fields you fill in change. A table can switch to on-demand at most four times in 24 hours.

**Inputs**

- Table (`table`, text, required): Pick a table, or enter its name, ARN or DynamoDB console address. It must be in the region you connected with.
- Billing mode (`billing_mode`, text): Leave empty to keep the current mode. Switching to Provisioned needs both capacity fields. One of: `PROVISIONED` (Provisioned capacity (covered by the free tier)), `PAY_PER_REQUEST` (On-demand (billed per request)).
- Read capacity units (`read_capacity_units`, number): Provisioned billing only. Reads per second (4 KB each, strongly consistent). The free tier covers 25 in total per region. From 1 to 40000.
- Write capacity units (`write_capacity_units`, number): Provisioned billing only. Writes per second (1 KB each). The free tier covers 25 in total per region. From 1 to 40000.
- Table class (`table_class`, text): Standard suits most tables; Infrequent Access costs less to store and more to read and write. One of: `STANDARD`, `STANDARD_INFREQUENT_ACCESS` (Standard - Infrequent Access).
- Deletion protection (`deletion_protection`, true/false): Block Delete table until this is turned off again.
- Wait until ready (`wait_until_active`, true/false): Wait (up to about 90 seconds) until the table is ACTIVE, so the next step can use it straight away. Default: `true`.

**Outputs**

- `result` (object)

**Example output**

```json
{
  "result": {
    "active": true,
    "changed": [
      "ProvisionedThroughput"
    ],
    "table": {
      "billing_mode": "PROVISIONED",
      "created_at": "2026-09-28T08:00:00Z",
      "deletion_protection_enabled": false,
      "encryption_type": null,
      "global_secondary_indexes": [
        {
          "index_arn": "arn:aws:dynamodb:us-east-1:123456789012:table/orders/index/by-status",
          "index_name": "by-status",
          "item_count": 3,
          "partition_key": {
            "name": "status",
            "type": "S"
          },
          "projection_type": "ALL",
          "size_bytes": 312,
          "sort_key": null,
          "status": "ACTIVE"
        }
      ],
      "item_count": 3,
      "latest_stream_arn": null,
      "local_secondary_indexes": [],
      "partition_key": {
        "name": "pk",
        "type": "S"
      },
      "read_capacity_units": 5,
      "size_bytes": 312,
      "sort_key": {
        "name": "sk",
        "type": "N"
      },
      "status": "ACTIVE",
      "stream_enabled": false,
      "table_arn": "arn:aws:dynamodb:us-east-1:123456789012:table/orders",
      "table_class": "STANDARD",
      "table_id": "4b6c1e3a-2f0d-4f7e-9c35-6d1f2a8b7e10",
      "table_name": "orders",
      "write_capacity_units": 5
    }
  }
}
```