Amazon Advertising API Integration for Agencies

As an agency managing Amazon advertising for multiple clients, manual campaign management quickly becomes unsustainable. Amazon's Advertising API provides the programmatic access you need to automate bid management, generate custom reports, and scale your operations from 10 clients to 100+ without proportionally increasing headcount.

In this comprehensive technical guide, we'll explore how agencies can leverage the Amazon Advertising API to build competitive advantages through automation, custom dashboards, and data-driven optimization at scale.

1. Amazon Advertising API Overview

The Amazon Advertising API is a suite of RESTful APIs that provide programmatic access to your advertising campaigns, enabling automation of tasks that would otherwise require manual work in the Advertising Console.

What the API Enables

• Campaign Management: Create, read, update, and archive campaigns programmatically
• Bid Automation: Adjust bids in real-time based on performance algorithms
• Bulk Operations: Manage thousands of keywords across hundreds of campaigns
• Custom Reporting: Pull performance data and create tailored dashboards
• Multi-Account Management: Manage multiple client accounts from a single interface
• Advanced Analytics: Combine Amazon data with other sources for deeper insights

API Components

The Amazon Advertising API consists of several components:

• Sponsored Products API: Manage Sponsored Products campaigns
• Sponsored Brands API: Manage Sponsored Brands campaigns (requires Brand Registry)
• Sponsored Display API: Manage display advertising campaigns
• Amazon DSP API: Access to programmatic display advertising (enterprise tier)
• Reporting API: Generate and download performance reports
• Portfolio API: Manage campaign portfolios and budget rules

Getting API Access

Requirements:

1. Amazon Advertising Account: Active account with campaign history
2. API Registration: Apply for API access through Amazon Advertising
3. OAuth 2.0 Setup: Configure Login with Amazon (LWA) credentials
4. Profile ID: Obtain profile IDs for each advertising account
5. Security Token Service: Implement token refresh mechanism

Application Process:

• Approval typically takes 3-5 business days
• Amazon reviews your use case and business model
• Agencies benefit from streamlined approval for multi-client management
• Technical documentation access granted upon approval

import requests
import time
from datetime import datetime, timedelta

class AmazonAdsAuth:
    """
    Handles authentication for Amazon Advertising API
    """
    def __init__(self, client_id, client_secret, refresh_token):
        self.client_id = client_id
        self.client_secret = client_secret
        self.refresh_token = refresh_token
        self.access_token = None
        self.token_expiry = None
        self.base_url = "https://advertising-api.amazon.com"
    
    def get_access_token(self):
        """Get valid access token, refresh if expired"""
        if self.access_token and self.token_expiry > datetime.now():
            return self.access_token
        
        # Request new access token
        url = "https://api.amazon.com/auth/o2/token"
        payload = {
            "grant_type": "refresh_token",
            "refresh_token": self.refresh_token,
            "client_id": self.client_id,
            "client_secret": self.client_secret
        }
        
        response = requests.post(url, data=payload)
        
        if response.status_code == 200:
            token_data = response.json()
            self.access_token = token_data["access_token"]
            # Set expiry 5 minutes before actual expiry for safety
            self.token_expiry = datetime.now() + timedelta(
                seconds=token_data["expires_in"] - 300
            )
            return self.access_token
        else:
            raise Exception(f"Auth failed: {response.text}")
    
    def get_headers(self, profile_id):
        """Get headers for API requests"""
        return {
            "Amazon-Advertising-API-ClientId": self.client_id,
            "Authorization": f"Bearer {self.get_access_token()}",
            "Amazon-Advertising-API-Scope": str(profile_id),
            "Content-Type": "application/json"
        }

2. Automated Campaign Management

The foundation of API integration is programmatic campaign management. This enables you to create, modify, and optimize campaigns at scale without manual console work.

Campaign Creation Automation

Creating campaigns programmatically is essential for agencies launching products for multiple clients simultaneously.

