canonical: https://jentic.com/apis/amazonaws.com/amplify

# AWS Amplify

Jentic publishes the only available OpenAPI specification for AWS Amplify, keeping it validated and agent-ready. AWS Amplify Hosting provides continuous deployment and global hosting for full-stack web and mobile apps, building from a connected Git repository on every push. The control-plane API exposes 37 operations spanning apps, branches, deployments, backend environments, custom domains, webhooks, and access logs. Frontend platform teams use it to provision per-feature preview environments, automate domain bindings, and trigger deployments outside the standard Git push flow.

## For AI agents

Provision and manage Amplify Hosting apps, branches, deployments, custom domains, and webhooks for full-stack web and mobile applications via 37 operations.

## Scope

Does not handle backend resource provisioning, GraphQL API generation, or authentication user pools - use for hosting frontends, branches, deployments, and custom domains only.

## Capabilities

- Provision an Amplify Hosting app connected to a GitHub, Bitbucket, GitLab, or CodeCommit repository
- Create per-branch deployments and pull request preview environments with their own URLs
- Bind custom domains and subdomains to specific branches with automatic SSL via ACM
- Trigger deployments programmatically via webhooks or StartDeployment for non-Git asset uploads
- Inspect deployment jobs, retrieve build logs, and roll back to a previous successful deployment
- Manage backend environments that pair frontend branches with Amplify CLI generated cloud resources

## Use cases

### Per-Branch Preview Deployments

Frontend platform teams use AWS Amplify Hosting to give every feature branch its own preview URL with a real backend. CreateBranch on an Amplify app provisions a build pipeline keyed off the named Git branch; pushing to the branch triggers a build and deploy, and the resulting URL is available via GetBranch. Reviewers click straight to a live preview from a pull request, removing the need to spin up local environments.

Example prompt: Call POST /apps/{appId}/branches with branchName=feature-search and stage=PULL_REQUEST, then poll GetBranch until activeJobId reflects a successful deployment

### Custom Domain Automation

Marketing and platform teams use the domain endpoints to bind acquired domains and subdomains to specific Amplify branches. CreateDomainAssociation registers the apex and subdomain mappings, Amplify provisions the ACM certificate automatically, and GetDomainAssociation returns the DNS records that must be set on Route 53 or another DNS host. The whole flow takes a few minutes once DNS propagates.

Example prompt: Call POST /apps/{appId}/domains with domainName=example.com and subDomainSettings mapping www to the main branch, then GetDomainAssociation to fetch DNS validation records

### Deploy Static Assets without Git

Build pipelines that produce a static asset bundle outside Amplify's own build system use StartDeployment with a presigned source URL to push artefacts directly to a branch. Combined with CreateDeployment, this lets monorepos and external CI systems publish to Amplify Hosting without forcing every project onto Amplify's build environment. Deployments retain the same atomic swap and rollback behaviour as Git-driven deploys.

Example prompt: Call POST /apps/{appId}/branches/{branchName}/deployments to create a deployment, upload the asset zip to the returned URL, then POST start-deployment to publish

### AI Agent Frontend Deployer

An AI agent invoked through Jentic creates a new Amplify app from a Git URL, attaches a feature branch, and reports the resulting preview URL back to a chat workflow. The agent searches Jentic for the create-app operation, loads its schema, and executes calls without having to handle SigV4 signing or Amplify's branch lifecycle quirks manually.

Example prompt: Search Jentic for create amplify app, execute it with a repository URL and access token reference, then call CreateBranch for main and return the branch URL

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| POST | /apps | Create a new Amplify Hosting app connected to a Git repository |
| GET | /apps | List all Amplify Hosting apps in the account |
| POST | /apps/{appId}/branches | Create a deployment branch for an app |
| POST | /apps/{appId}/branches/{branchName}/deployments | Create a deployment for a branch with a presigned upload URL |
| POST | /apps/{appId}/domains | Bind a custom domain to an Amplify app and its branches |
| POST | /apps/{appId}/webhooks | Create a webhook that triggers a deployment when called |

