# @amazonpay/amazon-pay-api-sdk-nodejs 中文文档

规范地址：https://npmcn.com/package/%40amazonpay/amazon-pay-api-sdk-nodejs/

版本：2\.3\.6
npm 元数据更新时间：2026-10-02T09:01:49.370Z
中文译文更新时间：2026-11-06T00:01:04.441Z
软件包许可：Apache-2\.0

本文由上游 README 翻译，可能存在偏差，请结合原文核对 API、命令与配置。版权与许可归原作者所有。

原始 npm 页面：https://www.npmjs.com/package/%40amazonpay/amazon-pay-api-sdk-nodejs
原文对照：https://npmcn.com/package/%40amazonpay/amazon-pay-api-sdk-nodejs/?lang=original

## 关键信息（来自 npm 元数据）

- 包体积（解压后）：183 kB，18 个文件
- 模块格式：CommonJS
- TypeScript 类型：未声明
- 运行依赖：1 个
- 首次发布：2020-05-07T19:26:13.971Z
- 最新版本发布：2026-10-02T09:01:49.224Z
- 近 30 天下载量：36467（2026-10-06 至 2026-11-04，npm 官方下载统计）
- 已发布版本数：16（近 12 个月 1 个）

## 中文简介

亚马逊支付支票 V2 集成

## 安装

```sh
npm install @amazonpay/amazon-pay-api-sdk-nodejs
```

也可以使用：`pnpm add @amazonpay/amazon-pay-api-sdk-nodejs`、`yarn add @amazonpay/amazon-pay-api-sdk-nodejs`、`bun add @amazonpay/amazon-pay-api-sdk-nodejs`

## README

# 亚马逊付费API SDK(节点.js)

亚马逊支付检查 v2 集成

请注意, Amazon Pay Pay API SDK只能用于API呼叫pay-api.amazon.com|eu|jp endpoint.

## 所需资源

