canonical: https://jentic.com/apis/amazonaws.com/aws-dax

# AWS Amazon DynamoDB Accelerator (DAX)

Jentic maintains a curated, agent-optimized OpenAPI specification for Amazon DynamoDB Accelerator (DAX), keeping it validated and agent-ready. Amazon DynamoDB Accelerator (DAX) is a managed in-memory caching service that sits in front of Amazon DynamoDB to deliver sub-millisecond read latency for cached items. The DAX control plane API lets you provision and operate clusters, manage parameter groups and subnet groups, scale replication factor, describe events, and tag resources. It is intended for read-heavy workloads where DynamoDB latency or cost-per-read becomes a bottleneck and a write-through cache makes economic sense.

## For AI agents

Provision and operate Amazon DynamoDB Accelerator (DAX) clusters, manage parameter and subnet groups, and scale replication factor for cached DynamoDB reads.

## Scope

Does not handle reading or writing cached items, DynamoDB table operations, or VPC networking - use for DAX cluster lifecycle and configuration only.

## Capabilities

- Provision DAX clusters with CreateCluster and tear them down with DeleteCluster when read-cache workloads change
- Adjust read capacity by calling IncreaseReplicationFactor or DecreaseReplicationFactor on a running cluster
- Manage cluster configuration through CreateParameterGroup, UpdateParameterGroup, and DescribeParameters
- Place clusters in target VPCs with CreateSubnetGroup and UpdateSubnetGroup
- Investigate operational issues by calling DescribeEvents to retrieve cluster lifecycle and failure events
- Apply IAM-style governance with TagResource, UntagResource, and ListTags on DAX clusters

## Use cases

### Add a Read Cache in Front of DynamoDB

Provision a DAX cluster to absorb hot-key read traffic from a DynamoDB table, cutting read latency from single-digit milliseconds to microseconds for cached items. The DAX control plane handles cluster creation, node placement across subnets, and parameter group binding so the application only needs to point its DAX client at the cluster endpoint. Useful when scaling read-heavy workloads where provisioned read capacity costs grow faster than the application can tolerate.

Example prompt: Call CreateCluster with a node type of dax.r4.large, replication factor 3, and a target subnet group, then poll DescribeClusters until the cluster status is available.

### Scale a DAX Cluster for Traffic Spikes

Increase or decrease the number of read replicas in a DAX cluster as traffic patterns change. IncreaseReplicationFactor adds nodes for a marketing event or product launch, and DecreaseReplicationFactor removes them once the spike subsides, keeping the cluster sized to actual demand without re-creating it.

Example prompt: Call IncreaseReplicationFactor on cluster my-dax-cluster with NewReplicationFactor 5 and verify the cluster returns to status available.

### Manage Cluster Parameter Groups

Create, update, and inspect DAX parameter groups to control TTL, query cache size, and engine-level tuning. Parameter groups let multiple clusters share a tested configuration and roll out changes via DescribeParameters and parameter group updates rather than per-cluster edits.

Example prompt: Create a parameter group named dax-prod-defaults, update query-ttl-millis to 600000, and attach it to two existing DAX clusters.

### Agent-Driven Cluster Lifecycle Management

An AI agent connected via Jentic can provision DAX clusters from a natural-language request, scale them in response to monitoring alerts, and decommission them on schedule. Jentic returns the matching DAX operation and its input schema so the agent can call CreateCluster, IncreaseReplicationFactor, or DeleteCluster with structured arguments and recover cleanly from validation errors.

Example prompt: Search Jentic for 'create a DAX cluster', load the CreateCluster schema, execute with the requested cluster name and node type, then poll DescribeClusters until status is available.

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| POST | /#X-Amz-Target=AmazonDAXV3.CreateCluster | Create a new DAX cluster |
| POST | /#X-Amz-Target=AmazonDAXV3.DescribeClusters | Describe one or more DAX clusters |
| POST | /#X-Amz-Target=AmazonDAXV3.IncreaseReplicationFactor | Add read replicas to a cluster |
| POST | /#X-Amz-Target=AmazonDAXV3.DecreaseReplicationFactor | Remove read replicas from a cluster |
| POST | /#X-Amz-Target=AmazonDAXV3.DeleteCluster | Delete a DAX cluster |
| POST | /#X-Amz-Target=AmazonDAXV3.CreateSubnetGroup | Create a subnet group for cluster placement |
| POST | /#X-Amz-Target=AmazonDAXV3.DescribeEvents | List recent cluster events |

