Cara Integrasi Amazon SP API: Tutorial Langkah demi Langkah

https://sellingpartnerapi-na.amazon.com (Amerika Utara)

https://sellingpartnerapi-eu.amazon.com (Eropa)

https://sellingpartnerapi-fe.amazon.com (Asia-Pasifik)

# .env

AMAZON_APPLICATION_ID="amzn1.application.xxxxx"

AMAZON_CLIENT_ID="amzn1.account.xxxxx"

AMAZON_CLIENT_SECRET="your_client_secret_here"

AMAZON_SELLER_ID="your_seller_id_here"

AWS_ACCESS_KEY_ID="your_aws_access_key"

AWS_SECRET_ACCESS_KEY="your_aws_secret_key"

AWS_REGION="us-east-1"

{

  "Version": "2012-10-17",

  "Statement": [

    {

      "Effect": "Allow",

      "Action": [

        "execute-api:Invoke"

      ],

      "Resource": [

        "arn:aws:execute-api:*:*:*/prod/*/sellingpartnerapi/*"

      ]

    }

  ]

}

const generateAuthUrl = (clientId, redirectUri, state) => {

  const baseUrl = 'https://www.amazon.com/sp/apps/oauth/authorize';

  const params = new URLSearchParams({

    application_id: process.env.AMAZON_APPLICATION_ID,

    client_id: clientId,

    redirect_uri: redirectUri,

    state: state,

    scope: 'sellingpartnerapi::notifications'

  });



  return `${baseUrl}?${params.toString()}`;

};



// Penggunaan

const authUrl = generateAuthUrl(

  process.env.AMAZON_CLIENT_ID,

  'https://your-app.com/callback',

  crypto.randomBytes(16).toString('hex')

);



console.log(`Redirect user to: ${authUrl}`);

const exchangeCodeForLwaToken = async (code, redirectUri) => {

  const response = await fetch('https://api.amazon.com/auth/o2/token', {

    method: 'POST',

    headers: {

      'Accept': 'application/json',

      'Content-Type': 'application/x-www-form-urlencoded'

    },

    body: new URLSearchParams({

      grant_type: 'authorization_code',

      client_id: process.env.AMAZON_CLIENT_ID,

      client_secret: process.env.AMAZON_CLIENT_SECRET,

      redirect_uri: redirectUri,

      code: code

    })

  });



  if (!response.ok) {

    const error = await response.json();

    throw new Error(`LWA Token Error: ${error.error_description}`);

  }



  const data = await response.json();



  return {

    access_token: data.access_token,

    refresh_token: data.refresh_token,

    expires_in: data.expires_in,

    token_type: data.token_type

  };

};



// Route callback

app.get('/callback', async (req, res) => {

  const { spapi_oauth_code, state } = req.query;

  if (state !== req.session.oauthState) {

    return res.status(400).send('Invalid state parameter');

  }

  try {

    const tokens = await exchangeCodeForLwaToken(spapi_oauth_code, 'https://your-app.com/callback');

    await db.sellers.update(req.session.sellerId, {

      amazon_lwa_access_token: tokens.access_token,

      amazon_lwa_refresh_token: tokens.refresh_token,

      amazon_token_expires: Date.now() + (tokens.expires_in * 1000)

    });

    res.redirect('/dashboard');

  } catch (error) {

    console.error('Token exchange failed:', error);

    res.status(500).send('Authentication failed');

  }

});

const refreshLwaToken = async (refreshToken) => {

  const response = await fetch('https://api.amazon.com/auth/o2/token', {

    method: 'POST',

    headers: {

      'Accept': 'application/json',

      'Content-Type': 'application/x-www-form-urlencoded'

    },

    body: new URLSearchParams({

      grant_type: 'refresh_token',

      client_id: process.env.AMAZON_CLIENT_ID,

      client_secret: process.env.AMAZON_CLIENT_SECRET,

      refresh_token: refreshToken

    })

  });



  const data = await response.json();



  return {

    access_token: data.access_token,

    refresh_token: data.refresh_token,

    expires_in: data.expires_in

  };

};



