Sample Store - App Entry + Credit Card Entry

• Introduction
• Integration Models at a Glance
• How They Work Together
  • Required Configurations
  • Available Partners
• Store Flow Diagram
• Model Deep Dives
  • App Entry
  • Credit Card Entry
  • Catalog API
• Detailed Integration Reference
  • Store Profile
  • APIs in Scope
• 1. Catalog Management
  • Key Documentation
  • Integration Summary
• 2. Shopper Entry — App-Based Authorization
  • Key Documentation
  • Integration Summary
  • Gate Behavior — App Entry
• 3. Shopper Entry — Credit Card
  • Gate Behavior — Credit Card Entry
• 4. Charge Calculation — Order Delegation
  • Key Documentation
  • Integration Summary
• 5. Payment Lifecycle
  • Key Documentation
  • Payment Flow
• 6. Entry Method Differences
• 7. Testing
  • Test Plans
  • Test Cases
  • Testing Phases
• 8. Operational Readiness
• 9. Data Reporting
  • Reporting Options
  • Key Documentation
  • Intra-Day S3 Reporting
  • Event Feed Reporting
  • Choosing Between Options
• 10. Shopper Self-Service Portal
  • Why a Portal Is Needed
  • Portal Capabilities
  • Integration Points
• 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.

Introduction

This document provides a high-level overview of a retail store that leverages Amazon's Just Walk Out (JWO) technology using two complementary shopper entry models — App Entry and Credit Card Entry — alongside the Catalog API for product management. Together, these components enable a seamless, frictionless shopping experience while giving the retailer full control over identity, fraud, pricing, and payment.

---

Integration Models at a Glance

Model	Best For	Key Retailer Value
App Entry	Shoppers with a retailer mobile app; loyalty-driven environments	Full control over shopper identity, loyalty programs, promotions, and payment instruments; enables personalized experiences tied to the retailer's app ecosystem
Credit Card Entry	High-throughput, low-friction venues (stadiums, airports, transit); no app required	Frictionless card-tap entry with no app dependency; ideal for captive audiences where speed and simplicity matter most
Catalog API	Any store using JWO	Keeps product catalog in sync with Amazon's recognition engine; ensures accurate cart building by maintaining current SKU-level item data (name, price, barcode)

---

How They Work Together

Both App Entry and Credit Card Entry can coexist in the same store, each serving a different type of shopper at entry. The Catalog API is a shared dependency for both — it ensures Amazon can correctly identify the items shoppers pick up, regardless of how they entered.

The retailer retains full ownership of:

• Fraud and abuse decisions
• Pricing, promotions, and tax calculations
• Payment processing and post-purchase activities (receipts, returns, refunds)

---

Required Configurations

The following configurations must be completed in the Merchant Portal and AWS before the store can operate:

Configuration	Owner	Applicable Entry Model	Description
AWS Account Allowlisting (Catalog API)	Amazon / Retailer	Both	Retailer's AWS account must be allowlisted to invoke the Catalog API
Merchant Portal — Catalog API	Amazon	Both	Catalog API configured for the merchant in the Merchant Portal
SNS Subscription (Catalog Notifications)	Retailer	Both	SQS queue subscribed to Amazon's SNS topic for catalog upload results
Identity Connector — ARN Allowlisting	Retailer	App Entry	Identity Gateway ARNs allowlisted in the retailer's Identity Connector
Merchant Portal — Identity Connector	Amazon	App Entry	Identity Connector configured and associated with store(s)
Identity Connector — Connectivity Test	Retailer	App Entry	Connectivity test completed via Merchant Portal
Mobile App — QR Code Generation	Retailer	App Entry	Mobile app generates Scan Key Codes per JWO specifications
Ordering Connector — ARN Allowlisting	Retailer	Both	Ordering Gateway ARNs allowlisted in the retailer's Ordering Connector
Merchant Portal — Ordering Connector	Amazon	Both	Ordering Connector configured and associated with store(s)
Ordering Connector — Connectivity Test	Retailer	Both	Connectivity test completed via Merchant Portal
Payment Service — API Access	Amazon / Retailer	Both	Retailer's AWS account allowlisted to invoke Adjust, Cancel, and Capture Charge APIs
Refund API — API Access	Amazon / Retailer	Both	Retailer's AWS account allowlisted to invoke Refund API
Report Payment Status — API Access	Amazon / Retailer	Both	Retailer's AWS account allowlisted to invoke Report Payment Status API
Get Transactional Data — API Access	Amazon / Retailer	Both	Retailer's AWS account allowlisted to invoke Get Transactional Data API
Get Shopper Identity — API Access	Amazon / Retailer	Both	Retailer's AWS account allowlisted to invoke Get Shopper Identity API
Payment Processor — Retailer Selected	Retailer	Both	Retailer's payment processor configured and integrated