## Key resources

- **Apps** — Create, list, update, and delete Amplify Hosting applications connected to a Git repository
- **Branches** — Manage per-branch deployment pipelines including pull-request preview branches
- **Deployments** — Trigger, list, and inspect deployment jobs for a branch
- **Domains** — Bind custom domains and subdomains to branches with automatic SSL
- **Webhooks** — Create and rotate webhooks that trigger Amplify deployments from external systems
- **Backend Environments** — Pair a frontend branch with an Amplify CLI managed backend environment

## Why Jentic

- **Setup:** Wiring AWS Amplify Hosting by hand means signing every request with AWS Signature Version 4 and resolving the amplify.{region}.amazonaws.com host for your region. Through Jentic you install once, import AWS Amplify from the API Directory, store your AWS access key and secret once, and your agent calls it.
- **Permission scoping:** Amplify puts the app id in the URL path (/apps/{appId}/branches, /apps/{appId}/domains, and similar), so a rule can pin the agent to one hosting app and its branches, deployments, and domains. You choose the operations it may call, so actions like creating new apps with POST /apps are not included unless you add them.
- **Credential handling:** Your AWS access key and secret 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 an Amplify app' or 'attach a custom domain to a branch', and Jentic returns the matching Amplify Hosting operation with its input schema so the agent does not have to memorise CreateApp versus CreateBranch versus CreateDeployment naming.

## Related APIs

- **AmplifyBackend** — Manages Amplify CLI generated backend resources that pair with Amplify Hosting frontend branches
- **AWS Certificate Manager** — Issues the SSL certificates that Amplify uses for custom domain bindings
- **Netlify** — Frontend hosting platform with similar Git-driven deploys and preview environments

## FAQ

### Why is there no official OpenAPI spec for AWS Amplify?

AWS does not publish an OpenAPI specification for Amplify Hosting; the official surface is the AWS SDKs and the Smithy model. Jentic generates and maintains this spec so that AI agents and developers can call AWS Amplify via structured tooling. It is validated against the live API and kept up to date. Get started with Jentic One, the self-hosted execution layer.

### What authentication does the AWS Amplify API use?

AWS Amplify Hosting uses AWS Signature Version 4 (SigV4) signed with an IAM access key id and secret access key, optionally with an STS session token. Through Jentic the access key id and secret access key are stored encrypted in the vault and SigV4 signing is performed server side, so the agent never sees the raw secret access key.

### Can I trigger a deployment without pushing to Git with the AWS Amplify API?

Yes. Call POST /apps/{appId}/branches/{branchName}/deployments to create a deployment with a presigned URL, upload your built asset zip to that URL, then call StartDeployment to publish it. This lets external CI systems push to Amplify Hosting without using Amplify's built-in build.

### What are the rate limits for the AWS Amplify API?

Amplify applies per-region throttling on each control-plane operation. Read operations like ListApps and GetBranch are throttled at higher rates than mutating operations like CreateApp and StartDeployment. ThrottlingException responses should be retried with exponential backoff and a small jitter.

### How do I create an Amplify app with the AWS Amplify API through Jentic?

Install the SDK with pip install jentic, search Jentic for create amplify app, load the CreateApp operation schema, and execute it with the repository URL, platform, and access token reference. Jentic handles SigV4 signing and returns the new appId, which you can then use to create branches and deployments.

### Can I bind a custom domain to a specific Amplify branch?

Yes. Use POST /apps/{appId}/domains with subDomainSettings entries that map a prefix to a branch - for example, www to main and staging to the staging branch. Amplify provisions the ACM certificate automatically and returns the DNS validation records you must set on your DNS provider.

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

Yes. Because you run Jentic One yourself, your own rules decide which Amplify operations and credentials the agent may use. Amplify carries the app id in the URL path, as in /apps/{appId}/branches and /apps/{appId}/domains, so a rule can pin the agent to a single hosting app and only its branches, deployments, and domains. You also choose exactly which operations it may call, so account-wide actions like creating new apps with POST /apps stay out of reach unless you add them.