-   亚马逊支付账户:为了注册亚马逊支付,请到 [https://pay.amazon.com (中文(简体) )](https://pay.amazon.com/),通过选择右上角的旗帜图标来选择区域,然后点击"Register".
-   节点10.0或以上

## 安装

要直接使用此模块, 请作为依赖性安装 :

```
npm i @amazonpay/amazon-pay-api-sdk-nodejs
```

## 生成偏差键

多个API需要一个独特的 `x-amz-pay-idempotency-key` 头,一些有效载荷需要独特的参考ID. 此 README 中的代码样本以一个 `uuidv4()` 函数。 SDK 不依赖于任何 UUID 库, 因此选择以下一种方法定义 `uuidv4`数字 :

-   选项1 - 节点内置 `crypto` 模块(要求节点14.17或更高,不额外安装)。 代码样本使用此选项:

```js
    const { randomUUID: uuidv4 } = require('crypto');
```

-   备选案文2: [乌伊德](https://www.npmjs.com/package/uuid) 软件包。 安装它 `npm i uuid` 并检查它支持的节点版本的文档 :

```js
    const { v4: uuidv4 } = require('uuid');
```

两个选项都产生一个随机版本4 UUID,所以其余的样本代码工作不变.

## 公用钥匙和私人钥匙

MWS访问密钥,MWS秘密密钥,以及MWS前作的MWS集成授权令牌,都无法使用此SDK.

您需要生成自己的公用/ 私用密钥对, 才能使用 SDK 调用 API .

在Windows 10中,可以用 ssh-keygen 命令完成此任务 :

```
ssh-keygen -t rsa -b 2048 -f private.pem
ssh-keygen -f private.pem -e -m PKCS8 > public.pub
```

在 Linux 或 macOS 中,可以使用 Opensl 命令进行此操作 :

```
openssl genrsa -out private.pem 2048
openssl rsa -in private.pem -pubout > public.pub
```

上面的第一个命令生成一个私钥,而第二行则使用私钥生成一个公钥.

将密钥与您的账户关联, 请遵从这里的指示 [获取您的公钥标识](https://developer.amazon.com/docs/amazon-pay-checkout/get-set-up-for-integration.html#5-get-your-public-key-id)。 。 。 .

## 配置

```js
    const fs = require('fs');
    const config = {
        'publicKeyId': 'ABC123DEF456XYZ',                 // RSA Public Key ID (this is not the Merchant or Seller ID)
        'privateKey': fs.readFileSync('tst/private.pem'), // Path to RSA Private Key (or a string representation)
        'region': 'us',                                   // Must be one of: 'us', 'eu', 'jp' 
        'sandbox': true,                                   // true (Sandbox) or false (Production) boolean
        'algorithm': 'AMZN-PAY-RSASSA-PSS-V2'             // Amazon Signing Algorithm, Optional: uses AMZN-PAY-RSASSA-PSS if not specified
    };
```

如果您在 Seller Central 中创建了环境特定密钥(即 Public Key Starts with LIVE 或 SANDBOX),那么使用这些 PublicKeyId & PrivateKey. 在这种情况下,不需要将 Sandbox 参数传递给 ApiConfigure.

```js
    const fs = require('fs');
    const config = {
        'publicKeyId': 'PUBLIC_KEY_ID',                   // LIVE-XXXXX or SANDBOX-XXXXX
        'privateKey': fs.readFileSync('tst/private.pem'), // Path to RSA Private Key (or a string representation)
        'region': 'us',                                   // Must be one of: 'us', 'eu', 'jp' 
        'algorithm': 'AMZN-PAY-RSASSA-PSS-V2'             // Amazon Signing Algorithm, Optional: uses AMZN-PAY-RSASSA-PSS if not specified
    };
```

# 版本

Pay-api.amazon.com|eu|jp端点使用版本来允许未来更新. 此SDK的主要版本会与API版本的端点保持一致.

如果您已经下载了这个SDK的 2.x.y 版本,下面的例子中的版本将是"v2".

# 方便函数(概览)

利用内置便利功能,方便API调用. 向下滚动以查看示例代码片段 .

在使用方便功能时,请求的有效载荷将使用提供的私人密钥签名,并向正确的区域端点发出HTTPS请求. 如果出现请求节奏, HTTPS 将尝试三次

## Alexa 发送跟踪器 API

请注意,你的商户必须白名单才能使用 [发送跟踪器 API](https://developer.amazon.com/docs/amazon-pay-onetime/delivery-order-notifications.html)。 。 。 .

-   **交付 跟踪器**(载荷,头数=无) + POST 改为 `${version}/deliveryTrackers`

## 授权托肯斯 API

请注意,您的解决方案提供者账户必须与商家账户有先前存在的关系(有效且活跃的MWS授权令牌),以便使用此功能.

-   **获得认证**(mwsAuthToken, 商号 Id, 头号=无效) – 进入 `${version}/authorizationTokens/${mwsAuthToken}?merchantId=${merchantId}`

## 亚马逊检查 v2 API

[退出 v2 整合指南](https://developer.amazon.com/docs/amazon-pay-api-v2/introduction.html)

信头字段对于下面的创建/POST调用不是可选的,因为它至少需要x-amz-pay-idemicpowerency-keey 报头:

```js
    const headers = {
        'x-amz-pay-idempotency-key': uuidv4().toString().replace(/-/g, '')
    };
```

### Amazon 检查 v2 买家 API

-   **获取Buyer**(购买者Token, $headers = null) – 进入 `${version}/buyer/{$buyerToken}`

### 退出 v2 退出会话 API

-   **创建检查会议**(载荷,标题) + POST 至 `${version}/checkoutSessions`
-   **获取检查会议**(离职会议) Id,页眉=无) 去 `${version}/checkoutSessions/${checkoutSessionId}`
-   **更新检查会议**(离职会议) Id, 有效载荷, 头数 = 无效 + PATCH to `${version}/checkoutSessions/${checkoutSessionId}`
-   **完成检查会议**(离职会议) Id, 有效载荷, 头数 = 无效 = POST `${version}/checkoutSessions/${checkoutSessionId}/complete`

### 检查 v2 充电 Permission API

-   **获取管理员许可**(充电) Id,页眉=无) 去 `${version}/chargePermissions/${chargePermissionId}`
-   **更新主管**(充电) Id, 有效载荷, 头数 = 无效 + PATCH to `${version}/chargePermissions/${chargePermissionId}`
-   **关闭管理员**(充电) Id, 有效载荷, 头数 = 无效) − DELETE `${version}/chargePermissions/${chargePermissionId}/close`

### 检查 v2 充电 API

-   **创建管理员**(载荷,标题) + POST 至 `${version}/charges`
-   **获取管理员**(充电,信头=无效) + 进入 `${version}/charges/${chargeId}`
-   **更新管理员** (充电器、有效载荷、信头=无) `${version}/charges/${chargeId}`
-   **抓取管理员**(充电器、有效载荷、信头) `${version}/charges/${chargeId}/capture`
-   **取消管理员**(充电器、有效载荷、信头=无) + DELETE `${version}/charges/${chargeId}/cancel`

### 退出 v2 退款API

-   **创建退款**(载荷,标题) + POST 至 `${version}/refunds`
-   **获得退款**(退款,信头=无效) + 进入 `${version}/refunds/${refundId}`

## 内部 API

请联系您的 Amazon 薪资账户管理器, 在使用 In- Store API 在生产环境中的呼叫前获取 In- Store 整合指南 副本 .

-   **正在购买MerchantScan**(载荷,头数=无) + POST 改为 `${version}/in-store/merchantScan`
-   **仓库管理员**(载荷,头数=无) + POST 改为 `${version}/in-store/charge`
-   **退款**(载荷,头数=无) + POST 改为 `${version}/in-store/refund`

### 亚马逊检查 v2 SPC

-   **最终确定离职会议**(离职会议) Id, 有效载荷, 头数 = 无效 = POST `${version}/checkoutSessions/${checkoutSessionId}/finalize`

### Amazon 退市 v2 商机上载和账户管理 API 授权商机

-   **注册 AmazonPay 账户**(载荷,头数=无) + POST 改为 `${version}/merchantAccounts`
-   **更新AmazonPay账户**(机械会计,有效载荷,头条=无) + PATCH to `${version}/merchantAccounts/${merchantAccountId}`
-   **删除AmazonPay账户**(商业会计,标题=无) + DELETE 改为 `${version}/merchantAccounts/${merchantAccountId}`

### Amazon 检查 v2 争议 API

-   **创建争议**(载荷、载体) `${version}/disputes`
-   **获得争议**(争议者,标题=无效) – 进入 `${version}/disputes/${disputeId}`
-   **更新争议**(争议、负载、头部=无效) `${version}/disputes/${disputeId}`
-   **争议争议**(争端、有效载荷、头等值为无效) `${version}/disputes/${disputeId}/contest`

### Amazon 检查 v2 文件 API

-   **上传文件**(一美元,发薪人) `${version}/files`

### Amazon 检查 v2 代理解决方案供应商的登入和账户管理 API

-   **创建默尚特账户**(负载,页眉=无) `${version}/merchantAccounts`
-   **更新Merchant账户**(机械会计,有效载荷,头) `${version}/merchantAccounts/${merchantAccountId}`
-   **商业帐户索赔**(机械会计、有效载荷、头) `${version}/merchantAccounts/${merchantAccountId}/claim`

### Amazon 检查 v2 存储管理 API 授权解决方案提供商

-   **创建Store**(机械会计、有效载荷、信头) `${version}/merchantAccounts/${merchantAccountId}/stores`
-   **更新 Store**(机械会计,存储仪,有效载荷,头) + PATCH to `${version}/merchantAccounts/${merchantAccountId}/stores/${storeId}`

# 使用方便函数

需要四个快速步骤来发出API呼吁:

步骤1. 构建客户端(使用先前定义的配置对象).

```js
    const Client = require('@amazonpay/amazon-pay-api-sdk-nodejs');

    const testPayClient = new Client.AmazonPayClient(config);
    // -or-
    const testPayClient = new Client.WebStoreClient(config);
    // -or-
    const testPayClient = new Client.InStoreClient(config);
```

第2步 生成有效载荷.

```js
    const payload = {
        scanData: 'UKhrmatMeKdlfY6b',
        scanReferenceId: uuidv4().toString().replace(/-/g, ''),
        merchantCOE: 'US',
        ledgerCurrency: 'USD',
        chargeTotal: {
            currencyCode: 'USD',
            amount: '2.00'
        },
        storeLocation: {
            countryCode: 'US'
        },
        metadata: {
            merchantNote: 'Merchant Name',
            customInformation: 'in-store Software Purchase',
            communicationContext: {
                merchantStoreName: 'Store Name',
                merchantOrderId: '789123'
            }
        }
    };
```

第三步 执行呼叫.

```js
     const response = testPayClient.merchantScan(payload);
```

如果您是解决方案提供方, 需要代表不同的商号进行 API 呼叫, 您需要将额外的认证符号参数传递到 API 呼叫中 .

```js
    const testHeaders = {
        'x-amz-pay-authtoken': 'other_merchant_super_secret_token'
    };
    const response = testpayClient.merchantScan(payload, testHeaders);
```

# 方便函数代码样本

## Alexa 发送通知

```js
    const fs = require('fs');
    const Client = require('@amazonpay/amazon-pay-api-sdk-nodejs');

    const config = {
        publicKeyId: 'ABC123DEF456XYZ',
        privateKey: fs.readFileSync('tst/private.pem'),
        region: 'us',
        sandbox: true,
        algorithm: 'AMZN-PAY-RSASSA-PSS-V2' // Amazon Signing Algorithm, Optional: uses AMZN-PAY-RSASSA-PSS if not specified 
    };

    const payload = {
        amazonOrderReferenceId: 'P00-0000000-0000000',
        deliveryDetails: [{
            trackingNumber: '1Z999AA10123456789',
            carrierCode: 'UPS'
        }]
    };

    const testPayClient = new Client.AmazonPayClient(config);
    testPayClient.deliveryTrackers(payload).then((apiResponse) => {
        const response = apiResponse;
    });
```

## 退出 v2 - 创建退出会话

```js
    const fs = require('fs');
    const { randomUUID: uuidv4 } = require('crypto');
    const Client = require('@amazonpay/amazon-pay-api-sdk-nodejs');

    const config = {
        publicKeyId: 'YOUR_PUBLIC_KEY_ID',
        privateKey: fs.readFileSync('tst/private.pem'),
        region: 'YOUR_REGION_CODE',
        sandbox: true,
        algorithm: 'AMZN-PAY-RSASSA-PSS-V2' // Amazon Signing Algorithm, Optional: uses AMZN-PAY-RSASSA-PSS if not specified
    };

    const payload = {
        webCheckoutDetails: {
            checkoutReviewReturnUrl: 'https://localhost/store/checkoutReview',
            checkoutResultReturnUrl: 'https://localhost/store/checkoutReturn'
        },
        storeId: 'amzn1.application-oa2-client.5cc4962582fd4025a2962fc5350582d9' // Enter Client ID
    };
    const headers = {
        'x-amz-pay-idempotency-key': uuidv4().toString().replace(/-/g, '')
    };

    const testPayClient = new Client.WebStoreClient(config);
    const response = testPayClient.createCheckoutSession(payload, headers);

    response.then(function (result) {
        console.log(result.data);
    }).catch(err => {
        console.log(err);
    });
```

## 退出 v2 - 获得退出会话

```js
    const fs = require('fs');
    const Client = require('@amazonpay/amazon-pay-api-sdk-nodejs');

    const config = {
        publicKeyId: 'YOUR_PUBLIC_KEY_ID',
        privateKey: fs.readFileSync('tst/private.pem'),
        region: 'YOUR_REGION_CODE',
        sandbox: true,
        algorithm: 'AMZN-PAY-RSASSA-PSS-V2' // Amazon Signing Algorithm, Optional: uses AMZN-PAY-RSASSA-PSS if not specified
    };

    const checkoutSessionId = "00000000-0000-0000-0000-000000000000";
    const testPayClient = new Client.WebStoreClient(config);
    const response = testPayClient.getCheckoutSession(checkoutSessionId);

    response.then(function (result) {
        console.log(result.data);
    }).catch(err => {
        console.log(err);
    });
```

## 退出 v2 - 更新退出会话

```js
    const fs = require('fs');
    const Client = require('@amazonpay/amazon-pay-api-sdk-nodejs');

    const config = {
        publicKeyId: 'YOUR_PUBLIC_KEY_ID',
        privateKey: fs.readFileSync('tst/private.pem'),
        region: 'YOUR_REGION_CODE',
        sandbox: true,
        algorithm: 'AMZN-PAY-RSASSA-PSS-V2' // Amazon Signing Algorithm, Optional: uses AMZN-PAY-RSASSA-PSS if not specified
    };

    const payload = {
        webCheckoutDetails: {
            checkoutResultReturnUrl: 'https://localhost/store/checkoutReturn'
        },
        paymentDetails: {
            paymentIntent: 'Confirm',
            canHandlePendingAuthorization: false,
            chargeAmount: {
                amount: 50,
                currencyCode: 'USD'
            }
        },
        merchantMetadata: {
            merchantReferenceId: uuidv4().toString().replace(/-/g, ''),
            merchantStoreName: 'AmazonTestStoreFront',
            noteToBuyer: 'merchantNoteForBuyer',
            customInformation: ''
        }
    };

    const checkoutSessionId = "00000000-0000-0000-0000-000000000000";
    const testPayClient = new Client.WebStoreClient(config);
    const response = testPayClient.updateCheckoutSession(checkoutSessionId, payload);

    response.then(function (result) {
        console.log(result.data);
    }).catch(err => {
        console.log(err);
    });
```

## 退出 v2 - 完整的退出会话

```js
    const fs = require('fs');
    const Client = require('@amazonpay/amazon-pay-api-sdk-nodejs');

    const config = {
        publicKeyId: 'YOUR_PUBLIC_KEY_ID',
        privateKey: fs.readFileSync('tst/private.pem'),
        region: 'YOUR_REGION_CODE',
        sandbox: true,
        algorithm: 'AMZN-PAY-RSASSA-PSS-V2' // Amazon Signing Algorithm, Optional: uses AMZN-PAY-RSASSA-PSS if not specified
    };

    const payload = {
        "chargeAmount": {
            "amount": "1.23",
            "currencyCode": "USD"
        }
    };

    const checkoutSessionId = "00000000-0000-0000-0000-000000000000";
    const testPayClient = new Client.WebStoreClient(config);
    const response = testPayClient.completeCheckoutSession(checkoutSessionId, payload);

    response.then(function (result) {
        console.log(result.data);
    }).catch(err => {
        console.log(err);
    });
```

## 退出 v2 - 获取充电权限 API

```js
    const fs = require('fs');
    const Client = require('@amazonpay/amazon-pay-api-sdk-nodejs');

    const config = {
        publicKeyId: 'YOUR_PUBLIC_KEY_ID',
        privateKey: fs.readFileSync('tst/private.pem'),
        region: 'YOUR_REGION_CODE',
        sandbox: true,
        algorithm: 'AMZN-PAY-RSASSA-PSS-V2' // Amazon Signing Algorithm, Optional: uses AMZN-PAY-RSASSA-PSS if not specified
    };

    const chargePermissionId = "S01-0000000-0000000";
    const testPayClient = new Client.WebStoreClient(config);
    const response = testPayClient.getChargePermission(chargePermissionId);
    
    response.then(function (result) {
        console.log(result.data);
    }).catch(err => {
        console.log(err);
    });
```

## 退出 v2 - 更新充电权限 API

```js
    const fs = require('fs');
    const Client = require('@amazonpay/amazon-pay-api-sdk-nodejs');

    const config = {
        publicKeyId: 'YOUR_PUBLIC_KEY_ID',
        privateKey: fs.readFileSync('tst/private.pem'),
        region: 'YOUR_REGION_CODE',
        sandbox: true,
        algorithm: 'AMZN-PAY-RSASSA-PSS-V2' // Amazon Signing Algorithm, Optional: uses AMZN-PAY-RSASSA-PSS if not specified
    };

    const chargePermissionId = "S01-0000000-0000000";
    const payload = {
        merchantMetadata: {
            merchantReferenceId: "32-41-323141-32",
            merchantStoreName: "AmazonTestStoreFront",
            noteToBuyer: "Some Note to buyer",
            customInformation: ""
        }
    };

    const testPayClient = new Client.WebStoreClient(config);
    const response = testPayClient.updateChargePermission(chargePermissionId, payload);
    
    response.then(function (result) {
        console.log(result.data);
    }).catch(err => {
        console.log(err);
    });
```

## 退出 v2 - 关闭充电权限 API

```js
    const fs = require('fs');
    const Client = require('@amazonpay/amazon-pay-api-sdk-nodejs');

    const config = {
        publicKeyId: 'YOUR_PUBLIC_KEY_ID',
        privateKey: fs.readFileSync('tst/private.pem'),
        region: 'YOUR_REGION_CODE',
        sandbox: true,
        algorithm: 'AMZN-PAY-RSASSA-PSS-V2' // Amazon Signing Algorithm, Optional: uses AMZN-PAY-RSASSA-PSS if not specified
    };

    const chargePermissionId = "S01-0000000-0000000";
    const payload = {
        closureReason: "No more charges required",
        cancelPendingCharges: false
    };

    const testPayClient = new Client.WebStoreClient(config);
    const response = testPayClient.closeChargePermission(chargePermissionId, payload);
    
    response.then(function (result) {
        console.log(result.data);
    }).catch(err => {
        console.log(err);
    });
```

## 退出 v2 - 创建充电 API

```js
    const fs = require('fs');
    const { randomUUID: uuidv4 } = require('crypto');
    const Client = require('@amazonpay/amazon-pay-api-sdk-nodejs');

    const config = {
        publicKeyId: 'YOUR_PUBLIC_KEY_ID',
        privateKey: fs.readFileSync('tst/private.pem'),
        region: 'YOUR_REGION_CODE',
        sandbox: true,
        algorithm: 'AMZN-PAY-RSASSA-PSS-V2' // Amazon Signing Algorithm, Optional: uses AMZN-PAY-RSASSA-PSS if not specified
    };

    const payload = {
        chargePermissionId: "S01-0000000-0000000",
        chargeAmount: {
            amount: "14.00",
            currencyCode: "USD"
        },
        captureNow: true,
        softDescriptor: "Descriptor",
        canHandlePendingAuthorization: false
    };

    const headers = {
        'x-amz-pay-idempotency-key': uuidv4().toString().replace(/-/g, '')
    };

    const testPayClient = new Client.WebStoreClient(config);
    const response = testPayClient.createCharge(payload, headers);
    
    response.then(function (result) {
        console.log(result.data);
    }).catch(err => {
        console.log(err);
    });
```

## 退出 v2 - 获取充电 API

```js
    const fs = require('fs');
    const Client = require('@amazonpay/amazon-pay-api-sdk-nodejs');

    const config = {
        publicKeyId: 'YOUR_PUBLIC_KEY_ID',
        privateKey: fs.readFileSync('tst/private.pem'),
        region: 'YOUR_REGION_CODE',
        sandbox: true,
        algorithm: 'AMZN-PAY-RSASSA-PSS-V2' // Amazon Signing Algorithm, Optional: uses AMZN-PAY-RSASSA-PSS if not specified
    };

    const chargeId = "S01-0000000-0000000-C000000";

    const testPayClient = new Client.WebStoreClient(config);
    const response = testPayClient.getCharge(chargeId);
    
    response.then(function (result) {
        console.log(result.data);
    }).catch(err => {
        console.log(err);
    });
```

## 亚马逊检查 v2 - 更新充电 API

**请注意,API只用于PSP(支付服务供应商)**

```js
    const fs = require('fs');
    const Client = require('@amazonpay/amazon-pay-api-sdk-nodejs');

    const config = {
        publicKeyId: 'YOUR_PUBLIC_KEY_ID',
        privateKey: fs.readFileSync('tst/private.pem'),
        region: 'YOUR_REGION_CODE',
        sandbox: true,
        algorithm: 'AMZN-PAY-RSASSA-PSS-V2' // Amazon Signing Algorithm, Optional: uses AMZN-PAY-RSASSA-PSS if not specified
    };

    const payload = {
        "statusDetails": {
            "state": "Canceled",
            "reasonCode": "ExpiredUnused"
        }
    };
    
    const chargeId = "S01-0000000-0000000-C000000";

    const testPayClient = new Client.WebStoreClient(config);
    const response = testPayClient.updateCharge(chargeId, payload);
    
    response.then(function (result) {
        console.log(result.data);
    }).catch(err => {
        console.log(err);
    });
```

## 检查 v2 - 捕获充电 API

```js
    const fs = require('fs');
    const { randomUUID: uuidv4 } = require('crypto');
    const Client = require('@amazonpay/amazon-pay-api-sdk-nodejs');

    const config = {
        publicKeyId: 'YOUR_PUBLIC_KEY_ID',
        privateKey: fs.readFileSync('tst/private.pem'),
        region: 'YOUR_REGION_CODE',
        sandbox: true,
        algorithm: 'AMZN-PAY-RSASSA-PSS-V2' // Amazon Signing Algorithm, Optional: uses AMZN-PAY-RSASSA-PSS if not specified
    };

    const payload = {
        captureAmount: {
            amount: '10.00',
            currencyCode: 'USD'
        },
        softDescriptor: 'AMZN'
    };

    const headers = {
        'x-amz-pay-idempotency-key': uuidv4().toString().replace(/-/g, '')
    };

    const chargeId = 'S01-0000000-0000000-C000000';
    const testPayClient = new Client.WebStoreClient(config);
    const response = testPayClient.captureCharge(chargeId, payload, headers);
    
    response.then(function (result) {
        console.log(result.data);
    }).catch(err => {
        console.log(err);
    });
```

## 退出 v2 - 取消收费 API

```js
    const fs = require('fs');
    const Client = require('@amazonpay/amazon-pay-api-sdk-nodejs');

    const config = {
        publicKeyId: 'YOUR_PUBLIC_KEY_ID',
        privateKey: fs.readFileSync('tst/private.pem'),
        region: 'YOUR_REGION_CODE',
        sandbox: true,
        algorithm: 'AMZN-PAY-RSASSA-PSS-V2' // Amazon Signing Algorithm, Optional: uses AMZN-PAY-RSASSA-PSS if not specified
    };

    const payload = {
        cancellationReason: 'REASON DESCRIPTION'
    };

    const chargeId = 'S01-0000000-0000000-C000000';
    const testPayClient = new Client.WebStoreClient(config);
    const response = testPayClient.cancelCharge(chargeId, payload);
    
    response.then(function (result) {
        console.log(result.data);
    }).catch(err => {
        console.log(err);
    });
```

## 退出 v2 - 创建退款API

```js
    const fs = require('fs');
    const { randomUUID: uuidv4 } = require('crypto');
    const Client = require('@amazonpay/amazon-pay-api-sdk-nodejs');

    const config = {
        publicKeyId: 'YOUR_PUBLIC_KEY_ID',
        privateKey: fs.readFileSync('tst/private.pem'),
        region: 'YOUR_REGION_CODE',
        sandbox: true,
        algorithm: 'AMZN-PAY-RSASSA-PSS-V2' // Amazon Signing Algorithm, Optional: uses AMZN-PAY-RSASSA-PSS if not specified
    };

    const payload = {
        chargeId: 'S01-0000000-0000000-C000000',
        refundAmount: {
            amount: '14.00',
            currencyCode: 'USD'
        },
        softDescriptor: 'Descriptor'
    };

    const headers = {
        'x-amz-pay-idempotency-key': uuidv4().toString().replace(/-/g, '')
    };

    const testPayClient = new Client.WebStoreClient(config);
    const response = testPayClient.createRefund(payload, headers);
    
    response.then(function (result) {
        console.log(result.data);
    }).catch(err => {
        console.log(err);
    });
```

## 退出 v2 - 获得退款 API

```js
    const fs = require('fs');
    const Client = require('@amazonpay/amazon-pay-api-sdk-nodejs');

    const config = {
        publicKeyId: 'YOUR_PUBLIC_KEY_ID',
        privateKey: fs.readFileSync('tst/private.pem'),
        region: 'YOUR_REGION_CODE',
        sandbox: true,
        algorithm: 'AMZN-PAY-RSASSA-PSS-V2' // Amazon Signing Algorithm, Optional: uses AMZN-PAY-RSASSA-PSS if not specified
    };

    const refundId = "S01-0000000-0000000-R000000";

    const testPayClient = new Client.WebStoreClient(config);
    const response = testPayClient.getRefund(refundId);
    
    response.then(function (result) {
        console.log(result.data);
    }).catch(err => {
        console.log(err);
    });
```

## 在存储商机中

```js
    const payload = {
        scanData: '[scanData]',
        scanReferenceId: '[scanReferenceId]',
        merchantCOE: 'US',
        ledgerCurrency: 'USD'
    };

    testInStoreClient.merchantScan(payload).then(function (response) {
        const merchantScanChargePermissionId = response.data.chargePermissionId;
    });
```

## 生成按钮签名

此帮助函数生成的签名仅对检查出 v2 前端按钮有效. 与API签名不同的是,没有涉及时间戳,因此此功能的结果可以被认为是一个静态签名,可以安全地放入您的网站JS源文件并反复使用(只要您的有效载荷不变).

生成按钮签名函数的示例调用 :

```js
    const fs = require('fs');
    const { randomUUID: uuidv4 } = require('crypto');
    const Client = require('@amazonpay/amazon-pay-api-sdk-nodejs');

    const config = {
        publicKeyId: 'YOUR_PUBLIC_KEY_ID',
        privateKey: fs.readFileSync('tst/private.pem'),
        region: 'YOUR_REGION_CODE',
        sandbox: true,
        algorithm: 'AMZN-PAY-RSASSA-PSS-V2' // Amazon Signing Algorithm, Optional: uses AMZN-PAY-RSASSA-PSS if not specified
    };

    const testPayClient = new Client.AmazonPayClient(config);
    const payload = {
        webCheckoutDetails: {
            checkoutReviewReturnUrl: 'https://localhost/test/checkoutReview.html',
            checkoutResultReturnUrl: 'https://localhost/test/checkoutResult.html'
        },
        storeId: 'amzn1.application-oa2-client.xxxxx'
    };
    const signature = testPayClient.generateButtonSignature(payload);
```

## 手动签名( 仅优先使用- 案件)

此 SDK 提供了帮助您手动签名您的 API 请求的能力, 如果您想要使用自己的代码在互联网上发送 HTTPS 请求 .

用值调用 apiCall 函数的示例:

```js
    /** API to process a request 
     *   - Makes an API Call using the specified options.
     * @param {Object} options - The options to make the API Call
     * @param {String} options.method - The HTTP request method
     * @param {String} options.urlFragment - The URI for the API Call
     * @param {String} [options.payload=null] - The payload for the API Call
     * @param {String} [options.headers=null] - The headers for the API Call
```

示例请求方法 :

```js
    const options = {
        method: 'POST',
        urlFragment: '${version}/in-store/merchantScan',
        payload: {
            scanData: 'UKhrmatMeKdlfY6b',
            scanReferenceId: '0b8fb271-2ae2-49a5-b35d4',
            merchantCOE: 'US',
            ledgerCurrency: 'USD',
            chargeTotal: {
                currencyCode: 'USD',
                amount: '2.00'
            },
            storeLocation: {
                countryCode: 'US'
            },
            metadata: {
                merchantNote: 'Merchant Name',
                customInformation: 'in-store Software Purchase',
                communicationContext: {
                    merchantStoreName: 'Store Name',
                    merchantOrderId: '789123'
                }
            }
        }
    };

    const client = new Client.InStoreClient(config);
    client.apiCall(options).then((apiResponse) => {
        const signedHeders = apiResponse;
    });
```

获得带有值的签名头函数的示例调用 : (只有当您不使用 apiCall 并想要创建您自己的自定义标题时才会使用此选项 。)

```js
    /** Signs the request headers
     *   - Signs the request provided and returns the signed headers object.
     * @param {Object} options - The options to make the API Call
     * @param {String} options.method - The HTTP request method
     * @param {String} options.urlFragment - The URI for the API Call
     * @param {String} [options.payload=null] - The payload for the API Call
     * @param {String} [options.headers=null] - The headers for the API Call
     **/
```

示例请求方法 :

```js
    const options = {
        method: 'POST',
        urlFragment: '${version}/in-store/merchantScan',
        payload: {
            scanData: 'UKhrmatMeKdlfY6b',
            scanReferenceId: '0b8fb271-2ae2-49a5-b35d4',
            merchantCOE: 'US',
            ledgerCurrency: 'USD',
            chargeTotal: {
                currencyCode: 'USD',
                amount: '2.00'
            },
            storeLocation: {
                countryCode: 'US'
            },
            metadata: {
                merchantNote: 'Merchant Name',
                customInformation: 'in-store Software Purchase',
                communicationContext: {
                    merchantStoreName: 'Store Name',
                    merchantOrderId: '789123'
                }
            }
        },
        headers: {
            'Accept': 'application/json',
            'Content-Type': 'application/json'
            'X-Amz-Pay-Region': 'us'
        }
    };

    const client = new Client.AmazonPayClient(config);
    const signedHeaders = client.getSignedHeaders(options);
```

# 报告 APIs 代码样本

## 亚马逊检查 v2 报告 API - Get Report API

```js
    const fs = require('fs');
    const { randomUUID: uuidv4 } = require('crypto');
    const Client = require('@amazonpay/amazon-pay-api-sdk-nodejs');

    const config = {
        publicKeyId: 'YOUR_PUBLIC_KEY_ID',
        privateKey: fs.readFileSync('tst/private.pem'),
        region: 'YOUR_REGION_CODE',
        sandbox: false,
        algorithm: 'AMZN-PAY-RSASSA-PSS-V2' // Amazon Signing Algorithm, Optional: uses AMZN-PAY-RSASSA-PSS if not specified
    };

    const testPayClient = new Client.WebStoreClient(config);
    const requestPayload = {
        reportTypes: "_GET_FLAT_FILE_OFFAMAZONPAYMENTS_SETTLEMENT_DATA_",
    };
    const response = testPayClient.getReports(requestPayload);
    
    response.then(function (result) {
        console.log(result.data);
    }).catch(err => {
        console.log(err);
    });
```

## 亚马逊检查 v2 报告 API - Get ReportById API

```js
    const fs = require('fs');
    const { randomUUID: uuidv4 } = require('crypto');
    const Client = require('@amazonpay/amazon-pay-api-sdk-nodejs');

    const config = {
        publicKeyId: 'YOUR_PUBLIC_KEY_ID',
        privateKey: fs.readFileSync('tst/private.pem'),
        region: 'YOUR_REGION_CODE',
        sandbox: false,
        algorithm: 'AMZN-PAY-RSASSA-PSS-V2' // Amazon Signing Algorithm, Optional: uses AMZN-PAY-RSASSA-PSS if not specified
    };

    const reportId = '1234567890';
    const testPayClient = new Client.WebStoreClient(config);
    const response = testPayClient.getReportById(reportId);
    
    response.then(function (result) {
        console.log(result.data);
    }).catch(err => {
        console.log(err);
    });
```

## 亚马逊检查 v2 报告 API - Get ReportDocument API

```js
    const fs = require('fs');
    const { randomUUID: uuidv4 } = require('crypto');
    const Client = require('@amazonpay/amazon-pay-api-sdk-nodejs');

    const config = {
        publicKeyId: 'YOUR_PUBLIC_KEY_ID',
        privateKey: fs.readFileSync('tst/private.pem'),
        region: 'YOUR_REGION_CODE',
        sandbox: false,
        algorithm: 'AMZN-PAY-RSASSA-PSS-V2' // Amazon Signing Algorithm, Optional: uses AMZN-PAY-RSASSA-PSS if not specified
    };

    const reportDocumentId = 'amzn1.tortuga.0.000000000-0000-0000-0000-000000000000.00000000000000';
    const testPayClient = new Client.WebStoreClient(config);
    const response = testPayClient.getReportDocument(reportDocumentId);
    
    response.then(function (result) {
        console.log(result.data);
    }).catch(err => {
        console.log(err);
    });
```

## 亚马逊检查 v2 报告 API - Get ReportSchedules API

```js
    const fs = require('fs');
    const { randomUUID: uuidv4 } = require('crypto');
    const Client = require('@amazonpay/amazon-pay-api-sdk-nodejs');

    const config = {
        publicKeyId: 'YOUR_PUBLIC_KEY_ID',
        privateKey: fs.readFileSync('tst/private.pem'),
        region: 'YOUR_REGION_CODE',
        sandbox: false,
        algorithm: 'AMZN-PAY-RSASSA-PSS-V2' // Amazon Signing Algorithm, Optional: uses AMZN-PAY-RSASSA-PSS if not specified
    };

    const reportTypes = '_GET_FLAT_FILE_OFFAMAZONPAYMENTS_ORDER_REFERENCE_DATA_,_GET_FLAT_FILE_OFFAMAZONPAYMENTS_BILLING_AGREEMENT_DATA_';
    const testPayClient = new Client.WebStoreClient(config);
    const response = testPayClient.getReportSchedules(reportTypes);
    
    response.then(function (result) {
        console.log(result.data);
    }).catch(err => {
        console.log(err);
    });
```

## 亚马逊检查 v2 报告 API - Get ReportScheduleById API

```js
    const fs = require('fs');
    const { randomUUID: uuidv4 } = require('crypto');
    const Client = require('@amazonpay/amazon-pay-api-sdk-nodejs');

    const config = {
        publicKeyId: 'YOUR_PUBLIC_KEY_ID',
        privateKey: fs.readFileSync('tst/private.pem'),
        region: 'YOUR_REGION_CODE',
        sandbox: false,
        algorithm: 'AMZN-PAY-RSASSA-PSS-V2' // Amazon Signing Algorithm, Optional: uses AMZN-PAY-RSASSA-PSS if not specified
    };

    const reportScheduleId = '1234567890';
    const testPayClient = new Client.WebStoreClient(config);
    const response = testPayClient.getReportScheduleById(reportScheduleId);
    
    response.then(function (result) {
        console.log(result.data);
    }).catch(err => {
        console.log(err);
    });
```

## 亚马逊检查 v2 报告 API - 创建报告 API

```js
    const fs = require('fs');
    const { randomUUID: uuidv4 } = require('crypto');
    const Client = require('@amazonpay/amazon-pay-api-sdk-nodejs');

    const config = {
        publicKeyId: 'YOUR_PUBLIC_KEY_ID',
        privateKey: fs.readFileSync('tst/private.pem'),
        region: 'YOUR_REGION_CODE',
        sandbox: false,
        algorithm: 'AMZN-PAY-RSASSA-PSS-V2' // Amazon Signing Algorithm, Optional: uses AMZN-PAY-RSASSA-PSS if not specified
    };

    const requestPayload = {
        reportType: '_GET_FLAT_FILE_OFFAMAZONPAYMENTS_AUTHORIZATION_DATA_',
        startTime: '20221114T074550Z',
        endTime: '20221114T074550Z'
    }
    const testPayClient = new Client.WebStoreClient(config);
    const response = testPayClient.createReport(requestPayload);
    
    response.then(function (result) {
        console.log(result.data);
    }).catch(err => {
        console.log(err);
    });
```

## 亚马逊检查 v2 报告 API - 创建报告列表 API

```js
    const fs = require('fs');
    const { randomUUID: uuidv4 } = require('crypto');
    const Client = require('@amazonpay/amazon-pay-api-sdk-nodejs');

    const config = {
        publicKeyId: 'YOUR_PUBLIC_KEY_ID',
        privateKey: fs.readFileSync('tst/private.pem'),
        region: 'YOUR_REGION_CODE',
        sandbox: false,
        algorithm: 'AMZN-PAY-RSASSA-PSS-V2' // Amazon Signing Algorithm, Optional: uses AMZN-PAY-RSASSA-PSS if not specified
    };

    const requestPayload = {
        reportType: "_GET_FLAT_FILE_OFFAMAZONPAYMENTS_ORDER_REFERENCE_DATA_",
        scheduleFrequency: "P1D",
        nextReportCreationTime: "20230317T074550Z",
        deleteExistingSchedule: false
    }
    const testPayClient = new Client.WebStoreClient(config);
    const response = testPayClient.createReportSchedule(requestPayload);
    
    response.then(function (result) {
        console.log(result.data);
    }).catch(err => {
        console.log(err);
    });
```

## Amazon checkout v2 报告 API - 取消报告列表 API

```js
    const fs = require('fs');
    const { randomUUID: uuidv4 } = require('crypto');
    const Client = require('@amazonpay/amazon-pay-api-sdk-nodejs');

    const config = {
        publicKeyId: 'YOUR_PUBLIC_KEY_ID',
        privateKey: fs.readFileSync('tst/private.pem'),
        region: 'YOUR_REGION_CODE',
        sandbox: false,
        algorithm: 'AMZN-PAY-RSASSA-PSS-V2' // Amazon Signing Algorithm, Optional: uses AMZN-PAY-RSASSA-PSS if not specified
    };

    const reportScheduleId = "1234567890";
    const testPayClient = new Client.WebStoreClient(config);
    const response = testPayClient.cancelReportSchedule(reportScheduleId);
    
    response.then(function (result) {
        console.log(result.data);
    }).catch(err => {
        console.log(err);
    });
```

## Amazon 退出 v2 SPC - 完成退出会话 API

```js
    const fs = require('fs');
    const { randomUUID: uuidv4 } = require('crypto');
    const Client = require('@amazonpay/amazon-pay-api-sdk-nodejs');

    const config = {
        publicKeyId: 'YOUR_PUBLIC_KEY_ID',
        privateKey: fs.readFileSync('tst/private.pem'),
        region: 'YOUR_REGION_CODE',
        sandbox: true,
        algorithm: 'AMZN-PAY-RSASSA-PSS-V2' // Amazon Signing Algorithm, Optional: uses AMZN-PAY-RSASSA-PSS if not specified
    };

    const checkoutSessionId = "00000000-0000-0000-0000-000000000000";
    const payload = {
        shippingAddress: {
            name: "Susie Smith",
            addressLine1: "10 Ditka Ave",
            addressLine2: "Suite 2500",
            city: "Chicago",
            county: null,
            district: null,
            stateOrRegion: "IL",
            postalCode: "60602",
            countryCode: "US",
            phoneNumber: "800-000-0000"
        },
        billingAddress: null,
        chargeAmount: {
            amount: 10,
            currencyCode: "USD"
        },
        totalOrderAmount: {
            amount: 10,
            currencyCode: "USD"
        },
        paymentIntent: "Confirm",
        canHandlePendingAuthorization: false
    };
    const headers = {
        'x-amz-pay-idempotency-key': uuidv4().toString().replace(/-/g, '')
    };

    const testPayClient = new Client.WebStoreClient(config);
    const response = testPayClient.finalizeCheckoutSession(checkoutSessionId, payload, headers);
    
    response.then(function (result) {
        console.log(result.data);
    }).catch(err => {
        console.log(err);
    });
```

## 亚马逊检查 v2 争议 API - 创建争议 API

```js
    const fs = require('fs');
    const { randomUUID: uuidv4 } = require('crypto');
    const Client = require('@amazonpay/amazon-pay-api-sdk-nodejs');

    const config = {
        publicKeyId: 'YOUR_PUBLIC_KEY_ID',
        privateKey: fs.readFileSync('tst/private.pem'),
        region: 'YOUR_REGION_CODE',
        sandbox: true,
        algorithm: 'AMZN-PAY-RSASSA-PSS-V2' // Amazon Signing Algorithm, Optional: uses AMZN-PAY-RSASSA-PSS if not specified
    };

    const payload = {
        'chargeId': 'S01-0000000-0000000-C000000',
        'providerMetadata': {
            'providerDisputeId': 'XXXXXXXXXXXX'
        },
        'disputeAmount': {
            'amount': '1',
            'currencyCode': 'JPY'
        },
        'filingReason': 'ProductNotReceived',
        'filingTimestamp': Date.now(),
        'statusDetails': {
            'state': 'ActionRequired'
        },
        'merchantResponseDeadline': Date.now()+ (14 * 24 * 60 * 60 * 1000)
    };

    const headers = {
        'x-amz-pay-idempotency-key': uuidv4().toString().replace(/-/g, '')
    };
    
    const testPayClient = new Client.WebStoreClient(config);
    const response = testPayClient.createDispute(payload, headers);
    
    response.then(function (result) {
        console.log(result.data);
    }).catch(err => {
        console.log(err);
    });
```

## 亚马逊检查 v2 争议 API - 获取争议 API

```js
const fs = require('fs');
    const Client = require('@amazonpay/amazon-pay-api-sdk-nodejs');

    const config = {
        publicKeyId: 'YOUR_PUBLIC_KEY_ID',
        privateKey: fs.readFileSync('tst/private.pem'),
        region: 'YOUR_REGION_CODE',
        sandbox: true,
        algorithm: 'AMZN-PAY-RSASSA-PSS-V2' // Amazon Signing Algorithm, Optional: uses AMZN-PAY-RSASSA-PSS if not specified
    };
    
    const disputeId = 'S01-0000000-0000000-B000000'
    
    const testPayClient = new Client.WebStoreClient(config);
    const response = testPayClient.getDispute(disputeId);
    
    response.then(function (result) {
        console.log(result.data);
    }).catch(err => {
        console.log(err);
    });
```

## 亚马逊检查 v2 争议 API - 更新争议 API

```js
    const fs = require('fs');
    const Client = require('@amazonpay/amazon-pay-api-sdk-nodejs');

    const config = {
        publicKeyId: 'YOUR_PUBLIC_KEY_ID',
        privateKey: fs.readFileSync('tst/private.pem'),
        region: 'YOUR_REGION_CODE',
        sandbox: true,
        algorithm: 'AMZN-PAY-RSASSA-PSS-V2' // Amazon Signing Algorithm, Optional: uses AMZN-PAY-RSASSA-PSS if not specified
    };

    const payload = {
        "statusDetails": {
            "resolution": "MerchantWon",
            "state": "Resolved",
            "reasonCode": "MerchantAcceptedDispute",
            "reasonDescription": "Merchant accepted the dispute request"
        },
        "closureTimestamp": Date.now()
    };

    const disputeId = 'S01-0000000-0000000-B000000'
    
    const testPayClient = new Client.WebStoreClient(config);
    const response = testPayClient.updateDispute(disputeId,payload);
    
    response.then(function (result) {
        console.log(result.data);
    }).catch(err => {
        console.log(err);
    });
```

## 亚马逊检查 v2 争议 API - 竞争争议 API

```js
    const fs = require('fs');
    const Client = require('@amazonpay/amazon-pay-api-sdk-nodejs');

    const config = {
        publicKeyId: 'YOUR_PUBLIC_KEY_ID',
        privateKey: fs.readFileSync('tst/private.pem'),
        region: 'YOUR_REGION_CODE',
        sandbox: true,
        algorithm: 'AMZN-PAY-RSASSA-PSS-V2' // Amazon Signing Algorithm, Optional: uses AMZN-PAY-RSASSA-PSS if not specified
    };

    const payload = {
        "merchantEvidences":  [
            {
                "evidenceType" : "TrackingNumber",
                "fileId": "20ca8c0f-3778-1b5a-8598-3d38cfdc4bde",
                "evidenceText": "raw text supporting merchant evidence"
            }
        ]
    };

    const disputeId = 'S01-0000000-0000000-B000000'
    
    const testPayClient = new Client.WebStoreClient(config);
    const response = testPayClient.contestDispute(disputeId,payload);
    
    response.then(function (result) {
        console.log(result.data);
    }).catch(err => {
        console.log(err);
    });
```

## Amazon 检查 v2 文件 API - 文件 API

```js
    const fs = require('fs');
    const { randomUUID: uuidv4 } = require('crypto');
    const Client = require('@amazonpay/amazon-pay-api-sdk-nodejs');

    const config = {
        publicKeyId: 'YOUR_PUBLIC_KEY_ID',
        privateKey: fs.readFileSync('tst/private.pem'),
        region: 'YOUR_REGION_CODE',
        sandbox: true,
        algorithm: 'AMZN-PAY-RSASSA-PSS-V2' // Amazon Signing Algorithm, Optional: uses AMZN-PAY-RSASSA-PSS if not specified
    };

    const payload = {
        "type" : "jpg",
        "purpose" : "disputeEvidence"
    };

    const headers = {
        'x-amz-pay-idempotency-key': uuidv4().toString().replace(/-/g, '')
    };
    
    const testPayClient = new Client.WebStoreClient(config);
    const response = testPayClient.uploadFile(payload,headers);
    
    response.then(function (result) {
        console.log(result.data);
    }).catch(err => {
        console.log(err);
    });
```

### Amazon checkout v2 代理解决方案供应商的 Merchant 登入和账户管理 API - 创建 Merchant 账户 API

```js
    const fs = require('fs');
    const { randomUUID: uuidv4 } = require('crypto');
    const Client = require('@amazonpay/amazon-pay-api-sdk-nodejs');

    const config = {
        publicKeyId: 'YOUR_PUBLIC_KEY_ID',
        privateKey: fs.readFileSync('tst/private.pem'),
        region: 'YOUR_REGION_CODE',
        sandbox: true,
        algorithm: 'AMZN-PAY-RSASSA-PSS-V2' // Amazon Signing Algorithm, Optional: uses AMZN-PAY-RSASSA-PSS if not specified
    };

    const payload = {
        uniqueReferenceId: "Unique_Reference_Id",
        ledgerCurrency: "JPY",
        businessInfo: {
            email: "abhi@abc.com",
            businessType: "CORPORATE",
            businessLegalName: "密林コーヒー",
            businessCategory: "Beauty",
            businessDisplayName: "Abhi's Cafe",
            annualSalesVolume: {
                amount: "100000",
                currencyCode: "JPY"
            },
            countryOfEstablishment: "JP",
            businessAddress: {
                addressLine1: "扇町４丁目５－１",
                addressLine2: "フルフィルメントセンタービル",
                city: "小田原市",
                stateOrRegion: "神奈川県",
                postalCode: "250-0001",
                countryCode: "JP",
                phoneNumber: {
                    countryCode: "81",
                    number: "2062062061"
                }
            },
            customerSupportInformation: {
                customerSupportEmail: "test.merchant_abhi@abc.com",
                customerSupportPhoneNumber: {
                    countryCode: "1",
                    number: "1234567",
                    extension: "123"
                }
            }
        },
        beneficiaryOwners: [
            {
                personFullName: "Abhishek Kumar",
                residentialAddress: {
                    addressLine1: "扇町４丁目５－１",
                    addressLine2: "フルフィルメントセンタービル",
                    city: "小田原市",
                    stateOrRegion: "神奈川県",
                    postalCode: "250-0001",
                    countryCode: "JP",
                    phoneNumber: {
                        countryCode: "81",
                        number: "2062062061"
                    }
                }
            }
        ],
        primaryContactPerson: {
            personFullName: "Abhishek Kumar"
        },
        integrationInfo: {
            ipnEndpointUrls: [
                "https://yourdomainname.com/ipnendpoint1",
                "https://yourdomainname.com/ipnendpoint2"
            ]
        },
        stores: [
            {
                domainUrls: [
                    "https://yourdomainname.com"
                ],
                storeName: "Rufus's Cafe",
                privacyPolicyUrl: "https://yourdomainname.com/privacy",
                storeStatus: {
                    state: "ACTIVE",
                    reasonCode: null
                }
            }
        ],
        merchantStatus: {
            statusProvider: "Ayden",
            state: "ACTIVE",
            reasonCode: null
        }
    };
    
    const testPayClient = new Client.WebStoreClient(config);
    const response = testPayClient.createMerchantAccount(payload);
    
    response.then(function (result) {
        console.log(result.data);
    }).catch(err => {
        console.log(err);
    });
```

### Amazon 取出 v2 Merchant 登入和账户管理 API 授权解决方案供应商 - 更新 Merchant 账户 API

```js
    const fs = require('fs');
    const { randomUUID: uuidv4 } = require('crypto');
    const Client = require('@amazonpay/amazon-pay-api-sdk-nodejs');

    const config = {
        publicKeyId: 'YOUR_PUBLIC_KEY_ID',
        privateKey: fs.readFileSync('tst/private.pem'),
        region: 'YOUR_REGION_CODE',
        sandbox: true,
        algorithm: 'AMZN-PAY-RSASSA-PSS-V2' // Amazon Signing Algorithm, Optional: uses AMZN-PAY-RSASSA-PSS if not specified
    };

    const payload = {
        businessInfo: {
            email: "abhi_updated@abc.com",
            businessType: "CORPORATE",
            businessLegalName: "密林コーヒー",
            businessCategory: "Beauty",
            businessDisplayName: "Abhi's Golden Cafe",
            annualSalesVolume: {
                amount: "500000",
                currencyCode: "JPY"
            },
            countryOfEstablishment: "JP",
            businessAddress: {
                addressLine1: "扇町４丁目５－１",
                addressLine2: "フルフィルメントセンタービル",
                city: "小田原市",
                stateOrRegion: "神奈川県",
                postalCode: "250-0025",
                countryCode: "JP",
                phoneNumber: {
                    countryCode: "81",
                    number: "2062062065"
                }
            },
            customerSupportInformation: {
                customerSupportEmail: "test.merchant_abhi@abc.com",
                customerSupportPhoneNumber: {
                    countryCode: "1",
                    number: "9999999",
                    extension: "123"
                }
            }
        }
    };
    
    const headers = {
        'x-amz-pay-authtoken': 'AUTH-TOKEN'
    };
    
    const testPayClient = new Client.WebStoreClient(config);
    const response = testPayClient.updateMerchantAccount("AXXXXXXX",payload,headers);
    
    response.then(function (result) {
        console.log(result.data);
    }).catch(err => {
        console.log(err);
    });
```

### Amazon检查 v2Merchant 注册和账户管理 APIs for Authorized Solutions - Merchant 账户索赔 API

```js
    const fs = require('fs');
    const Client = require('@amazonpay/amazon-pay-api-sdk-nodejs');

    const config = {
        publicKeyId: 'YOUR_PUBLIC_KEY_ID',
        privateKey: fs.readFileSync('tst/private.pem'),
        region: 'YOUR_REGION_CODE',
        sandbox: true,
        algorithm: 'AMZN-PAY-RSASSA-PSS-V2' // Amazon Signing Algorithm, Optional: uses AMZN-PAY-RSASSA-PSS if not specified
    };

    const payload = {
        uniqueReferenceId: 'xxxxxxx-xxxx-xxxx-xxxx-xxxxxx'
    };
    
    
    const testPayClient = new Client.WebStoreClient(config);
    const response = testPayClient.merchantAccountClaim("AXXXXXXX",payload);
    
    response.then(function (result) {
        console.log(result.data);
        console.log('Location:', result.headers["location"]);
    }).catch(err => {
        console.log(err);
    });
```

## 亚马逊检查 v2 存储管理 API - 创建存储 API

注:此API仅限上市解决方案提供商使用.

```js
    const fs = require('fs');
    const { randomUUID: uuidv4 } = require('crypto');
    const Client = require('@amazonpay/amazon-pay-api-sdk-nodejs');

    const config = {
        publicKeyId: 'YOUR_PUBLIC_KEY_ID',
        privateKey: fs.readFileSync('tst/private.pem'),
        region: 'YOUR_REGION_CODE',
        sandbox: false,
        algorithm: 'AMZN-PAY-RSASSA-PSS-V2' // Amazon Signing Algorithm, Optional: uses AMZN-PAY-RSASSA-PSS if not specified
    };

    const payload = {
        allowedOriginDomains: ['https://example.com', 'https://www.example.com'],
        allowedRedirectURLs: ['https://example.com/return', 'https://example.com/cancel'],
        storeName: 'My Store',
        privacyPolicyUrl: 'https://example.com/privacy',
        merchantLogoUrl: 'https://example.com/logo.png'
    };

    const headers = {
        'x-amz-pay-idempotency-Key': uuidv4().toString().replace(/-/g, ''),
        'x-amz-pay-authToken': 'YOUR_AUTH_TOKEN'
    };

    const merchantAccountId = 'MERCHANT_ACCOUNT_ID';

    const testPayClient = new Client.WebStoreClient(config);
    const response = testPayClient.createStore(merchantAccountId, payload, headers);

    response.then(function (result) {
        console.log(result.data);
    }).catch(err => {
        console.log(err);
    });
```

## 亚马逊检查 v2 存储管理 API - 更新存储 API

注:此API仅限上市解决方案提供商使用.

```js
    const fs = require('fs');
    const Client = require('@amazonpay/amazon-pay-api-sdk-nodejs');

    const config = {
        publicKeyId: 'YOUR_PUBLIC_KEY_ID',
        privateKey: fs.readFileSync('tst/private.pem'),
        region: 'YOUR_REGION_CODE',
        sandbox: false,
        algorithm: 'AMZN-PAY-RSASSA-PSS-V2' // Amazon Signing Algorithm, Optional: uses AMZN-PAY-RSASSA-PSS if not specified
    };

    const payload = {
        allowedOriginDomains: ['https://updated-example.com', 'https://www.updated-example.com'],
        allowedRedirectURLs: ['https://updated-example.com/return', 'https://updated-example.com/cancel'],
        storeName: 'Updated Store Name',
        privacyPolicyUrl: 'https://updated-example.com/privacy',
        merchantLogoUrl: 'https://updated-example.com/new-logo.png'
    };

    const headers = {
        'x-amz-pay-authToken': 'YOUR_AUTH_TOKEN'
    };

    const merchantAccountId = 'MERCHANT_ACCOUNT_ID';
    const storeId = 'STORE_ID';

    const testPayClient = new Client.WebStoreClient(config);
    const response = testPayClient.updateStore(merchantAccountId, storeId, payload, headers);

    response.then(function (result) {
        console.log(result.data);
    }).catch(err => {
        console.log(err);
    });
```

## 常见问题

### @amazonpay/amazon-pay-api-sdk-nodejs 是什么？

亚马逊支付支票 V2 集成

### 如何安装 @amazonpay/amazon-pay-api-sdk-nodejs？

在项目目录运行 npm install @amazonpay/amazon-pay-api-sdk-nodejs，或使用 pnpm add / yarn add / bun add。

### @amazonpay/amazon-pay-api-sdk-nodejs 支持 TypeScript 吗？

该包的 package\.json 没有声明类型入口。需要类型提示时，可以在 npm 上查找社区维护的 @types/amazonpay\_\_amazon-pay-api-sdk-nodejs 是否存在。

### @amazonpay/amazon-pay-api-sdk-nodejs 支持 ESM 还是 CommonJS？

以 CommonJS 形式发布，可以直接 require\(\)；在 ES Module 项目中也可以用 import 引入（Node\.js 会把 module\.exports 作为默认导出）。

### @amazonpay/amazon-pay-api-sdk-nodejs 可以商用吗？

@amazonpay/amazon-pay-api-sdk-nodejs 使用 Apache-2\.0 许可。宽松许可：允许商业使用、修改和再分发，并附带明确的专利授权；分发时需保留许可与 NOTICE 文件，修改过的文件要注明改动。以上为概括，不构成法律意见，请以许可原文为准。

### @amazonpay/amazon-pay-api-sdk-nodejs 的下载量有多少？

根据 npm 官方下载统计，@amazonpay/amazon-pay-api-sdk-nodejs 在 2026/10/06 – 2026/11/04 这 30 天内被下载 36,467 次，日均约 1,216 次。下载量会把 CI 构建、镜像同步和作为其他包依赖的安装一并计入，适合横向比较热度，不能直接等同于使用人数。

### @amazonpay/amazon-pay-api-sdk-nodejs 还在维护吗？

最新版本 2\.3\.6 发布于 2026/10/02（1 个月前）；至今共发布 16 个版本，其中过去 12 个月发布了 1 个；首次发布于 2020/05/08。发布频率只是参考信号：功能稳定的工具可能很少需要更新，建议结合源码仓库的 issue 和提交记录判断。