Available Partners

The following partners have pre-built integrations that support the APIs required for this store model (Catalog, Identity Connector, Ordering Connector, and Payments Integration):

Partner	Catalog	Identity Connector	Ordering Connector	Payments Integration
SkyTab Venue	Yes	Yes	Yes	Yes

The following partners support individual integrations and can be combined to cover all required APIs:

Partner	Available Integrations
Compass Digital	Catalog, Identity Connector, Ordering Connector
Grubhub	Catalog, Identity Connector, Ordering Connector
Sodexo Everyday	Catalog, Identity Connector, Ordering Connector
Tapin2	Catalog, Identity Connector, Ordering Connector
Transact Campus	Catalog, Identity Connector, Ordering Connector
retailcloud	Catalog, Ordering Connector, Payments Integration
Daemon	Catalog, Ordering Connector, Payments Integration
Oracle Symphony (Via Daemon)	Catalog, Ordering Connector, Payments Integration
Shopify (Via Daemon)	Catalog, Ordering Connector, Payments Integration
Compass Group UK & Ireland (SmartQ)	Catalog, Ordering Connector, Payments Integration

---

Store Flow Diagram

┌─────────────────────────────────────────────────────────────────┐
│              📦 CATALOG MANAGEMENT — Catalog API                 │
│                                                                  │
│  Retailer prepares catalog JSON                                 │
│       ──► Upload via Catalog API (max 10K items, 10 req/sec)    │
│       ──► Amazon validates & ingests items by SKU               │
│       ──► SNS/SQS notification with results                     │
│                                                                  │
│  ⚡ Shared dependency: Items available for cart recognition     │
│     in BOTH entry models below                                  │
└─────────────────────────────────────────────────────────────────┘
          │                                    │
          ▼                                    ▼
┌──────────────────────────────┐  ┌──────────────────────────────┐
│ 📱 APP ENTRY                  │  │ 💳 CREDIT CARD ENTRY           │
│    Mobile App Shoppers       │  │    Card Entry Shoppers        │
├──────────────────────────────┤  ├──────────────────────────────┤
│                              │  │                              │
│ 1. Shopper opens app,        │  │ 1. Shopper taps credit/debit │
│    generates QR code         │  │    card at gate              │
│                              │  │                              │
│ 2. Scans QR at entry gate    │  │ 2. Amazon calls Retailer     │
│                              │  │    Fraud & Abuse API         │
│ 3. Amazon calls Retailer     │  │                              │
│    Identity API              │  │ 3. Retailer: F&A decision    │
│                              │  │    ├─ Approved → gate opens  │
│ 4. Retailer: Identity &      │  │    └─ Denied → gate closed   │
│    F&A check                 │  │                              │
│    ├─ Approved → gate opens  │  │ 4. Shopper shops —           │
│    └─ Denied → gate closed   │  │    Amazon tracks items       │
│                              │  │                              │
│ 5. Shopper shops —           │  │ 5. Shopper exits             │
│    Amazon tracks items       │  │                              │
│                              │  │ 6. Amazon sends virtual cart │
│ 6. Shopper exits             │  │    to Retailer Ordering API  │
│                              │  │                              │
│ 7. Amazon sends virtual cart │  │ 7. Retailer: pricing,        │
│    to Retailer Ordering API  │  │    promotions, tax           │
│                              │  │                              │
│ 8. Retailer: pricing,        │  │ 8. Retailer processes payment│
│    promotions, tax           │  │    via Payment Processor     │
│                              │  │                              │
│ 9. Retailer charges shopper  │  │                              │
│    via own payment system    │  │                              │
└──────────────────────────────┘  └──────────────────────────────┘