## Key resources

- **Cluster** — Create, describe, scale, and delete DAX clusters that cache DynamoDB reads.
- **Parameter Group** — Manage tunable engine parameters such as TTL and query cache size.
- **Subnet Group** — Define VPC subnets where cluster nodes are placed for HA.
- **Event** — Retrieve cluster lifecycle and failure events for diagnostics.
- **Tags** — Apply and list tags on DAX clusters for cost allocation and governance.

## Why Jentic

- **Setup:** Wiring Amazon DynamoDB Accelerator by hand means implementing AWS Signature v4 request signing, resolving the regional dax host, and setting the X-Amz-Target header to route each JSON action to the right operation. Through Jentic you install once, import Amazon DynamoDB Accelerator from the API Directory, store the AWS credentials once, and your agent calls it.
- **Permission scoping:** This API routes every call through a single endpoint with the action named in the request, covering cluster operations like CreateCluster, DescribeClusters, and IncreaseReplicationFactor. Limit the agent to the operations it needs, such as DescribeClusters and DescribeEvents, so DeleteCluster is not included unless you add it.
- **Credential handling:** Your AWS credentials are stored once, encrypted, by your own Jentic One instance and injected at execution time. They never enter the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'create a DAX cluster' or 'add read replicas to my cache', and Jentic returns the matching Amazon DynamoDB Accelerator operation with its input schema so the agent calls the right endpoint without browsing the AWS service reference.

## Related APIs

- **Amazon Data Lifecycle Manager** — Schedules backups for AWS resources alongside DAX-fronted DynamoDB workloads.
- **AWS RDS Data API** — HTTP-based access to relational databases when DynamoDB is not the right model.
- **Amazon DocumentDB** — Document database control plane for MongoDB-compatible workloads.

## FAQ

### Which OpenAPI specification does this Amazon DynamoDB Accelerator (DAX) page describe?

A curated, agent-optimized Jentic specification covering 21 DAX control plane operations. AWS describes DAX through its own official service model, the Smithy model in the `aws/api-models-aws` repository, and documents all 21 operations as reference pages in its API documentation at `https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/`. That model is official, but it is not an OpenAPI document. The OpenAPI variant here descends from the community APIs.guru entry at `https://api.apis.guru/v2/specs/amazonaws.com/dax/2017-04-19/openapi.json`, generated from an AWS SDK model by the third-party aws2openapi converter, and Jentic keeps it validated and agent-ready. Get started with Jentic One, the self-hosted execution layer.

### What authentication does the Amazon DAX API use?

The DAX control plane API uses AWS Signature Version 4 (HMAC) signing with an AWS access key ID and secret access key. Through Jentic, those credentials live encrypted in your Jentic One instance and are injected into signed requests at execution time, so the agent never sees the raw secret access key.

### Can I scale a DAX cluster up and down with the API?

Yes. Use IncreaseReplicationFactor to add read replicas and DecreaseReplicationFactor to remove them. The cluster remains available during scaling, so no recreation is needed for routine capacity changes.

### What are the rate limits for the Amazon DAX API?

The DAX control plane shares standard AWS service quotas, which are managed per account and region rather than published as fixed per-second limits in the spec. Treat sustained CreateCluster or scaling calls as throttle-prone and back off on ThrottlingException responses.

### How do I provision a DAX cluster through Jentic?

Search Jentic for 'create a DAX cluster', load the CreateCluster operation schema, then execute it with parameters like ClusterName, NodeType, ReplicationFactor, and SubnetGroupName. Run pip install jentic to get the SDK and use the async search and execute pattern.

### Does this API serve cached data, or only manage clusters?

This API only manages clusters and configuration. Reading and writing cached items goes through the DAX data-plane client libraries (which speak the DAX wire protocol) against the cluster endpoint returned by DescribeClusters.

### Can I limit what my agent is allowed to do with the AWS DAX API?

Yes. Because Jentic One is self-hosted, your own rules decide which DAX operations and credentials the agent may use, even though every call routes through one endpoint with the action named in the request. You can allow the agent only the operations it needs, such as DescribeClusters and DescribeEvents for read-only monitoring, so a destructive action like DeleteCluster is never available unless you add it. Scaling actions like IncreaseReplicationFactor and DecreaseReplicationFactor can be granted or withheld the same way.