const ensureValidToken = async (sellerId) => {

  const seller = await db.sellers.findById(sellerId);

  if (seller.amazon_token_expires < Date.now() + 300000) {

    const newTokens = await refreshLwaToken(seller.amazon_lwa_refresh_token);

    await db.sellers.update(sellerId, {

      amazon_lwa_access_token: newTokens.access_token,

      amazon_lwa_refresh_token: newTokens.refresh_token,

      amazon_token_expires: Date.now() + (newTokens.expires_in * 1000)

    });

    return newTokens.access_token;

  }

  return seller.amazon_lwa_access_token;

};

const crypto = require('crypto');



class SigV4Signer {

  constructor(accessKey, secretKey, region, service = 'execute-api') {

    this.accessKey = accessKey;

    this.secretKey = secretKey;

    this.region = region;

    this.service = service;

  }



  sign(method, url, body = '', headers = {}) {

    const parsedUrl = new URL(url);

    const now = new Date();

    const amzDate = now.toISOString().replace(/[:-]|\.\d{3}/g, '');

    const dateStamp = amzDate.slice(0, 8);



    headers['host'] = parsedUrl.host;

    headers['x-amz-date'] = amzDate;

    headers['x-amz-access-token'] = this.accessToken;

    headers['content-type'] = 'application/json';



    const canonicalHeaders = Object.entries(headers)

      .sort(([a], [b]) => a.localeCompare(b))

      .map(([k, v]) => `${k.toLowerCase()}:${v.trim()}`)

      .join('\n');



    const signedHeaders = Object.keys(headers)

      .sort()

      .map(k => k.toLowerCase())

      .join(';');



    const payloadHash = crypto.createHash('sha256').update(body).digest('hex');



    const canonicalRequest = [

      method.toUpperCase(),

      parsedUrl.pathname,

      parsedUrl.search.slice(1),

      canonicalHeaders,

      '',

      signedHeaders,

      payloadHash

    ].join('\n');



    const algorithm = 'AWS4-HMAC-SHA256';

    const credentialScope = `${dateStamp}/${this.region}/${this.service}/aws4_request`;



    const stringToSign = [

      algorithm,

      amzDate,

      credentialScope,

      crypto.createHash('sha256').update(canonicalRequest).digest('hex')

    ].join('\n');



    const kDate = this.hmac(`AWS4${this.secretKey}`, dateStamp);

    const kRegion = this.hmac(kDate, this.region);

    const kService = this.hmac(kRegion, this.service);

    const kSigning = this.hmac(kService, 'aws4_request');

    const signature = this.hmac(kSigning, stringToSign, 'hex');



    const authorization = `${algorithm} Credential=${this.accessKey}/${credentialScope}, SignedHeaders=${signedHeaders}, Signature=${signature}`;



    return {

      headers: {

        ...headers,

        'Authorization': authorization

      },

      canonicalRequest,

      stringToSign,

      signature

    };

  }



  hmac(key, data, encoding = 'buffer') {

    return crypto.createHmac('sha256', key).update(data).digest(encoding);

  }

}



// Penggunaan

const signer = new SigV4Signer(

  process.env.AWS_ACCESS_KEY_ID,

  process.env.AWS_SECRET_ACCESS_KEY,

  'us-east-1'

);



const signedRequest = signer.sign('GET', 'https://sellingpartnerapi-na.amazon.com/orders/v0/orders', '', {

  'x-amz-access-token': accessToken

});

const { SignatureV4 } = require('@aws-sdk/signature-v4');

const { Sha256 } = require('@aws-crypto/sha256-js');



const signer = new SignatureV4({

  credentials: {

    accessKeyId: process.env.AWS_ACCESS_KEY_ID,

    secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY

  },

  region: 'us-east-1',

  service: 'execute-api',

  sha256: Sha256

});



const makeSpApiRequest = async (method, endpoint, accessToken, body = null) => {

  const url = new URL(endpoint);



  const headers = {

    'host': url.host,

    'content-type': 'application/json',

    'x-amz-access-token': accessToken,

    'x-amz-date': new Date().toISOString().replace(/[:-]|\.\d{3}/g, '')

  };



  const signedRequest = await signer.sign({

    method,

    hostname: url.hostname,

    path: url.pathname,

    query: Object.fromEntries(url.searchParams),

    headers,

    body: body ? JSON.stringify(body) : undefined

  });



  const response = await fetch(endpoint, {

    method,

    headers: signedRequest.headers,

    body: signedRequest.body

  });



  if (!response.ok) {

    const error = await response.json();

    throw new Error(`SP-API Error: ${error.errors?.[0]?.message || response.statusText}`);

  }



  return response.json();

};