---

Model Deep Dives

App Entry

The App Entry model is designed for retailers with an established mobile app and shopper loyalty ecosystem. Shoppers authenticate using a QR code generated within the retailer's app, giving the retailer complete control over identity verification and fraud decisions at the point of entry.

Why use it:

• Supports loyalty programs, personalized promotions, and app-based payment instruments
• Retailer controls the full shopper identity lifecycle
• Enables rich post-purchase experiences (digital receipts, order history, returns) within the app

Retailer responsibilities:

• Shopper identity lookup and fraud & abuse (F&A) checks at entry
• Cart pricing, promotions, and tax calculation
• Payment processing via the retailer's own payment systems

---

Credit Card Entry

The Credit Card Entry model is optimized for high-throughput environments where shoppers may not have — or want to use — a retailer app. Entry is handled via a standard credit or debit card tap, with Amazon pre-integrated with an External Payment Processor.

Why use it:

• No app download required — reduces friction for casual or one-time shoppers
• Ideal for captive audiences in venues like stadiums, airports, and transit hubs
• Fast entry via card tap supports high-volume, time-sensitive shopping scenarios

Retailer responsibilities:

• Fraud & abuse decision at entry (via delegated F&A APIs)
• Cart pricing, promotions, and tax calculation
• Payment processing via the External Payment Processor integration

---

Catalog API

The Catalog API enables the retailer to programmatically manage the product catalog that powers Amazon's item recognition engine. Without an accurate and up-to-date catalog, Amazon cannot correctly identify items shoppers pick up — making this a foundational dependency for both entry models.

Why use it:

• Ensures Amazon's JWO system recognizes items accurately at the SKU level
• Supports both JWO (UploadCatalog) and Dash Cart (UploadCartCatalog) services
• Provides validation, error reporting, and status notifications for every upload

Key constraints to be aware of:

• Maximum 10 requests per second
• Maximum 10,000 items per upload
• Pre-signed S3 result links are valid for 60 minutes

This integration architecture gives retailers the flexibility to serve diverse shopper populations — app users and card-only shoppers — under a single store footprint, while maintaining full control over the business logic that matters most: fraud decisions, pricing, and payment. The Catalog API ties it all together by ensuring the underlying product data is always accurate and current.

---

Detailed Integration Reference

This section provides a consolidated view of all the capabilities, APIs, and documentation required to implement a Just Walk Out store that supports both app-based entry and credit card entry. In this model, shoppers can enter the store by scanning a QR code from the retailer's mobile app or by tapping a credit card at the gate. The retailer manages shopper identity verification for app entry, delegates charge calculation to their own POS system, and orchestrates the full payment lifecycle through Amazon's Payment Service APIs for credit card entry shoppers.

Store Profile

Attribute	Value
Entry Method	Mobile app QR code scan and credit card tap at gate
Identity Verification	Retailer-managed via Verify Identity Keys API (app entry); Amazon-managed (credit card entry)
Charge Calculation	Order Delegation (retailer POS)
Payment Orchestration	Retailer-managed via Payment Service APIs
Receipt Data	Get Transactional Data + Get Shopper Identity APIs
Catalog Management	Catalog API

APIs in Scope

API	Endpoint	Purpose
Upload Catalog	POST /v1/catalog/upload	Upload product catalog to Amazon systems
Get Catalog Upload Status	POST /v1/catalog/getCatalogUploadStatus	Check catalog upload processing status
Verify Identity Keys	POST /v1/identity/identity-keys	Authorize app entry shoppers at the JWO gate
Create Purchases	POST /v1/order/purchases	Receive the shopping cart and create a purchase record
Adjust Charge	POST /v1/adjust/charge	Adjust the pre-auth to the cart total
Cancel Charge	POST /v1/cancel/charge	Cancel the pre-auth (empty cart)
Capture Charge	POST /v1/capture/charge	Capture the adjusted amount
Refund	POST /v1/refund	Refund a captured charge
Report Payment Status	POST /v1/feedback/payment-status	Report debt payoff to restore store access
Get Transactional Data	POST /v1/payment/transactional-data	Retrieve EMV data for receipts
Get Shopper Identity	POST /v1/identity/shopper	Retrieve shopper email for receipt delivery

