Sample Store - Credit Card Entry with Checkout Service
- Overview
- 1. Shopper Entry
- 2. Charge Calculation — Ordering Connector
- 3. Checkout — Submit Cart to Amazon
- 4. Testing
- 5. Operational Readiness
- Generate Project Task Lists
- Operational Readiness Checklist
- End-to-End Flow
Disclaimer: This document contains sample content for illustrative purposes only. Organizations should follow their own established best practices, security requirements, and compliance standards to ensure solutions are production-ready.
Overview
This page provides a consolidated view of all the capabilities, APIs, and documentation required to implement a Just Walk Out store using credit card entry where Amazon manages the full payment lifecycle. The retailer calculates pricing and submits the cart to Amazon via the Checkout Service API. Amazon validates the cart, charges the shopper's credit card, and generates the receipt.
Store Profile
| Attribute | Value |
|---|---|
| Entry Method | Credit card |
| Identity Verification | Amazon-managed |
| Charge Calculation | Order Delegation via Create Purchases API |
| Payment Processing | Amazon-managed via Checkout Service API |
| Receipts | Amazon-managed |
APIs in Scope
| API | Endpoint | Purpose |
|---|---|---|
| Create Purchases | POST /v1/order/purchases |
Receive cart and calculate pricing (Order Delegation) |
| Checkout Cart | POST /v1/checkout/carts |
Submit priced cart to Amazon for payment and receipt generation |
Required Configurations
The following configurations must be completed in the Merchant Portal and AWS before the store can operate:
| Configuration | Owner | Description |
|---|---|---|
| AWS Account Allowlisting (Catalog API) | Amazon / Retailer | Retailer's AWS account must be allowlisted to invoke the Catalog API |
| Merchant Portal — Catalog API | Amazon | Catalog API configured for the merchant in the Merchant Portal |
| SNS Subscription (Catalog Notifications) | Retailer | SQS queue subscribed to Amazon's SNS topic for catalog upload results |
| Ordering Connector — ARN Allowlisting | Retailer | Ordering Gateway ARNs allowlisted in the retailer's Ordering Connector |
| Merchant Portal — Ordering Connector | Amazon | Ordering Connector configured and associated with store(s) |
| Ordering Connector — Connectivity Test | Retailer | Connectivity test completed via Merchant Portal |
| Checkout Service — API Access | Amazon / Retailer | Retailer's AWS account allowlisted to invoke Checkout Cart API |
Available Partners
The following partners have pre-built integrations that support the APIs required for this store model (Catalog, Ordering Connector, and Checkout Integration):
| Partner | Catalog | Ordering Connector | Checkout Integration |
|---|---|---|---|
| Cognizant Technology Solutions | Yes | Yes | Yes |
| MyVenue | Yes | Yes | Yes |
| retailcloud | Yes | Yes | Yes |
| Square (Via Daemon) | Yes | Yes | Yes |
| Tapin2 | Yes | Yes | Yes |
Partners with full API coverage can use the Checkout Service Validation Plan to validate their integration for new store deployments without re-testing the full build.
The following partners support individual integrations and can be combined to cover all required APIs:
| Partner | Available Integrations |
|---|---|
| First Class Nevada | Ordering Connector, Checkout Integration |
| Hudson | Ordering Connector, Checkout Integration |
| Cognizant Technology Solutions | Catalog, Ordering Connector, Checkout Integration |
| RapidRMS | Catalog |
| RIOT Insight | Catalog |
1. Shopper Entry
Amazon manages gate authorization independently. When a shopper taps their credit card at the gate, Amazon verifies the payment instrument, places a pre-authorization hold, and opens the gate. No retailer callback is involved.
| Step | Action |
|---|---|
| 1 | Shopper taps credit card at gate |
| 2 | Amazon verifies payment instrument |
| 3 | Amazon places pre-auth on card |
| 4 | Gate opens |
2. Charge Calculation — Ordering Connector
After the shopper exits, Amazon calls the retailer's Create Purchases API with the virtual shopping cart. The retailer calculates pricing, applies promotions and taxes, and returns a purchaseId. This is the Order Delegation model where the retailer owns charge calculation.
Key Documentation
| Topic | Link |
|---|---|
| Charge Calculation Overview | Charge Calculation Overview |
| Setup | Charge Calculation Setup |
| API Setup | Configure Charge Calculation API |
| Charge Calculation API | Create Purchases |
| CloudFormation Templates | Ordering Connector CloudFormation Templates |
How It Works
- Shopper exits the store
- Amazon sends the virtual cart to the retailer via
POST /v1/order/purchases - Retailer calculates pricing, promotions, and taxes using their POS system
- Retailer returns a purchaseId for cross-system tracking
- Empty carts return an empty purchaseId and trigger pre-auth cancellation
3. Checkout — Submit Cart to Amazon
After calculating pricing, the retailer submits the priced cart to Amazon via the Checkout Service API. Amazon validates the cart data (line items, totals, promotions, taxes), charges the shopper's credit card, and generates the receipt.
Key Documentation
| Topic | Link |
|---|---|
| Checkout Service Overview | Checkout Service |
How It Works
| Step | Action |
|---|---|
| 1 | Retailer receives cart via Create Purchases API |
| 2 | Retailer calculates pricing, promotions, and taxes |
| 3 | Retailer calls POST /v1/checkout/carts with the priced cart |
| 4 | Amazon validates line items match the original cart |
| 5 | Amazon validates order totals (priceTotal = subTotal - promotionsTotal + salesTaxTotal) |
| 6 | Amazon charges the shopper's credit card |
| 7 | Amazon returns orderId on success (201) |
Validation Rules
Amazon validates the checkout payload before processing payment:
| Validation | Description |
|---|---|
| Cart content match | lineItems must match the cart Amazon sent to the Ordering Connector |
| Price calculation | totalPrice = price - promotions + salesTax for each line item |
| Order totals | priceTotal = subTotal - promotionsTotal + salesTaxTotal |
| Decimal precision | All amounts must be rounded to 2 decimal places |
| Non-empty cart | lineItems array must not be empty |
| Item pricing | Every line item must have a price |
Empty Cart Handling
When the shopper exits without taking items, Amazon sends an empty cart to the retailer's Create Purchases API. The retailer returns a valid purchaseId. The retailer does not need to call the Checkout API or cancel the pre-auth — Amazon cancels the pre-auth automatically.
4. Testing
Test Plan
| Test Plan | Link |
|---|---|
| Checkout Service Store Test Plan | Test Plan |
Validation Plan (Existing Partners)
For existing partners who have pre-built integrations and need to validate their integration for a new store deployment without re-testing the full build:
| Validation Plan | Link |
|---|---|
| Checkout Service Validation Plan | Validation Plan |
Existing Test Cases
| Test Cases | Link |
|---|---|
| Checkout Service | Checkout Service Test Cases |
| Create Purchases | Create Purchases Test Cases |
| Cart Payload Validation | Cart Payload Validation Test Cases |
| API Gateway Alarm Validation | See API Gateway Alarm Test below |
API Gateway Alarm Test
Objective: Confirm that API Gateway CloudWatch alarms trigger correctly when error thresholds are breached.
| Test Case | Trigger Condition | Expected Alarm Behavior |
|---|---|---|
| 4xx Error Rate Breach | Send repeated invalid requests to exceed the 4xx error rate threshold | CloudWatch alarm transitions to ALARM state; SNS notification delivered to configured subscribers |
| 5xx Error Rate Breach | Simulate backend failures to exceed the 5xx error rate threshold | CloudWatch alarm transitions to ALARM state; SNS notification delivered to configured subscribers |
| Latency Threshold Breach | Send requests that cause response latency to exceed the p99 threshold | CloudWatch alarm transitions to ALARM state; SNS notification delivered to configured subscribers |
| Throttling Alarm | Send requests exceeding the configured rate limit to trigger 429 responses | CloudWatch alarm transitions to ALARM state; SNS notification delivered to configured subscribers |
| Alarm Recovery | Stop sending error-generating traffic after alarm triggers | CloudWatch alarm transitions back to OK state within the configured evaluation period |
Test Steps:
- Identify the CloudWatch alarms configured for your API Gateway (4xx rate, 5xx rate, latency, throttling)
- Note the alarm thresholds and evaluation periods
- Generate traffic that breaches the threshold (e.g., send requests with invalid payloads for 4xx, or trigger backend errors for 5xx)
- Verify the alarm transitions to ALARM state in the CloudWatch console
- Verify the SNS notification is delivered (email, PagerDuty, Slack, or other configured target)
- Stop the error-generating traffic and confirm the alarm returns to OK state
Acceptance Criteria:
- All configured alarms trigger within the expected evaluation period when thresholds are breached
- Notifications are delivered to all configured subscribers
- Alarms recover to OK state when the breach condition is resolved
- No false positives during normal operational traffic
Testing Phases
| Phase | Link |
|---|---|
| Connectivity Testing | Connectivity Testing |
| End-to-End Testing | E2E Testing |
| Load Testing | Load Testing |
5. Operational Readiness
| Resource | Link |
|---|---|
| Operational Readiness Overview | Overview |
| Checkout Service Store Well-Architected | Well-Architected Review |
Generate Project Task Lists
Download Project Task Lists
Generate comprehensive project task lists with task owners, status tracking, and acceptance test cases for your Credit Card Entry with Checkout Service JWO store implementation.
Operational Readiness Checklist
Would you like an operational readiness checklist?
Download a checklist covering all operational readiness items for your Credit Card Entry + Checkout Service JWO store launch.
End-to-End Flow
┌─────────────────────────────────────────────────────────────────┐
│ SHOPPER ENTRY │
│ │
│ 1. Shopper taps credit card at gate │
│ 2. Amazon verifies payment instrument │
│ 3. Amazon places pre-auth on card │
│ 4. Gate opens │
│ │
└─────────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────┐
│ SHOPPING │
│ │
│ Shopper picks up items ──► Amazon tracks virtual cart │
└─────────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────┐
│ SHOPPER EXIT & CHARGE CALCULATION │
│ │
│ 1. Shopper exits store │
│ 2. Amazon sends cart to retailer │
│ 3. Retailer calls ──► POST /v1/order/purchases │
│ └── Returns purchaseId (or empty for empty cart) │
│ 4. Retailer calculates pricing, promotions, taxes │
└─────────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────┐
│ CHECKOUT & PAYMENT │
│ │
│ 1. Retailer calls ──► POST /v1/checkout/carts │
│ ├── Amazon validates cart content and totals │
│ ├── Amazon charges shopper's credit card │
│ └── Returns orderId (201) │
│ │
│ Empty cart ──► No checkout call ──► Amazon cancels pre-auth │
└─────────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────┐
│ POST-PURCHASE │
│ │
│ Amazon handles all post-purchase operations: │
│ • Receipts available via Just Walk Out receipt portal │
│ • Refunds managed by Amazon │
│ • Shopper accesses receipt history by payment card │
└─────────────────────────────────────────────────────────────────┘