const getOrders = async (accessToken, options = {}) => {

  const params = new URLSearchParams({

    createdAfter: options.createdAfter,

    createdBefore: options.createdBefore,

    orderStatuses: options.orderStatuses?.join(',') || '',

    marketplaceIds: options.marketplaceIds?.join(',') || ['ATVPDKIKX0DER'],

    maxResultsPerPage: options.maxResultsPerPage || 100

  });



  for (const [key, value] of params.entries()) {

    if (!value) params.delete(key);

  }



  const endpoint = `https://sellingpartnerapi-na.amazon.com/orders/v0/orders?${params.toString()}`;

  return makeSpApiRequest('GET', endpoint, accessToken);

};



// Contoh penggunaan

const orders = await getOrders(accessToken, {

  createdAfter: new Date(Date.now() - 24 * 60 * 60 * 1000).toISOString(),

  orderStatuses: ['Unshipped', 'PartiallyShipped'],

  marketplaceIds: ['ATVPDKIKX0DER']

});

const getOrderItems = async (accessToken, orderId) => {

  const endpoint = `https://sellingpartnerapi-na.amazon.com/orders/v0/orders/${orderId}/orderItems`;

  return makeSpApiRequest('GET', endpoint, accessToken);

};



// Usage

const orderItems = await getOrderItems(accessToken, '112-1234567-1234567');

const confirmShipment = async (accessToken, orderId, shipmentData) => {

  const endpoint = `https://sellingpartnerapi-na.amazon.com/orders/v0/orders/${orderId}/shipmentConfirmation`;



  const payload = {

    packageDetails: {

      packageReferenceId: shipmentData.packageReferenceId || '1',

      carrier_code: shipmentData.carrierCode,

      tracking_number: shipmentData.trackingNumber,

      ship_date: shipmentData.shipDate || new Date().toISOString(),

      items: shipmentData.items.map(item => ({

        order_item_id: item.orderItemId,

        quantity: item.quantity

      }))

    }

  };



  return makeSpApiRequest('POST', endpoint, accessToken, payload);

};



// Usage

await confirmShipment(accessToken, '112-1234567-1234567', {

  carrierCode: 'USPS',

  trackingNumber: '9400111899223456789012',

  items: [

    { orderItemId: '12345678901234', quantity: 2 }

  ]

});

const getInventorySummaries = async (accessToken, options = {}) => {

  const params = new URLSearchParams({

    granularityType: options.granularityType || 'Marketplace',

    granularityId: options.granularityId || 'ATVPDKIKX0DER',

    startDateTime: options.startDateTime || '',

    sellerSkus: options.sellerSkus?.join(',') || ''

  });



  const endpoint = `https://sellingpartnerapi-na.amazon.com/fba/inventory/v1/summaries?${params.toString()}`;

  return makeSpApiRequest('GET', endpoint, accessToken);

};



// Usage

const inventory = await getInventorySummaries(accessToken, {

  granularityId: 'ATVPDKIKX0DER',

  sellerSkus: ['MYSKU-001', 'MYSKU-002']

});

const getListings = async (accessToken, options = {}) => {

  const params = new URLSearchParams({

    marketplaceIds: options.marketplaceIds?.join(',') || ['ATVPDKIKX0DER'],

    itemTypes: options.itemTypes?.join(',') || ['ASIN', 'SKU'],

    identifiers: options.identifiers?.join(',') || '',

    issuesLocale: options.locale || 'en_US'

  });



  const endpoint = `https://sellingpartnerapi-na.amazon.com/listings/2021-08-01/items?${params.toString()}`;

  return makeSpApiRequest('GET', endpoint, accessToken);

};



// Usage

const listings = await getListings(accessToken, {

  identifiers: ['B08N5WRWNW', 'B09JQKJXYZ'],

  itemTypes: ['ASIN']

});