---

1. Catalog Management

Before your store can operate, you must upload a product catalog to Amazon's systems. The catalog maps SKUs to barcodes, product names, and store IDs so that items picked up by shoppers can be identified.

Key Documentation

Topic	Link
Catalog Overview	Catalog Considerations
Catalog Data Fields	Catalog Items
Reference Architecture	Catalog Reference Architecture
API Setup	Configure Catalog API
Upload Catalog API	Upload Catalog
Get Upload Status API	Get Catalog Upload Status
Catalog Maintenance	Catalog Maintenance

Integration Summary

1. Set up your AWS account and IAM role with Invoke API permissions
2. Deploy the CloudFormation templates for SQS and connectivity testing
3. Onboard your AWS account and SQS ARN via the Merchant Portal
4. Confirm the SNS subscription for upload result notifications
5. Upload your catalog (max 10,000 items per request, 10 requests/second)
6. Track upload status via the Get Catalog Upload Status API or SNS/SQS notifications
7. Download and process the upload result report from the S3 presigned URL (valid for 60 minutes)

---

2. Shopper Entry — App-Based Authorization

Shoppers can enter the store by scanning a QR code generated by your mobile app. Amazon calls your Verify Identity Keys API to authorize the shopper. You verify the identity key and return a gate decision.

Key Documentation

Topic	Link
Entry Experience Overview	Shopper Entry Experience
Mobile App Entry	Mobile App Entry
API Setup	Configure Shopper Entry API
Verify Identity Keys API	VerifyIdentityKeys

Integration Summary

1. Build a mobile app that generates QR code Scan Key Codes per JWO specifications
2. Implement the Verify Identity Keys API (POST /v1/identity/identity-keys) as your Identity Connector
3. Decode the Base64-encoded identityKey and validate the shopper
4. Return visitor details with type SHOPPER, ASSOCIATE, or CASH_SHOPPER
5. Handle all requests idempotently using the authEvent.id
6. Ensure responses return within 2 seconds

Gate Behavior — App Entry

Response Code	Gate Action
200	Gate opens
400	Gate remains closed
401	Gate remains closed
429	Gate remains closed
500	Gate follows store default decision

---

3. Shopper Entry — Credit Card

Shoppers can also enter the store by tapping a credit card at the gate. Amazon handles identity verification and places a pre-auth on the card. No retailer-side identity integration is required for this entry method.

Gate Behavior — Credit Card Entry

Step	Action
1	Shopper taps credit card at gate
2	Amazon verifies payment instrument
3	Pre-auth placed on card
4	Gate opens

---

4. Charge Calculation — Order Delegation

After the shopper exits, Amazon calls your Create Purchases API with the virtual shopping cart. You calculate pricing, apply promotions and taxes, and return a purchaseId. This flow applies to both app entry and credit card entry shoppers.

Key Documentation

Topic	Link
Charge Calculation Overview	Charge Calculation Overview
Setup	Charge Calculation Setup
API Setup	Configure Charge Calculation API
Create Purchases API	Create Purchases

Integration Summary

1. Implement the Create Purchases API (POST /v1/order/purchases) as your Ordering Connector
2. Receive the cart with item SKUs, quantities, shopping trip details, and auth events
3. Use the authEvent payloadType to determine entry method: FINANCIAL = credit card, SCAN_CODE = app entry
4. Calculate pricing, promotions, and taxes using your POS system
5. Return a purchaseId for cross-system tracking
6. Handle empty carts by returning an empty purchaseId and triggering pre-auth cancellation
7. Route unrecognized SKUs to your bad cart handling process
8. Handle all requests idempotently using the idempotentShoppingTripId

---

5. Payment Lifecycle

After charge calculation, the retailer manages the payment flow through Amazon's Payment Service APIs. This applies to both entry methods.

Key Documentation

Topic	Link
Payment Processing Overview	Payment Processing
Setup	Payment Processing Setup
Payment Processor Setup	Payment Processor Setup
Pre-Authorization Setup	Pre-Authorization Setup
API Setup	Payment Service Setup
Adjust Charge API	Adjust Charge
Cancel Charge API	Cancel Charge
Capture Charge API	Capture Charge
Refund API	Refund Charge
Get Transactional Data API	Get Transactional Data
Get Shopper Identity API	Get Shopper Identity