def create_campaign(auth, profile_id, campaign_data):
    """
    Create a new Sponsored Products campaign
    """
    endpoint = f"{auth.base_url}/v2/sp/campaigns"
    
    payload = {
        "name": campaign_data["name"],
        "campaignType": "sponsoredProducts",
        "targetingType": campaign_data["targeting_type"],  # "manual" or "auto"
        "state": "enabled",
        "dailyBudget": campaign_data["daily_budget"],
        "startDate": campaign_data["start_date"],  # Format: YYYYMMDD
        "bidding": {
            "strategy": "legacyForSales",  # or "autoForSales"
            "adjustments": [
                {
                    "predicate": "placementTop",
                    "percentage": 100  # +100% for top of search
                }
            ]
        }
    }
    
    response = requests.post(
        endpoint,
        headers=auth.get_headers(profile_id),
        json=payload
    )
    
    if response.status_code == 207:  # Multi-status response
        result = response.json()
        if result["success"]:
            return {
                "success": True,
                "campaign_id": result["campaignId"]
            }
        else:
            return {
                "success": False,
                "error": result["details"]
            }
    else:
        return {
            "success": False,
            "error": response.text
        }

Bulk Keyword Management

Managing thousands of keywords manually is impossible. The API enables bulk operations:

• Keyword Creation: Add hundreds of keywords in a single API call
• Bid Updates: Adjust bids across entire campaigns based on performance
• Negative Keywords: Bulk add negatives to prevent wasted spend
• Match Type Changes: Convert broad to phrase or exact based on data

Campaign Optimization Workflow

Automated Daily Optimization Process:

1. Data Retrieval: Pull previous day's performance via Reporting API
2. Analysis: Calculate ACoS, ROAS, conversion rates by keyword
3. Decision Logic: Apply rules-based or ML-based optimization decisions
4. Bid Adjustments: Update bids via API based on performance
5. Budget Allocation: Shift budget to high-performing campaigns
6. Negative Keyword Addition: Add poor performers to negative lists
7. Reporting: Generate client reports and alert on anomalies

3. Real-Time Bid Adjustments

Manual bid management can't compete with algorithmic automation. Real-time (or near real-time) bid optimization is where agencies gain competitive advantage.

Bid Optimization Strategies

1. Performance-Based Bidding

Adjust bids based on historical performance metrics:

• Increase bids for keywords with ACoS < target by 10-20%
• Decrease bids for keywords with ACoS > target by 15-25%
• Pause keywords with no conversions after 100+ clicks
• Boost top performers to maximize impression share

2. Time-Based Bidding (Dayparting)

Adjust bids by hour of day or day of week:

• Analyze conversion rates by time period
• Increase bids 20-50% during high-conversion windows
• Decrease bids 30-50% during low-conversion periods
• Consider timezone differences for international markets

3. Inventory-Based Bidding

Coordinate with inventory levels:

• Reduce bids when inventory is low (< 30 days)
• Increase bids when inventory is high (> 90 days)
• Pause campaigns automatically when out of stock
• Resume with lower bids when inventory is restocked

4. Competitive Response Bidding

React to competitive changes:

• Monitor lost impression share metrics
• Automatically increase bids if share drops significantly
• Adjust based on competitive pricing changes
• Defend brand terms aggressively

Machine Learning for Bid Optimization

Advanced agencies are implementing ML models for bid prediction:

• Features: Historical CPC, CTR, CVR, day of week, seasonality, inventory levels
• Models: Gradient boosting (XGBoost), neural networks, or ensemble methods
• Output: Optimal bid recommendation with confidence intervals
• Validation: A/B test ML bids vs rule-based bids to measure lift

4. Custom Reporting Dashboards

The Advertising Console's reporting is limited. Custom dashboards enable deeper insights and better client communication.

Reporting API Capabilities

The Reporting API provides access to detailed performance metrics:

• Granularity Levels: Campaign, ad group, keyword, product, search term
• Time Ranges: Daily, weekly, monthly, custom date ranges
• Metrics: Impressions, clicks, spend, sales, ACoS, ROAS, conversions
• Attribution: 7-day and 30-day attribution windows

Report Generation Process

1. Request Report: POST request specifying metrics, date range, and granularity
2. Polling: Report generation is asynchronous; poll status endpoint
3. Download: Once ready, download report (JSON, CSV, or gzip formats)
4. Processing: Parse and load into your database
5. Aggregation: Calculate derived metrics and trends
6. Visualization: Display in custom dashboard

