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

# AWS AppSync

AWS AppSync is a managed GraphQL service that connects mobile and web clients to data sources such as DynamoDB, Lambda, RDS, OpenSearch, and HTTP endpoints. It handles schema management, real-time subscriptions, offline data sync, and resolver mappings for production GraphQL APIs.

## For AI agents

Use the AWS AppSync API to build and operate managed GraphQL APIs on AWS, with 51 operations covering the full control-plane lifecycle.

## Scope

Does not handle relational database hosting, REST endpoint creation, or front-end UI rendering - use for managed GraphQL API definition and resolution only.

## Capabilities

- Create GraphQL APIs with API key, IAM, Cognito, OIDC, or Lambda authentication
- Attach data sources to DynamoDB tables, Lambda functions, RDS clusters, OpenSearch, or HTTP endpoints
- Define resolvers and pipeline functions that translate GraphQL operations into data source calls
- Provision API caches to reduce latency on common queries
- Issue API keys for client access and manage their expiration
- Map custom domain names to GraphQL APIs through the domain name resource

## Use cases

### Mobile-app backend with DynamoDB

Power a mobile app's read and write operations through a managed GraphQL API backed by DynamoDB tables. AppSync handles schema validation, request and response mapping, and real-time subscriptions on top of DynamoDB Streams without requiring custom server code. Initial setup is typically a day for a multi-table schema.

Example prompt: Create a GraphQL API named 'mobile-api', add a DynamoDB data source pointing at the Posts table, and attach a resolver to the listPosts query.

### Aggregated data layer over multiple backends

Combine data from DynamoDB, Lambda functions, and external HTTP endpoints into a single GraphQL schema so client apps can fetch heterogeneous data with one round trip. Pipeline resolvers chain multiple data source calls together, and AppSync handles authentication, throttling, and logging at the API edge. Setup time depends on schema complexity but typically takes one to two days for a multi-source schema.

Example prompt: Create three data sources - Posts (DynamoDB), Recommendations (Lambda), and ExternalProfile (HTTP) - and attach a pipeline resolver to the getUserFeed query that chains them in order.

### Cached read-heavy GraphQL API

Reduce latency on read-heavy GraphQL queries by enabling an API cache. AppSync caches resolver responses according to the configured TTL and key strategy, so repeat queries for the same arguments hit the cache rather than the backing data source. This improves both response times and cost at high traffic volumes.

Example prompt: Create an API cache for the mobile-api GraphQL API with type T2_MEDIUM, TTL 300, and FULL_REQUEST_CACHING strategy.

### AI agent shipping GraphQL APIs through Jentic

An agent that scaffolds backend services on demand can spin up complete AppSync APIs by calling its operations through Jentic. The agent searches for the API and resolver intents, loads the schemas, and executes the calls with scoped credentials, so root AWS keys never enter its context. A multi-step API provisioning task becomes a single agent action.

Example prompt: Search Jentic for 'create a managed GraphQL API', load the CreateGraphqlApi schema, and execute it for an API named 'agent-built-graphql' with API_KEY auth.

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| POST | /v1/apis | Create a GraphQL API |
| POST | /v1/apis/{apiId}/datasources | Create a data source for a GraphQL API |
| POST | /v1/apis/{apiId}/functions | Create a reusable pipeline function |
| POST | /v1/apis/{apiId}/apikeys | Create an API key for client access |
| POST | /v1/domainnames | Create a custom domain name |
| POST | /v1/apis/{apiId}/ApiCaches | Create a cache for an API |

## Key resources

- **GraphqlApis** — Top-level GraphQL API definitions including authentication and logging configuration
- **DataSources** — Connections to DynamoDB tables, Lambda functions, RDS clusters, or HTTP endpoints
- **Resolvers** — Mappings from GraphQL fields to data source operations
- **Functions** — Reusable resolver pipeline steps
- **ApiKeys** — API keys used by clients authenticated through the API_KEY scheme
- **DomainNames** — Custom domain names that route clients to a GraphQL API

## Why Jentic

- **Setup:** Wiring AWS AppSync by hand means creating IAM credentials, choosing the right regional host from appsync.{region}.amazonaws.com, signing every request with AWS SigV4, and building your own retry and pagination handling. Through Jentic you install once, import AWS AppSync from the API Directory, store the AWS access key once, and your agent calls it.
- **Permission scoping:** AWS AppSync puts the API id in the URL path (/v1/apis/{apiId}/datasources, /v1/apis/{apiId}/functions), so a rule can pin your agent to one GraphQL API: it can add data sources and pipeline functions to that API and nothing else. You choose the operations it may call, so destructive ones like deleting an API or revoking an API key are not included unless you add them.
- **Credential handling:** Your AWS access key for AWS AppSync is stored once, encrypted, by your own Jentic One instance and signed with SigV4 at execution time. It never enters the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'create a managed GraphQL API' or 'attach a data source to an API', and Jentic returns the matching AWS AppSync operation with its input schema so the agent calls the right endpoint without browsing the AWS service reference.

## Related APIs

- **API Gateway V2 HTTP APIs** — API Gateway V2 exposes REST or HTTP APIs rather than GraphQL
- **Lambda function backends** — Lambda functions are a common AppSync data source for custom resolver logic
- **Amplify framework** — Amplify scaffolds AppSync schemas and client integrations for web and mobile apps

## FAQ

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

The AWS AppSync API uses AWS Signature Version 4 (HMAC) request signing with IAM-issued credentials, the same scheme as every AWS service API. Jentic's your Jentic One instance stores those AWS credentials encrypted in the vault, generates short-lived signed requests at execution time, and never passes raw access keys into the agent's context.

### Can I create a graphql API for my mobile app with the AWS AppSync API?

Yes - the AWS AppSync API exposes 51 operations including the actions needed for that scenario. Use the operations listed in the key endpoints section as the starting point, then chain calls as needed for your workflow.

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

AWS applies per-account, per-region request rate limits to the AWS AppSync control plane. Specific limits are not encoded in the OpenAPI spec; consult the AWS service quotas console for the AWS AppSync entry, and design retries with exponential backoff to absorb throttling responses.

### How do I create a managed GraphQL API through Jentic?

Run pip install jentic, then call client.search('create a managed GraphQL API') to discover the AWS AppSync operations that match. Load the schema for the chosen operation with client.load(...) and execute it with client.execute(...). Jentic handles AWS request signing automatically against the credentials stored in your Jentic One instance.

### Is the AWS AppSync API free to call?

AWS does not charge for control-plane API calls themselves on most AWS AppSync operations, but the underlying resources you create or operate (fleets, queries, deployments, and so on) incur usage charges according to the AWS AppSync pricing page. Refer to the AWS pricing page for the service to estimate cost.

### Which operations should an agent call first when working with the AWS AppSync API?

For most workflows, agents should start by listing existing resources to understand the current state, then call the create or update operation that matches the intent. The endpoints listed under Key Endpoints in the catalog give a ranked starting set.

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

Yes. Because you run Jentic One yourself, your own rules decide which AWS AppSync operations and which stored AWS credentials the agent may use. Since AppSync puts the API id in the URL path (for example /v1/apis/{apiId}/datasources and /v1/apis/{apiId}/functions), you can pin the agent to a single GraphQL API and allow only the calls it needs, such as adding data sources and pipeline functions. Destructive operations like deleting an API or revoking an API key stay out of scope unless you explicitly grant them.