Payment Flow

Step	API	Trigger
1. Order Delegation	POST /v1/order/purchases	Amazon sends cart after shopper exits
2. Adjust	POST /v1/adjust/charge	purchaseId returned, cart total known
3a. Capture	POST /v1/capture/charge	Adjust returns APPROVED
3b. Cancel	POST /v1/cancel/charge	Empty cart or adjust not needed
4. Refund (optional)	POST /v1/refund	Shopper requests refund (within 30 days)
5. Get Data	POST /v1/payment/transactional-data	After capture, for receipt generation
6. Get Identity	POST /v1/identity/shopper	For receipt delivery via email

---

6. Entry Method Differences

While most of the integration is shared, there are key differences based on how the shopper enters the store.

Capability	App Entry	Credit Card Entry
Identity Verification	Retailer-managed (Verify Identity Keys API)	Amazon-managed
Gate Authorization	Retailer returns 200/401 decision	Amazon verifies payment instrument
Pre-Auth Trigger	After identity verification succeeds	At card tap
authEvent payloadType	SCAN_CODE	FINANCIAL
Shopper ID in Cart	scanResult.id returned by Identity Connector	Not present (Amazon-managed)
Mobile App Required	Yes	No
Fallback Entry	Credit card tap	N/A

---

7. Testing

Test Plans

Test Plan	Link
Catalog Test Plan	Catalog Test Plan
App Entry Store Test Plan	App Entry Store Test Plan
Credit Card Entry Test Plan	Credit Card Test Plan

Test Cases

Test Cases	Link
Catalog Upload	Catalog Upload Test Cases
Inventory Synchronization	Inventory Sync Test Cases
Verify Identity Keys	Verify Identity Keys Test Cases
Create Purchases	Create Purchases Test Cases
Adjust Charge	Adjust Charge Test Cases
Capture Charge	Capture Charge Test Cases
Cancel Charge	Cancel Charge Test Cases
Refund Charge	Refund Charge Test Cases
Get Transactional Data	Get Transactional Data Test Cases
Get Shopper Identity	Get Shopper Identity Test Cases

Testing Phases

Phase	Description	Link
Functional / Mock Testing	Test APIs with mock data before connecting to live systems	Mock Testing
Connectivity Testing	Verify your AWS account can invoke Amazon APIs	Connectivity Testing
End-to-End Testing	Complete shopping journey from entry to charge for both entry methods	E2E Testing
Load Testing	Validate performance under peak concurrent load	Load Testing

---

8. Operational Readiness

Resource	Link
Operational Readiness Overview	Overview
App Entry Store WAR	App Entry Well-Architected Review
CC Entry WAR	Credit Card Well-Architected Review
Catalog Upload WAR	Catalog Upload Well-Architected Review

---

9. Data Reporting

Important: Amazon provides two reporting options for accessing your store's transaction data. You should select the option that best fits your data ingestion infrastructure and reporting frequency requirements. Both options can be used independently or together.

Reporting Options

Option	Delivery Method	Frequency	Best For
Intra-Day S3 Reporting	CSV files delivered to S3 via SNS/SQS notifications	Every 15 minutes (96 files per day)	Retailers with batch-oriented data pipelines; CSV-based ingestion; scheduled reconciliation workflows
Event Feed	JSON events delivered via Amazon EventBridge	Near real-time (per event)	Retailers needing real-time data; event-driven architectures; multiple stores or merchant accounts at scale

Key Documentation

Topic	Link
Reporting Overview	Data Reporting Overview
Intra-Day S3 Reporting	Intra-Day Reporting Solution
Event Feed Reporting	Event Feed Solution

Intra-Day S3 Reporting

The Intra-Day reporting solution delivers CSV files containing order data to an Amazon S3 bucket every 15 minutes. You subscribe to SNS notifications, process messages via SQS, and copy the files to your destination bucket using a Lambda function.

Integration steps:

1. Onboard your IAM role and SQS ARN via the Merchant Portal
2. Subscribe your SQS queue to the Amazon SNS topic
3. Deploy a Lambda function to process SQS messages and copy files from the Amazon S3 bucket
4. Implement de-duplication logic to prevent processing the same file twice
5. Implement upsert logic for orders that span multiple 15-minute files

Key considerations:

• S3 presigned URLs in notifications are valid for 60 minutes
• Files are KMS-encrypted; ensure your IAM role has decrypt permissions
• Orders may appear in multiple consecutive files — use upsert logic, not insert

Event Feed Reporting

The Event Feed solution delivers CART and PAYMENT events via Amazon EventBridge in near real-time. You configure EventBridge rules to route events to your preferred targets (S3, database, API endpoint, Lambda).

Integration steps:

1. Onboard to the Event Feed solution via the Merchant Portal
2. Configure EventBridge rules for event types: CART and PAYMENT
3. Set up targets for matched events (S3 bucket, Lambda function, API destination)
4. Implement dead-letter queue for failed event processing
5. Handle PAYMENT event subtypes: AuthorizationApproved, CaptureApproved, AuthorizationDeclined, CaptureDeclined

Key considerations:

• CART events contain: merchantSku, quantityValue, priceValue, taxValue, listPriceValue, promotionInfos
• PAYMENT events contain: amount, brand, cardLastFourDigits, reconciliationId, status
• Use EventBridge rules to filter and route events by type for alerting (e.g., decline events trigger alerts)

Choosing Between Options

Consideration	Intra-Day S3	Event Feed
Data format	CSV	JSON
Latency	Up to 15 minutes	Near real-time
Infrastructure	SNS/SQS + Lambda + S3	EventBridge + targets
Scalability for multi-store	Manual per-store setup	Scales across stores/accounts
Reconciliation approach	Batch (scheduled)	Event-driven (continuous)
Alerting on declines	Post-hoc (after file processing)	Real-time (EventBridge rule)

---

10. Shopper Self-Service Portal

Important: When the retailer manages the post-purchase experience (receipts, refunds, and payment orchestration), a shopper-facing self-service portal is required. This portal serves as the primary channel for shoppers to look up receipts, request refunds, and pay off outstanding balances (bad debt) to regain store access.

Why a Portal Is Needed

In this store model, the retailer — not Amazon — owns the post-purchase relationship with the shopper. Without a self-service portal, shoppers have no way to:

• Look up receipts — Shoppers need to retrieve itemized receipts for past shopping trips. For credit card entry shoppers, the portal can use the cardStatementTransactionId from the Get Transactional Data API to help shoppers match trips to their card statements.
• Request refunds — Shoppers need a channel to initiate refund requests. The portal validates eligibility (within 30-day window, valid reason) and calls the Refund API (POST /v1/refund) on the shopper's behalf.
• Pay off outstanding balances — When a shopper has bad debt (declined adjustment, partial capture, expired pre-auth), they are denied store entry. The debt resolution flow depends on the F&A strategy:
  • Amazon Managed F&A: The portal provides a payment channel to resolve the outstanding balance, after which the retailer calls the Report Payment Status API (POST /v1/feedback/payment-status) to clear the balance in Amazon's system and restore store access.
  • Retailer Managed F&A: The portal provides a payment channel to resolve the outstanding balance, after which the retailer clears the debt directly in their own system. No call to Amazon is required since the retailer controls the gate authorization decision.

Portal Capabilities

Capability	Description	APIs Used
Receipt Lookup	Search past shopping trips by date, payment card, or transaction ID	Get Transactional Data, Get Shopper Identity
Receipt Download	View and download itemized receipts with prices, promotions, taxes, and payment details	Get Transactional Data
Refund Request	Submit a refund request with reason code; track refund status	Refund (POST /v1/refund)
Outstanding Balance View	Display current outstanding balance with breakdown by shopping trip	Internal bad debt records
Debt Payoff (Amazon Managed F&A)	Process payment to resolve outstanding balance and report to Amazon	Payment processor + Report Payment Status (POST /v1/feedback/payment-status)
Debt Payoff (Retailer Managed F&A)	Process payment to resolve outstanding balance and clear debt internally	Payment processor + internal debt records
Debt Resolution Confirmation	Confirm balance cleared and store access restored	Report Payment Status (Amazon Managed F&A) or internal system (Retailer Managed F&A)