const submitListingUpdate = async (accessToken, listingData) => {

  const endpoint = 'https://sellingpartnerapi-na.amazon.com/listings/2021-08-01/items/MYSKU-001';



  const payload = {

    productType: 'LUGGAGE',

    patches: [

      {

        op: 'replace',

        path: '/attributes/title',

        value: 'Updated Wireless Bluetooth Headphones - Premium Sound'

      },

      {

        op: 'replace',

        path: '/salesPrice',

        value: {

          currencyCode: 'USD',

          amount: '79.99'

        }

      }

    ]

  };



  return makeSpApiRequest('PATCH', endpoint, accessToken, payload);

};

const createReport = async (accessToken, reportType, dateRange) => {

  const endpoint = 'https://sellingpartnerapi-na.amazon.com/reports/2021-06-30/reports';



  const payload = {

    reportType: reportType,

    marketplaceIds: dateRange.marketplaceIds || ['ATVPDKIKX0DER'],

    dataStartTime: dateRange.startTime?.toISOString(),

    dataEndTime: dateRange.endTime?.toISOString()

  };



  return makeSpApiRequest('POST', endpoint, accessToken, payload);

};



const getReportDocument = async (accessToken, reportId) => {

  const endpoint = `https://sellingpartnerapi-na.amazon.com/reports/2021-06-30/reports/${reportId}/document`;

  return makeSpApiRequest('GET', endpoint, accessToken);

};

const createSubscription = async (accessToken, subscriptionData) => {

  const endpoint = 'https://sellingpartnerapi-na.amazon.com/notifications/v1/subscriptions';



  const payload = {

    payload: {

      destination: {

        resource: subscriptionData.destinationArn,

        name: subscriptionData.name

      },

      modelVersion: '1.0',

      eventFilter: {

        eventCode: subscriptionData.eventCode,

        marketplaceIds: subscriptionData.marketplaceIds

      }

    }

  };



  return makeSpApiRequest('POST', endpoint, accessToken, payload);

};



// Usage

await createSubscription(accessToken, {

  destinationArn: 'arn:aws:sns:us-east-1:123456789012:sp-api-notifications',

  name: 'OrderStatusNotifications',

  eventCode: 'OrderStatusChange',

  marketplaceIds: ['ATVPDKIKX0DER']

});

class RateLimitedQueue {

  constructor(rateLimit, burstLimit = null) {

    this.rateLimit = rateLimit;

    this.burstLimit = burstLimit || rateLimit * 2;

    this.tokens = this.burstLimit;

    this.lastRefill = Date.now();

    this.queue = [];

    this.processing = false;

  }



  async add(requestFn) {

    return new Promise((resolve, reject) => {

      this.queue.push({ requestFn, resolve, reject });

      this.process();

    });

  }



  refillTokens() {

    const now = Date.now();

    const elapsed = (now - this.lastRefill) / 1000;

    const tokensToAdd = elapsed * this.rateLimit;



    this.tokens = Math.min(this.burstLimit, this.tokens + tokensToAdd);

    this.lastRefill = now;

  }



  async process() {

    if (this.processing || this.queue.length === 0) return;



    this.processing = true;



    while (this.queue.length > 0) {

      this.refillTokens();



      if (this.tokens < 1) {

        const waitTime = (1 / this.rateLimit) * 1000;

        await new Promise(r => setTimeout(r, waitTime));

        continue;

      }



      this.tokens--;

      const { requestFn, resolve, reject } = this.queue.shift();



      try {

        const result = await requestFn();

        resolve(result);

      } catch (error) {

        reject(error);

      }

    }



    this.processing = false;

  }

}



// Usage

const ordersQueue = new RateLimitedQueue(10, 20);

const orders = await ordersQueue.add(() => getOrders(accessToken, options));

// Apidog pre-request script for SigV4 signing

const crypto = require('crypto');



const accessKey = apidog.variables.get('aws_access_key');

const secretKey = apidog.variables.get('aws_secret_key');

const accessToken = apidog.variables.get('lwa_access_token');

const region = apidog.variables.get('region');



const method = apidog.request.method;

const url = new URL(apidog.request.url);

const body = apidog.request.body;



// Generate SigV4 signature

const signer = new SigV4Signer(accessKey, secretKey, region);

const signedHeaders = signer.sign(method, url.href, body, {

  'x-amz-access-token': accessToken

});



// Set headers for the request

apidog.request.headers = {

  ...apidog.request.headers,

  ...signedHeaders.headers

};