def request_report(auth, profile_id, report_config):
    """
    Request a performance report from Amazon Advertising API
    """
    endpoint = f"{auth.base_url}/v2/sp/{report_config['report_type']}/report"
    
    payload = {
        "reportDate": report_config["date"],  # Format: YYYYMMDD
        "metrics": [
            "campaignName",
            "campaignId",
            "impressions",
            "clicks",
            "cost",
            "attributedConversions7d",
            "attributedSales7d",
            "acos"
        ]
    }
    
    response = requests.post(
        endpoint,
        headers=auth.get_headers(profile_id),
        json=payload
    )
    
    if response.status_code == 202:
        report_data = response.json()
        return {
            "success": True,
            "report_id": report_data["reportId"],
            "status": report_data["status"]
        }
    else:
        return {"success": False, "error": response.text}

def download_report(auth, profile_id, report_id):
    """
    Download completed report
    """
    # First check status
    status_endpoint = f"{auth.base_url}/v2/reports/{report_id}"
    status_response = requests.get(
        status_endpoint,
        headers=auth.get_headers(profile_id)
    )
    
    if status_response.status_code == 200:
        status_data = status_response.json()
        
        if status_data["status"] == "SUCCESS":
            # Download report
            report_url = status_data["location"]
            report_response = requests.get(report_url)
            
            if report_response.status_code == 200:
                # Decompress if gzipped
                import gzip
                import json
                
                data = gzip.decompress(report_response.content)
                report_data = json.loads(data)
                
                return {
                    "success": True,
                    "data": report_data
                }
        
        return {
            "success": False,
            "status": status_data["status"]
        }

Dashboard Design Best Practices

Executive Dashboard (Client-Facing):

• High-level KPIs: Total spend, sales, ACoS, TACoS, ROAS
• Trend charts: 30-day performance trends
• Top performers: Best campaigns, keywords, products
• Budget pacing: Burn rate vs daily budget
• Competitive benchmarks: Performance vs industry averages

Operational Dashboard (Internal Team):

• Detailed metrics by campaign, ad group, keyword
• Bid efficiency analysis and recommendations
• Search term reports with negative keyword suggestions
• Budget utilization and opportunity identification
• A/B test results and statistical significance

5. Multi-Client Campaign Management

The true power of API integration for agencies is managing hundreds of client accounts from a unified platform.

Multi-Account Architecture

Database Structure:

• Clients Table: Client information, contact details, contracts
• Profiles Table: Amazon Advertising profile IDs, marketplace, credentials
• Campaigns Table: Campaign data synced from API
• Keywords Table: Keyword performance data
• Reports Table: Historical performance data
• Optimization Rules: Client-specific optimization parameters

Workflow Automation:

1. Nightly Sync: Pull performance data for all clients (scheduled at 3 AM)
2. Morning Analysis: Run optimization algorithms across all accounts
3. Approval Queue: Flag significant changes for account manager review
4. Execution: Apply approved optimizations via API
5. Reporting: Generate and email client reports automatically
6. Alerting: Notify team of anomalies or critical issues

Scaling Considerations

• Parallel Processing: Process multiple accounts simultaneously (within rate limits)
• Job Queues: Use Celery, RabbitMQ, or AWS SQS for task distribution
• Caching Layer: Redis for session data and frequently accessed information
• Database Optimization: Indexing, partitioning for large datasets
• Monitoring: Application performance monitoring (APM) tools
• Error Recovery: Robust retry logic and failure notifications

Frequently Asked Questions

Conclusion

Amazon Advertising API integration is no longer a luxury for agencies—it's a necessity for competitive survival. As the Amazon advertising ecosystem becomes more complex and competitive, manual management simply cannot keep pace. Agencies that invest in API automation gain significant advantages: they can manage more clients with fewer resources, deliver better results through algorithmic optimization, and provide superior client experiences with custom dashboards and real-time insights.

The initial investment in API integration—whether building internally or partnering with developers—pays dividends through improved efficiency, scalability, and client retention. Start with the fundamentals (authentication, basic reporting, simple bid automation), then progressively add sophisticated features as your technical capabilities grow.

The agencies that will dominate Amazon advertising in the coming years won't be those with the most people—they'll be those with the best technology.

About the Author: This guide was created by the development team at Coretech3. We've built advertising automation platforms for agencies managing $10M+ in annual Amazon ad spend. Contact us to discuss building your custom advertising automation solution.