Integration Points

1. Authentication — Shopper must authenticate to access their data (e.g., by payment card lookup, email, or loyalty account)
2. Get Transactional Data API — Retrieve EMV data, card last four digits, reconciliationId, and cardStatementTransactionId for receipt display
3. Get Shopper Identity API — Retrieve shopper email for account matching and receipt delivery
4. Refund API — Process refund requests with idempotent refundRequestId and appropriate refundReasonCode
5. Report Payment Status API (Amazon Managed F&A only) — After a debt payoff payment is confirmed, report the updated settledAmount to Amazon to clear the outstanding balance
6. Internal debt clearance (Retailer Managed F&A only) — After a debt payoff payment is confirmed, clear the outstanding balance in the retailer's internal system; no Amazon API call needed
7. Shopper Authorization feedback loop — Once the debt is cleared (via Report Payment Status for Amazon Managed F&A, or internally for Retailer Managed F&A), the shopper should be re-authorized at the gate on their next visit

---

Generate Project Task Lists

---

Operational Readiness Checklist

---

End-to-End Flow

┌─────────────────────────────────────────────────────────────────┐
│                    PRE-LAUNCH SETUP                              │
│                                                                  │
│  1. Upload Catalog ──► POST /v1/catalog/upload                  │
│  2. Check Status ────► POST /v1/catalog/getCatalogUploadStatus  │
│  3. Process SNS/SQS notification ──► Download result report     │
└─────────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────────┐
│                    SHOPPER ENTRY (TWO PATHS)                     │
│                                                                  │
│  PATH A — App Entry:                                            │
│  1. Shopper opens mobile app ──► QR code generated              │
│  2. Shopper scans QR at gate                                    │
│  3. Amazon calls ──► POST /v1/identity/identity-keys            │
│  4. Retailer verifies identity key ──► 200 = gate opens         │
│  5. Pre-auth placed on payment instrument                       │
│                                                                  │
│  PATH B — Credit Card Entry:                                    │
│  1. Shopper taps credit card at gate                            │
│  2. Amazon verifies payment instrument                          │
│  3. Pre-auth placed on card ──► gate opens                      │
└─────────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────────┐
│                    SHOPPING                                       │
│                                                                  │
│  Shopper picks up items ──► Amazon tracks virtual cart           │
└─────────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────────┐
│                    SHOPPER EXIT & CHARGE (SHARED FLOW)            │
│                                                                  │
│  1. Shopper exits store                                         │
│  2. Amazon calls ──► POST /v1/order/purchases                   │
│  3. Retailer calculates pricing, promotions, taxes              │
│  4. Retailer returns purchaseId                                 │
│  5. Retailer calls ──► POST /v1/adjust/charge                   │
│     ├── APPROVED ──► POST /v1/capture/charge                    │
│     └── DECLINED ──► Bad debt workflow                          │
│  6. Empty cart ──► POST /v1/cancel/charge                       │
└─────────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────────┐
│                    POST-PURCHASE                                  │
│                                                                  │
│  1. Retailer calls ──► POST /v1/payment/transactional-data      │
│  2. Retailer calls ──► POST /v1/identity/shopper                │
│  3. Generate receipt with EMV data + shopper email               │
│  4. Refund (if needed) ──► POST /v1/refund (within 30 days)    │
│                                                                  │
│  Outstanding Balance Payoff (via Shopper Self-Service Portal):  │
│                                                                  │
│  Amazon Managed F&A:                                            │
│  5a. Shopper logs into portal ──► views outstanding balance     │
│  6a. Shopper pays balance ──► retailer payment processor        │
│  7a. Retailer calls ──► POST /v1/feedback/payment-status        │
│      └── Amazon clears debt ──► shopper re-authorized at gate   │
│                                                                  │
│  Retailer Managed F&A:                                          │
│  5b. Shopper logs into portal ──► views outstanding balance     │
│  6b. Shopper pays balance ──► retailer payment processor        │
│  7b. Retailer clears outstanding debt in internal system        │
│      └── Shopper re-authorized at gate (retailer F&A passes)   │
└─────────────────────────────────────────────────────────────────┘