AWS AppSync is a managed GraphQL and Pub/Sub API service that connects applications to data sources like DynamoDB, Lambda, and HTTP endpoints. The pricing includes query/mutation operations, real-time subscriptions, and optional caching. Understanding the per-operation costs is essential since GraphQL applications tend to generate high request volumes due to client-driven queries.
TL;DR: AppSync charges $4.00 per million query and mutation operations, $2.00 per million real-time update connection-minutes, and caching from $0.02/hour (small). The free tier covers 250,000 queries and 250,000 real-time updates per month for 12 months. For read-heavy APIs, enabling caching at $14.40/month can save thousands in query costs.
Query and Mutation Pricing
| Component | Free Tier (12 months) | Price |
|---|---|---|
| Queries and Mutations | 250,000/month | $4.00/million |
| Data Modification Operations | Included above | $4.00/million |
What Counts as an Operation?
Every GraphQL query, mutation, or subscription initiation is one operation. Importantly, a single GraphQL request that resolves multiple fields against different data sources still counts as one operation. This is a key advantage over REST APIs, where fetching the same data might require multiple HTTP calls.
For a mobile app with 50,000 daily active users making an average of 20 API calls each:
| Component | Calculation | Monthly Cost |
|---|---|---|
| Operations | 50,000 x 20 x 30 = 30M/month | $120.00 |
| Data Transfer (5 GB) | Standard rates | ~$0.45 |
| Total | $120.45 |
Real-Time Subscription Pricing
| Component | Free Tier (12 months) | Price |
|---|---|---|
| Connection-Minutes | 250,000/month | $2.00/million |
| Outbound Messages | Included in connection-minutes | -- |
How Connection-Minutes Work
A connection-minute is measured for each client connected to a real-time subscription. If 1,000 users each maintain a WebSocket connection for 60 minutes, that equals 60,000 connection-minutes.
For a chat application with 500 concurrent users connected 8 hours/day:
| Component | Calculation | Monthly Cost |
|---|---|---|
| Connection-Minutes | 500 x 480 min x 30 days = 7.2M | $14.40 |
Real-time updates are cost-effective compared to polling. The same chat app using REST polling every 5 seconds would generate 500 x 720 polls/hour x 8 hours x 30 days = 86.4 million API calls, costing $345.60 in query operations alone.
Caching Pricing
| Cache Instance | Hourly Cost | Monthly Cost |
|---|---|---|
| Small (1.6 GB) | $0.02 | ~$14.40 |
| Medium (6.1 GB) | $0.04 | ~$28.80 |
| Large (13.5 GB) | $0.08 | ~$57.60 |
| Extra Large (28.4 GB) | $0.15 | ~$108.00 |
| 2x Extra Large (58.2 GB) | $0.30 | ~$216.00 |
| 4x Extra Large (118 GB) | $0.55 | ~$396.00 |
When Caching Saves Money
AppSync caching stores resolved query results and returns them without hitting backend data sources. A small cache at $14.40/month that achieves a 70% cache hit rate on 10 million monthly queries saves $28.00 in query costs, a net savings of $13.60/month. For read-heavy APIs, the savings scale linearly.
Configure cache TTL per resolver to balance freshness and cost. Static data resolvers can use long TTLs (hours), while frequently changing data should use shorter TTLs (seconds to minutes).
AppSync vs API Gateway for GraphQL
| Factor | AppSync | API Gateway + Lambda |
|---|---|---|
| Per request | $4.00/million | $3.50/million (REST) or $1.00/million (HTTP) |
| Real-time | Built-in ($2.00/M conn-min) | WebSocket API ($1.00/M messages) |
| Caching | Built-in ($14.40+/month) | Requires separate ElastiCache |
| Data sources | Direct resolvers (DynamoDB, RDS) | Lambda required |
| Schema management | Automatic from GraphQL schema | Manual |
| Best for | GraphQL-native apps | REST APIs, custom GraphQL |
AppSync costs slightly more per operation ($4.00 vs $3.50/million) than API Gateway REST APIs, but eliminates Lambda invocation costs for simple CRUD operations through direct DynamoDB resolvers. For applications already using DynamoDB, AppSync can be 30-50% cheaper overall since you skip Lambda entirely.
Cost Optimization Strategies
-
Use direct resolvers instead of Lambda. AppSync can resolve queries directly against DynamoDB, Aurora, OpenSearch, and HTTP endpoints without Lambda. This eliminates Lambda invocation costs ($0.20/million) and reduces latency.
-
Enable caching for read-heavy APIs. If over 50% of your queries return the same data within a time window, a small cache instance pays for itself within days. Start with the small tier and monitor hit rates.
-
Batch and consolidate queries. Encourage client applications to fetch all needed data in a single GraphQL query rather than making multiple small queries. Each request is one operation regardless of how many fields it resolves.
-
Use subscriptions instead of polling. Real-time subscriptions at $2.00/million connection-minutes are dramatically cheaper than polling an API every few seconds, which generates millions of unnecessary query operations.
-
Monitor operation counts per resolver. Use CloudWatch metrics to identify which resolvers generate the most operations. Optimize or cache the highest-volume resolvers first for maximum cost impact.
Related Guides
- AWS API Gateway Pricing Guide
- AWS Lambda Pricing Guide
- AWS DynamoDB Pricing Guide
- AWS Cognito Pricing Guide
FAQ
How much does AppSync cost for a small application?
A small application with 500,000 queries/month and minimal real-time usage costs approximately $2.00/month after the free tier expires. During the 12-month free tier period, 250,000 queries/month are free, making AppSync essentially free for small projects.
Does AppSync charge for failed queries?
Yes. Failed queries (validation errors, resolver errors) still count as operations and are billed at $4.00/million. Implement client-side validation to reduce unnecessary failed requests.
Can I use AppSync without GraphQL?
Yes. AppSync now supports a Merged API feature and can be used with event-driven architectures. However, its pricing model is optimized for GraphQL workloads. For pure REST APIs, API Gateway HTTP APIs at $1.00/million are significantly cheaper.
Lower Your AppSync Costs with Wring
Wring helps you access AWS credits and volume discounts to lower your AppSync API costs. Through group buying power, Wring negotiates better rates so you pay less per million queries.
