Have questions? Leave your message here or Schedule a quick call with our manager now

FAQ

General Service Questions

Return (RMA, Return Merchandise Authorization) - return of low-quality or defective goods for repair, replacement, refund, etc. Only shipped goods can be returned.

The return process may vary depending on the specific eCommerce platform. However, the return procedure usually includes the following:

  1. The customer creates a return request, where he indicates the product he wants to return, the reason for the return, and the desired action (product replacement, repair, refund, etc.).
  2. Depending on the return policy of a particular online store, the seller can confirm or reject the customer's request.
  3. If the manager confirms the return request, the product is sent back to the seller.
  4. The seller performs an action (replaces the product, refunds, etc.).

First of all, you need to check in the API2Cart API Documentation whether there are methods for working with returns for your chosen eCommerce platform:

return methods api2cart

You should also read the method description to know which options are supported and required for a particular eCommerce platform.

Or you can use this link.

Returns are closely related to orders. Methods for importing (creating and updating) returns are in the order section. For greater filtering capabilities, methods for exporting returns are placed in a separate return section.

To create a return, you need to use the order.return.add method.

order return method

For all platforms, order_id and order_products must be specified. That is, which order and which products in the order will be returned.

In order_products, you need to specify the following:

  • order_product_id - the product ID in the order. The value should be taken from the export of orders (order.list/info)
  • order_product_id
  • order_product_quantity - number of product units to be returned.

Depending on the eCommerce platform, you must also specify:

  • order_product_reason_id return reason, the value must be taken from the return.reason.list method. Not supported on Bol.com.
  • order_product_customer_comment - the customer's comment describing the reason for the return. On some platforms, there may be a separate comment for each product, and on some, there may be one common comment for all products, in which case you need to specify the comment parameter.
  • order_product_handling_status - supported only on Bol.com. Is required. This is the processing status of the returned product. Possible values are displayed in the error text if an incorrect value is specified.
  • order_product_handling_status
  • return_status_id - return status, the value must be taken from the return.status.list method.

The return status can be updated using the order.return.update method.

order.return.update method

You can't specify any return status on Shopify. Shopify has a clear return workflow. Follow this chart to find out which status you can upgrade to.

return status on Shopify

A list of all returns can be obtained with the help of return.list method.

For Shopify, you must specify the order_id or order_ids parameter. That is, on Shopify, you can only issue returns for a specific order.

In order to find out for which orders there are returns, you need to select the value from the export orders field additional_fields -> return_status.

return_status

If the value is no_return, then no return request was created for such an order. Accordingly, return.list will not return anything for such an order. If the status is any other, then in this case, a return will be displayed for the order.

For Shopify, there is a return_status filter in the order.list method that allows you to filter orders for which there is a return.

The Plugin Builder allows you to build the Bridge Connector plugin, which is used to connect the store to API2Cart, for different shopping platforms. The following platforms are currently supported:

  • Magento 2
  • Opencart 2.x - 4.x
  • PrestaShop
  • Shopware 6
  • WooCommerce

If the “Plugin builder” feature is available in the account plan, the plugin can be customized to your needs, for example, you can specify the plugin's name, company, description, and logo. Also, you can enable or disable encryption on the bridge, configure the callback URL, etc. When this feature is unavailable in the plan, the values for the plugin are set by default.

Also, the possibility of asymmetric data encryption has been added to the Plugin Builder. Data is encrypted using the OAEP (Optimal Asymmetric Encryption Padding) protocol, which provides a reliable level of security and resistance to attacks. More details.

Callback URL and Public Key allow you to generate a plugin. After installing it and clicking the “Connect” button, a webhook will be sent to the URL that was specified in the Callback URL field with encrypted store credentials that can be used when adding it to APICart. Namely: store_url, store_key, store_root, bridge_url. Data is encrypted with an RSA key. You can insert your own public key or generate a pair of 2048-bit keys.

The data sent to the callback is encrypted according to the following principle:

  • Encoding the data array into a JSON string
  • Division of the received string into parts of one length (depending on the length of the generated key)
  • Encoding the parts with the public key
  • Combining the encoded parts into one string and converting it to base64 format
  • Sending the base64-encoded string to the callback

The callback will receive a webhook with encrypted data in the "data" field.

The x-webhook-cart-id and x-webhook-timestamp headers are also available.

To decrypt the data, you need to perform actions with the received data in the reverse direction:

  • Decode from base64
  • Division of the string into equal parts (depending on the key length)
  • Decrypt the received parts using the private key
  • Combine the obtained decrypted parts into a single JSON string

Here's an example of PHP code:

As a result, you will receive data that can be used in the account.cart.add method to add a store.

Some fields in the Pplugin Builder are validated, and an error will be displayed if incorrect data is entered. Also, next to each field is a hint with a brief description of what this field is for.

After successfully building the plugin, the downloaded archive with the plugin can be installed on the page of the selected platform.

Asymmetric data encryption has been added in version 141 of the bridge as well as plugins that can be built using the plugin builder. Data is encrypted using the OAEP (Optimal Asymmetric Encryption Padding) protocol, which provides reliable security and resistance to attacks.

When exchanging data between API2Cart and the server on which the bridge or plugin is installed, there is a risk of interception of this data. Especially if the data is not transmitted over a secure HTTP protocol, an attacker can gain unauthorized access to the database. In addition, if the attacker somehow learns the store_key, he can directly interact with the store through the bridge, bypassing API2Cart. To prevent this from happening, we implemented asymmetric data encryption.

Here's how it works:

  • when downloading a bridge or installing a plugin generated by the plugin builder, a pair of keys is generated: a public key for encryption (contained in the bridge file) and a private key for decryption (added and known only to API2Cart). Each new store will have an individual key.
  • data transmitted to the bridge is encrypted using a private key.
  • when receiving data from API2Cart, the bridge decrypts the data, and the bridge executes the necessary scripts.
  • the received results are encrypted using a public key and sent to API2Cart, where they are decrypted using a private key.

This algorithm does not lead to significant delays in the execution of requests or additional load on the server and is a reliable tool for protecting confidential data during its exchange between parties.

Its main advantages:

  • Encrypted communication channel prevents interception of confidential data.
  • Protection against store_key exposure; an attacker will not be able to perform requests directly to the bridge/plugin even if he knows the store_key.

The main difference between the Enterprise On-Premise solution and the other plans provided by API2Cart is that no one except your team will have access to the service resources (as it will be on your chosen server). Enterprise On-Premise solution guarantees you the highest level of data security that can be provided by API2Cart.

You can take sole control of who can manage your API2Cart server infrastructure by using the functionality provided by Amazon Web Service (AWS), Microsoft Azure, Hetzner Cloud, and Google Cloud Platform. Also, you can use API2Cart service on your own server.

All requests will be made over HTTPS protocol.

With the Enterprise On-Premise solution, you will be able to manipulate the data from as many of your clients’ stores as needed with no limits.

Also, Enterprise On-Premise solution includes webhooks, escrow service, WhiteLabel, and plugin builder.

Enterprise On-Premise solution is perfect for high-volume enterprises with a high number of clients.

To test API2Cart Enterprise On-Premise solution you will need to:

  1. Contact our manager by phone, email ([email protected]), or online chat. At first, you can test API2Cart functionality on https://app.api2cart.com/. If you decide to switch to Enterprise On-Premise Solution, you contact us, and we will create a separate server for you with no limits.
  2. We create infrastructure on Amazon. Enterprise On-Premise solution is placed on Amazon Cloud storage. It is possible to get access to it using our Amazon Web Services (AWS) or your own. Also, you can use the solution not only on AWS but also on Google Cloud, Microsoft Azure, Hetzner Cloud, or your own server.
  3. Get access to API2Cart using a particular link. API2Cart Enterprise On-Premise solution is available on a special link. Only your team will have access to it. Also, it can be a special subdomain (e.g., yourcompany.api2cart.com) or domain (api2cart.yourcompanydomain.com).
  4. Test the solution for 30-days for free. During the trial period, you will be able to connect an unlimited number of your clients’ online stores and use all API2Cart API methods for working with the data related to products, categories, customers, orders, shipments, etc.

The usage of API2Cart Enterprise On-Premise solution includes continuous support by our dedicated tech specialists.

Yes, API2Cart supports the following shopping carts plugins:

You can also download some plugins in the "Plugins" section of your API2Cart account.

We return Live Shipping Rates on Shopify, Magento, Magento 2, and WooCommerce for now (November 2021)

Methods:

/basket.live_shipping_service.list.json

/basket.live_shipping_service.create.json

/basket.live_shipping_service.delete.json

 

How it works?

Create new shipping service on the store

/basket.live_shipping_service.create.json

      On WooCommerce stores there can be an unlimited amount of services, but on Shopify you can create only one sevice (Shopify limit).

      To create the service you’ll have to specify the name of the service and callback url, that will return us shipping rates. We validate the callback when it is being created by sending test request to it. Test requests contain header X-Shipping-Service: 1.  

      To check it the request was really sent by API2Cart, compare header signature X-Shipping-Service-Signature

      The signature is built based on all headers that start with X-Shipping-Service, except for X-Shipping-Service-Signature.

 

Video tutorial:

 

The algorithm:

      1. Create array of headers, let the header name be its key, its value - the header value string.

      2. Sort the headers by the name.  

      3. Create the string for signature, that is made of headers. For that, encode the array of headers in JSON and concatenate from request body.

      4. Calculate sha256 signature in binary format

      5. Convert the binary signature to base64

 

Php example:

      $headersToSign = [

      'X-Shipping-Service-Test-Request' => '1',

      'X-Shipping-Service-Request-Timestamp' => '1553177278'

      ];

      ksort($headersToSign);

      $headersJson = json_encode($headers);

      $sign = base64_encode(hash_hmac('sha256', $headersJson . $body, $signingKey, true));

 

Test request example (from API2Cart)

 

REQUEST: POST /rates.php

Host: www.stores.local

Connection: close

User-Agent: Zend_Http_Client

accept-encoding: identity

content-type: application/json

accept: application/json

X-Shipping-Service-Signature: Q4jaFbiUKJW2gjTHqvlRrWMUOx65CaepT0BaKFiw6a0=

X-Shipping-Service-Test-Request: 1

X-Shipping-Service-Request-Timestamp: 1553609265

Content-Length: 1880

{

   "packages": [

       {

           "id": "1",

           "currency_code": "USD",

           "origin": {

               "first_name": null,

               "last_name": null,

               "postcode": "35004",

               "address1": "Test, 1\/1",

               "address2": "",

               "phone": "",

               "city": "Moody",

               "country": {

                   "code2": "US",

                   "code3": "USA",

                   "name": "United States of America"

               },

               "state": {

                   "code": "AL",

                   "name": "Alabama"

               },

               "company": null

           },

           "destination": {

               "first_name": null,

               "last_name": null,

               "postcode": "35005",

               "address1": "Test, 1\/1",

               "address2": "",

               "phone": "",

               "city": "Adamsville",

               "country": {

                   "code2": "US",

                   "code3": "USA",

                   "name": "United States of America"

               },

               "state": {

                   "code": "AL",

                   "name": "Alabama"

               },

               "company": null

           },

           "items": [

               {

                   "product_id": "1",

                   "model": "t1",

                   "name": "Test Product 1",

                   "price": 100.99,

                   "quantity": 5.5,

                   "discount_amount": null,

                   "total_price": 555.45,

                   "tax_percent": 21,

                   "tax_value": 116.64,

                   "variant_id": null,

                   "weight_unit": "kg",

                   "weight": 5.5

               }

           ]

       },

       {

           "id": "2",

           "currency_code": "USD",

           "origin": {

               "first_name": null,

               "last_name": null,

               "postcode": "35004",

               "address1": "Test, 1\/1",

               "address2": "",

               "phone": "",

               "city": "Moody",

               "country": {

                   "code2": "US",

                   "code3": "USA",

                   "name": "United States of America"

               },

               "state": {

                   "code": "AL",

                   "name": "Alabama"

               },

               "company": null

           },

           "destination": {

               "first_name": null,

               "last_name": null,

               "postcode": "35005",

               "address1": "Test address",

               "address2": "",

               "phone": "",

               "city": "Adamsville",

               "country": {

                   "code2": "US",

                   "code3": "USA",

                   "name": "United States of America"

               },

               "state": {

                   "code": "AL",

                   "name": "Alabama"

               },

               "company": null

           },

           "items": [

               {

                   "product_id": "1",

                   "model": "t1",

                   "name": "Test Product 1",

                   "price": 100.99,

                   "quantity": 5.5,

                   "discount_amount": null,

                   "total_price": 555.45,

                   "tax_percent": 21,

                   "tax_value": 116.64,

                   "variant_id": null,

                   "weight_unit": "kg",

                   "weight": 5.5

               },

               {

                   "product_id": "1",

                   "model": "t2",

                   "name": "Test product 2",

                   "price": 100.99,

                   "quantity": 5.5,

                   "discount_amount": null,

                   "total_price": 555.45,

                   "tax_percent": 21,

                   "tax_value": 116.64,

                   "variant_id": null,

                   "weight_unit": "kg",

                   "weight": 5.5,

                   "additional_fields": {

                       "dimensions_unit": "cm",

                       "height": 3.5,

                       "width": 2.15,

                       "length": 10.36

                   }

               }

           ]

       }

   ]

}

 

Once you get test request, your endpoint have to respond in JSON format

The response will differ for different shopping carts

For instance, from Shopify response structure will look like the following:

{  

  "packages_rates":[  

     {  

        "package_id":"1",

        "rates":[  

           {  

              "name":"Some name",

              "description":"Tax included an duties",

              "code":"some_name",

              "currency":"USD",

              "total_cost":10.56

           },

           {  

              "name":"Some name 2",

              "description":"Tax included an duties",

              "code":"some_name2",

              "currency":"USD",

              "total_cost":20.59,

              "min_delivery_timestamp":1558177278,

              "max_delivery_timestamp":1559177278

           }

        ]

     }

  ]

}

 

For WooCommerce the response structure will look like that:

{  

  "packages_rates":[  

     {  

        "package_id":"1",

        "rates":[  

           {

     "name": "Some name",

     "code": "some_name",

     "total_cost": 10.56,

"taxable" : true,

"tax_value": 2.12/*pass tax value*/

   },

   {

     "name": "Some name",

     "code": "some_name",

     "total_cost": 10.56,

"taxable" : false/*disable tax*/

   },

   {

     "name": "Some name",

     "code": "some_name",

     "total_cost": 10.56,

     "taxable" : true /*tax calculated using store tax rates*/

   },

...

        ]

     }

  ]

}

When we send a certain amount of packages, we expect to get the same amount of packages_rates objects. The property rates can be empty, which means there can be no rates for a certain package.

If the structure is not valid, we return an error. For example, you will get error when you pass a string in total_cost.

{

   "return_code": 109,

   "return_message": "Bad Response. Field \"rates->0->total_cost\" has wrong type. It must be decimal",

   "result": {}

}

If the callback returns 404 error code, we will not try again

If the callback returns 200 error code, we will check response validity and then return it to the store in the format that fits the store.

If the store returns 200 error code, butwith empty or incorrect response, we will wait 2 seconds and will try again.

If the callback don’t respond in 15 seconds, we will throw an error and will not try again.

{

   "return_code": 109,

   "return_message": "Callback https://www.stores.local/rates.php did not respond within 15 sec",

   "result": {}

}

If everything is ok, the new service will be created.

 

2) When the store requests rates, we unify the request and send it to callback specified when the service was created. Also, we send X-Shipping-Service-Id header.

 

If the response is not valid or the callback didn’t answer, we will log the error and increment error count of the shipping service by 1. If the next request will be successful, the count will be reduced to zero. Soon we will add the functionality that will turn off the service when the error limit is exceeded.

1. Open cPanel and find the FTP Accounts icon.

cPanel

2. Add an account to allow access to your server via FTP.

FTP Accounts

Fill in the following fields:

  • Login (it is the username for FTP access);
  • Password and Password (again) (you can use Password Generator create random passwords);

cPannel password generator

It is recommended to use strong passwords. The system will show you whether your password is strong enough.

  • Directory (it is a root directory for FTP access; it is recommended to change it for public_html);
  • Quota (it can be left without any modifications).

After you have filled in all the information necessary, you get something like this:

Add FTP Account

3. Click on Create FTP Account and have your account created.

FTP Account Created

Lately announced, all WooCommerce users are able to upgrade their stores to the new 4.0 version. However, there are profound changes considering orders.

Make sure you have performed WooCommerce upgrade correctly to allow WooCommerce and API2Cart work with your orders properly.

There are two ways to establish WooCommerce upgrade:

  1. Automated. Just press “Update Now” button and all needed changes will be done correctly.
  2. Manual. Update all WooCommerce files via your FTP client. In this case, after upload, you have to click “Run Installation” in your admin panel.

Notice that only after that, database version is updated. Otherwise, you won’t be able to view the previously placed orders in WooCommerce itself. And API2Cart will not be able to detect new WooCommerce version, thus work with new orders.

It all depends on the speed of connection and your shopping cart server, as well as the type of shopping cart. For example, the requests for Magento take more time than for the shopping cart like osCommerce. While retrieving data from shopping cart specify the necessary fields in the parameters. This will speed up the process. Do not specify the unnecessary fields, because for some fields additional requests may be sent, which increases the time of data retrieving.

Our developers are constantly improving the service to provide its fast and reliable performance.

Check the following steps to add API2Cart IPs to whitelist and prevent accidental blocking.

Instruction for WHM (Web Host Manager)

1. Login to WHM (Web Host Manager)

whm-login

2. Go to Security Center and then Host Access Control.

3. Add IP addresses over the ALL deny line in Host Access.

Host-Access-control

4. To ensure the IPs won’t be banned by cPHulk, add them to the white list.

cPHulk-whitelist

5. If there is the CSF plug-in installed, do not forget to add СSF IP to the white list as well.

СSF-IP-whitelist

Instruction for Plesk user:

  1. Login to Plesk.
  2. Click Websites & Domains tab at the top.
  3. Click SQL Whitelist Beta icon.
  4. Click Add IP, select service and type IP; Click OK.

The list of IPs you need to add:

  • 144.76.201.51
FTP access is specified for automated uploading store bridge, which will be used for connection.The bridge can be uploaded automatically, specifying FTP access or manually, saving the bridge file. For that you have to click Download in the appropriate form and upload a bridge to the root of your store and click Save.

You can use the parameter force_all (for example, product.list?api_key=<your_api_key>&store_key=<your_store_key>&start=0&count=10&params=force_all.) or use the response_fields parameter, which will contain the result field (for example, order.list?api_key=<your_api_key>&store_key=<your_store_key>&start=0&count=10&response_fields={return_code,return_message,pagination,result}).

For more information go to API2Cart Documentation.

API2Cart supports Product.list API method that helps to retrieve the following data from the shopping cart:
  1. Product ID
  2. Brand name of product
  3. Product Model
  4. Product SKU
  5. Universal Product Code
  6. Time of product creation
  7. Time of product modification
  8. Product Name
  9. Product short description
  10. Product full description
  11. Product URL
  12. Product SEO URL
  13. Product meta title
  14. Product related keywords
  15. Product meta description
  16. Product available for sale
  17. Products available for view
  18. Count of products views
  19. Count of products ordered
  20. Product Weight
  21. Product Quantity
  22. Product Price
  23. Price of products sold in large quantities (wholesale)
  24. Special price of product. ex. Regular price:100 Special Price: 99.99
  25. Price with discount based on the ordered product quantity
  26. Product category IDs
  27. Product Categories
  28. Product Images
  29. Product Options
Product.list method also includes the fields that were created in the shopping cart backend (admin section) and the specific fields, which are set for this shopping cart by default. API2Cart constantly improves its services, so we expect to deliver you all the required methods in the near future. Please CONTACT US in order to request the necessary functionality.

Connection Bridge file is what helps API2Cart users connect stores which are based on open-source shopping platforms like Magento, WooCommerce, PrestaShop, and CS-Cart. API2Cart API works directly with databases of such types of shopping platforms via a bridge file. Read more.

We use the minimum amount of code in our bridge files. Running SQL queries allows us to retrieve the data directly without running all the shopping cart code. What is more, the bridge allows us to work with the data that is not available via the platform’s API.

Benefits of the Connection Bridge:

- Speed

- Low server load, because all data is processed on our side.

- Flexibility, as we can add new methods without updating the bridge.

This special access gateway is secured by the unique signature and encryption for safe data processing. To add a store to your API2Cart account you have to set up Connection Bridge to enable data interaction.

There are three ways you can connect Bridge file:

1. Manually download the Bridge to your computer. It will be stored in a zip file named “bridge.zip”. Extract the file. It will contain the “bridge2cart” folder. Upload it to the store’s root folder via FTP client (WinSCP, FileFTP, FileZilla, CuteFTP, etc.)

If needed, the bridge file can be stored in any folder on the server, but in that case you’ll need to use parameters bridge_url (the full http url for a bridge) and store_root (absolute server path to the store root folder).

If the bridge folder is contained in the store root folder, then you don’t need to specify store_root parameter, only bridge_url.

After uploading the bridge, use account.cart.add method.

2. Automatically upload the Bridge via account.cart.add method. Use account.cart.add method specifying FTP credentials (Host, Port, Login, Password and Store Path) or use API2Cart admin panel.

3. Using plugins that can be built in the Plugin Builder section on your API2Cart account.

What is the Connection Bridge and why do I need it?

Plugin uploads the bridge and installs it to the store’s root folder. You can place the plugin on the platform app marketplace. Then, your clients will be able to install the bridge in one click.

To check if the Connection Bridge file has been installed correctly enter https://[yourstore url]/bridge2cart/bridge.php within your browser address line. If the bridge file is working correctly, you will see the following message:

“Version: xx

BRIDGE INSTALLED.”

Check the current bridge version here.

If not, please set the following permissions:

- 644 or 666 for "bridge.php", depending on your server configuration

- 755 or 777 for "/bridge2cart" folder, depending on your server configuration

Note! We strongly recommend turning off your website redirects to ensure proper functioning of the Connection Bridge file.

If you have any questions during the process of bridge installation, please read this article or contact us by email ([email protected]).

API2Cart uses Customer.list API method that help to retrieve following data:

  • Customer ID
  • Customer Group
  • Customer’s e-mail
  • Customer First Name
  • Customer Last Name
  • Time of customer creation
  • Time of customer modification
  • Customer’s login
  • Date of last login
  • Customer’s date of birth
  • Customer Status
  • Customers subscribed for newsletters
  • Customer’s Gender (male/female)
  • Link to use website
  • Customer’s fax number
  • Customer’s Company
  • Customer’s phone number
  • Customer’s Address Book

This method also includes the fields that were created in the shopping cart backend (admin section) and the specific fields, which are set for this shopping cart by default.

API2Cart constantly improves its services, so we expect to deliver you all the required methods in the near future. Please contact us in order to request necessary functionality.

Many shopping carts have an entity limit in one request. Even if it is said that there is no limitation, you should be careful and not to include too many entities in a single API request since it may negatively affect your system and client’s store performance. It is better to extract data in smaller chunks (4­-50 items), what guarantees a correct result.

Notice that:

  • BigCommerce limits the number of entities to 250 in a single API request.
  • 3DCart has no official limits set but after the various requests test it is recommended not to exceed 100 entities.
  • Shopify’s entity limit includes 250 in one request.
  • Volusion has no limitation. However, we recommend not to include more than 50-100 entities.

When the registration is completed, you are automatically redirected to your API2Cart account. In the “My Stores List” section you will find OpenCart demo store which is available for testing service’s functionality.

You can also add demo stores that can be created in the "Demostores" section of your API2Cart account. More details at Demo store in API integration

We provide a unified API to work with multiple shopping carts and marketplaces. By integrating with our API, you can integrate with different e-Commerce platforms such as Magento, PrestaShop, Bigcommerce, Shopify, OpenCart, Volusion, etc. at the same time, without any need to develop separate integration solutions for each shopping cart.

The integration works the following way - you already have your business logic module which is integrated with API2Cart. Thus, you receive a complex solution which can work with numerous platforms - hosted and self-hosted. You will have to establish connection via connection bridge or provide store access details - and you'll be able to retrieve necessary data and process it with your solution. So, API2Cart is a universal programming interface which will help you optimize eCommerce integration process.

Event takes place when a user or an owner interacts with the shopping cart for some purpose. For example, events may be considered as user registration, product adding/updating or some other changes on the store.

API2Cart cannot establish real-time synchronization with the store. However, it is feasible to sync with the store periodically (e.g. every 3 minutes) and retrieve all the necessary data in the shortest time possible.

Getting Started

To connect Shopware API to Api2Cart, you need to follow these steps:
    • Go to Settings > System in the administration panel and select Integrations. How to connect Shopware API to API2Cart?
    • Add a new integration.
    • Choose the administrator role and save the integration.
    • If you are using a non-administrator role, the following permissions are necessary for the integration to function properly.
 

{
   "permissions": [
     "system_config:read",
     "sales_channel:read",
     "currency:read",
     "sales_channel_domain:read",
     "shipping_method:read",
     "cms_page:read",
     "category:create",
     "category:read",
     "category:update",
     "category:delete",
     "category_tag:create",
     "category_tag:read",
     "category_tag:update",
     "category_tag:delete",
     "category_translation:read",
     "category_translation:update",
     "category_translation:delete",
     "product_media:read",
     "product_media:update",
     "product_media:delete",
     "product_category:read",
     "product_category:update",
     "product_category:delete",
     "product_category:create",
     "media:read",
     "media:update",
     "media:delete",
     "media:create",
     "customer:read",
     "customer:update",
     "customer:delete",
     "customer:create",
     "customer_address:create",
     "customer_address:read",
     "customer_address:update",
     "customer_address:delete",
     "customer_group:read",
     "customer_group:update",
     "customer_group:delete",
     "customer_group:create",
     "country:read",
     "country_state:read",
     "country_state_translation:read",
     "country_translation:read",
     "order_customer:read",
     "customer:read",
     "customer:create",
     "customer:update",
     "customer:delete",
     "order:read",
     "order:create",
     "order:update",
     "order:delete",
     "order_address:read",
     "order_address:create",
     "order_address:update",
     "order_address:delete",
     "order_customer:read",
     "order_customer:create",
     "order_customer:update",
     "order_customer:delete",
     "order_delivery:read",
     "order_delivery:create",
     "order_delivery:update",
     "order_delivery:delete",
     "order_delivery_position:read",
     "order_delivery_position:create",
     "order_delivery_position:update",
     "order_delivery_position:delete",
     "order_line_item:read",
     "order_line_item:create",
     "order_line_item:update",
     "order_line_item:delete",
     "order_line_item_download:read",
     "order_line_item_download:create",
     "order_line_item_download:update",
     "order_line_item_download:delete",
     "order_tag:read",
     "order_tag:create",
     "order_tag:update",
     "order_tag:delete",
     "order_transaction:read",
     "order_transaction:create",
     "order_transaction:update",
     "order_transaction:delete",
     "order_transaction_capture:read",
     "order_transaction_capture:create",
     "order_transaction_capture:update",
     "order_transaction_capture:delete",
     "order_transaction_capture_refund:read",
     "order_transaction_capture_refund:create",
     "order_transaction_capture_refund:update",
     "order_transaction_capture_refund:delete",
     "order_transaction_capture_refund_position:read",
     "order_transaction_capture_refund_position:create",
     "order_transaction_capture_refund_position:update",
     "order_transaction_capture_refund_position:delete",
     "customer_wishlist:read",
     "customer_wishlist_product:read",
     "state_machine:read",
     "state_machine_state:read",
     "state_machine_translation:read",
     "payment_method:read",
     "tax:read",
     "tax:create",
     "tax:update",
     "tax:delete",
     "tax_rule:read",
     "tax_rule:create",
     "tax_rule:update",
     "tax_rule:delete",
     "tax_rule_type:read",
     "tax_rule_type:create",
     "tax_rule_type:update",
     "tax_rule_type:delete",
     "tax_rule_type_translation:read",
     "tax_rule_type_translation:create",
     "tax_rule_type_translation:update",
     "tax_rule_type_translation:delete",
     "product:read",
     "product:create",
     "product:update",
     "product:delete",
     "product_category:read",
     "product_category:create",
     "product_category:update",
     "product_category:delete",
     "product_category_tree:read",
     "product_category_tree:create",
     "product_category_tree:update",
     "product_category_tree:delete",
     "product_configurator_setting:read",
     "product_configurator_setting:create",
     "product_configurator_setting:update",
     "product_configurator_setting:delete",
     "product_cross_selling:read",
     "product_cross_selling:create",
     "product_cross_selling:update",
     "product_cross_selling:delete",
     "product_cross_selling_assigned_products:read",
     "product_cross_selling_assigned_products:create",
     "product_cross_selling_assigned_products:update",
     "product_cross_selling_assigned_products:delete",
     "product_cross_selling_translation:read",
     "product_cross_selling_translation:create",
     "product_cross_selling_translation:update",
     "product_cross_selling_translation:delete",
     "product_custom_field_set:read",
     "product_custom_field_set:create",
     "product_custom_field_set:update",
     "product_custom_field_set:delete",
     "product_download:read",
     "product_download:create",
     "product_download:update",
     "product_download:delete",
     "product_export:read",
     "product_export:create",
     "product_export:update",
     "product_export:delete",
     "product_feature_set:read",
     "product_feature_set:create",
     "product_feature_set:update",
     "product_feature_set:delete",
     "product_feature_set_translation:read",
     "product_feature_set_translation:create",
     "product_feature_set_translation:update",
     "product_feature_set_translation:delete",
     "product_keyword_dictionary:read",
     "product_keyword_dictionary:create",
     "product_keyword_dictionary:update",
     "product_keyword_dictionary:delete",
     "product_manufacturer:read",
     "product_manufacturer:create",
     "product_manufacturer:update",
     "product_manufacturer:delete",
     "product_manufacturer_translation:read",
     "product_manufacturer_translation:create",
     "product_manufacturer_translation:update",
     "product_manufacturer_translation:delete",
     "product_media:read",
     "product_media:create",
     "product_media:update",
     "product_media:delete",
     "product_option:read",
     "product_option:create",
     "product_option:update",
     "product_option:delete",
     "product_price:read",
     "product_price:create",
     "product_price:update",
     "product_price:delete",
     "product_property:read",
     "product_property:create",
     "product_property:update",
     "product_property:delete",
     "product_review:read",
     "product_review:create",
     "product_review:update",
     "product_review:delete",
     "product_search_config:read",
     "product_search_config:create",
     "product_search_config:update",
     "product_search_config:delete",
     "product_search_config_field:read",
     "product_search_config_field:create",
     "product_search_config_field:update",
     "product_search_config_field:delete",
     "product_search_keyword:read",
     "product_search_keyword:create",
     "product_search_keyword:update",
     "product_search_keyword:delete",
     "product_sorting:read",
     "product_sorting:create",
     "product_sorting:update",
     "product_sorting:delete",
     "product_sorting_translation:read",
     "product_sorting_translation:create",
     "product_sorting_translation:update",
     "product_sorting_translation:delete",
     "product_tag:read",
     "product_tag:create",
     "product_tag:update",
     "product_tag:delete",
     "product_translation:read",
     "product_translation:create",
     "product_translation:update",
     "product_translation:delete",
     "product_visibility:read",
     "product_visibility:create",
     "product_visibility:update",
     "product_visibility:delete"
   ]
 }
 
  
  • Use the obtained Access Key ID and Secret Access Key to connect to Api2Cart, using them as parameters shopware_api_key and shopware_api_secret.
  In order to integrate with Mercado Libre, you need to create an application. To create an application, you need to follow the link https://developers.mercadolibre.com.co/devcenter/ It is necessary to fill in the information:     

Specify the callback URL and select the necessary scopes. We recommend you select all because you will need to perform all the actions again.

   

After creating an application, you will receive an App ID and a Secret Key.

 

 

Then you need to create a link

https://auth.mercadolibre.com.co/authorization?response_type=code&client_id=$APP_ID&redirect_uri=$YOUR_URL

In the end, you need to add the domain of the country for which the account is registered. If you go to the link in the browser, there will be a window where you need to grant access to the application.

 

 

After that, a redirect will be to the page whose URL should contain the code

   

Which should be used in the next query

 

where client_id - App ID, client_secret - Secret Key

As a result, you will receive access_token and refresh_token

To add a page to API2Cart, you need to specify refresh_token, App ID, and Secret Key

 

To integrate your customer's store with your business system via API2Cart, you will need to take the following steps:

  1. Register: Create an account on the API2Cart platform and fill in the necessary information that is required during registration. To create your account, you will need to contact our specialists.
  2. Get an API key: After registration, you will receive an API key, which will be used as an authentication token to make API requests. The API key will be available in the account.
  3. api2cart account
  4. Choose supported platforms: API2Cart supports more than 40 different eCommerce platforms, such as Shopify, WooCommerce, Magento, BigCommerce, Amazon, eBay, and more. You need to choose the specific platform on which the store is built.
  5. Get required settings for platform connection: For each platform you choose, you will need to provide your store URL, API credentials, and other relevant information required to add the store to API2Cart.
  6. When adding a store through the dashboard, there will be prompts for the parameters that are required to be added, as well as a link to the documentation on how to get the necessary parameters for the selected platform:

    api2cart add store

    To connect platforms (Magento, OpenCart, WooCommerce, and others), before they connect, you need to download and drop a bridge into the root of the site or install the “Bridge Connector” plugin for the corresponding platform. Also, in addition to the store URL, you need to specify the store_key parameter received after downloading or connecting the plugin. You can also set additional parameters for the connection.

    api2cart add store 2

    It is also possible to connect a store using the API2Cart API, having an API key and the necessary parameters to connect using the account.cart.add method This will establish a connection between the store and API2Cart.

  7. Connect the platform: After successfully connecting the platform to the unified API provided by API2Cart, you will be able to access various data on the store, such as products, orders, customers, categories, and more.

Parameters supported in the product.add method for Amazon SP-API

  • sku - Required. A unique identifier for the product in the seller's catalog.
  • price - Required
  • quantity - Required
  • asin, ean, gtin, upc - One of these is required. one of them is transferred.
  • category_id
  • store_id
  • product_type
  • marketplace_item_properties

asin, ean, gtin, upc parameters are identifiers that identify a product in the Amazon catalog. Every product that is in the Amazon catalog has a unique asin.

Adding a product that already exists in the Amazon catalog

To add a product that already exists in the Amazon catalog, you only need to provide the SKU, the product identifier, and the price and quantity. The quantity can be zero. Only integer values are supported. After a while, the product will appear in the seller's catalog and will have the properties of the product that was assigned to the identifier (name, description, attributes, images, etc.) as well as the seller's offer (offer), which is determined by the price and quantity.

Adding a product that does not exist in the Amazon catalog

Adding a new product that does not exist in the Amazon catalog is a more complex process, as Amazon requires filling out a large number of attributes to create a new product with an indication of the category in which the product will be placed.

Therefore, when creating a product through product.add, if the product identifier that does not yet exist in the Amazon catalog is specified, one of the parameters must be specified: category_id or product_type

To work with Amazon categories, we have added support for the category.count\list\info\find methods.

In the response of the category.list\info methods, the product_types field is displayed in additional_fields. If it contains any data, the ID of this category can be passed in the category_id parameter. Instead of the category_id parameter, you can use the product_type parameter, specifying the value of the additional_fields.product_types field (if the additional_fields.product_types field contains several values, separated by commas, then one of them).

Once one of the category_id or product_type parameters has been defined, you need to pass the attributes of the new product that is being created in the Amazon catalog. For a list of mandatory requirements for a certain product type (product_type) in Amazon, there is a JSON-schema. This JSON-schema is displayed in the category.info method in the additional_fields.category_options field (category.list this field is not displayed to save requests to Amazon).

As you can see from the image, the additional_fields.category_options object contains a WASHER object with the corresponding JSON-schema. If additional_fields.product_types contains multiple values, then JSON-schemas for all product types will be displayed.

The data from the JSON-schema fields is passed in the marketplace_item_properties parameter. This parameter is validated both on the Api2Cart side

and on the Amazon side.

The corresponding errors that will be displayed in an unsuccessful attempt of the product.add method.

If all the required properties for a certain product type are passed, the product will be created in the Amazon catalog.

Possible nuances:

Even if we received a response with return_code: 0 for the product.add method on Amazon SP-API, this does not mean that Amazon will immediately place the product in its catalog and the seller's catalog among its offers. This product may require additional adjustments in the seller's admin panel. Such products are located in the Catalog > Complete Your Drafts menu section.

which will contain product drafts and Amazon's appropriate troubleshooting guidelines for their listing of these products.

Follow these steps to connect PrestaShop API to API2Cart:

  1. Visit PrestaShop. Go to the Advanced Parameters -> Webservice
  2. PrestaShop-API-to-API2Cart

  3. Add a new webservice key
  4. PrestaShop-API-to-API2Cart2

  5. Generate Key and permit access
  6. PrestaShop-API-to-API2Cart3

  7. Enable PrestaShop's webservice
  8. PrestaShop-API-to-API2Cart-4

  9. After the previous steps, you must go to the API2Cart APP and choose the Add store option. Then, you need to choose PrestaShop API, fill in all the required fields, and press the button Add
  10. PrestaShop-API-to-API2Cart-5

To add eBay to Api2Cart, the following parameters are required:

  • ebay_client_id: eBay Client ID
  • ebay_client_secret: eBay Client Secret
  • ebay_refresh_token: eBay Refresh Token
  • ebay_environment: eBay Environment (Sandbox or Production)
  • ebay_site_id: eBay Site ID (optional, default is 0)

To obtain these parameters, you need to have a developer account on eBay.
To sign in or register, please visit the following page: https://developer.ebay.com/signin

Application Keys are available on the following page: https://developer.ebay.com/my/keys
Depending on the environment (Sandbox or Production), you will need the App ID (ebay_client_id) and Cert ID (ebay_client_secret).

To obtain the ebay_refresh_token, select User Tokens on the page that opens.

In the Get a Token from eBay via Your Application section, add the eBay Redirect URL.

Fill in the fields for the added eBay Redirect URL and click Save. Enable the OAuth Enabled checkbox for this eBay Redirect URL.

Then select OAuth and click Test Sign-In.

This will open a login page where you need to log in with your eBay seller account (for sandbox environment, you can register a test user at https://developer.ebay.com/sandbox/register).

After successful login with the seller account and confirmation of the application access request, you will be redirected to the URL specified in the Your auth accepted URL field. The redirect URL will include a code parameter in the following format:
code:v^1.1#i^1#r^1#p^3#f^0#I^3#t^Ul41Xzg6MDM5RENGM0E3NEIxNTJDQkU5QTRfMV8xI0VeMTI4NA==

This code is required to obtain the refresh token. To get the refresh token, send a POST request to https://api.ebay.com/identity/v1/oauth2/token (for production) or https://api.sandbox.ebay.com/identity/v1/oauth2/token (for sandbox) with the following parameters:

  • grant_type: authorization_code
  • redirect_uri: the URL specified in the "Your auth accepted URL" field
  • code: the code obtained (make sure it's not URL encoded)
Include basic authorization in the request as well.

Upon successful execution of the request, you will receive the refresh token, which is used as the ebay_refresh_token parameter when adding the eBay store to Api2Cart.

The ebay_environment parameter can be either Sandbox or Production, depending on the use case.

The ebay_site_id parameter (default is 0) is used to identify the eBay Site ID. More information can be found at https://developer.ebay.com/devzone/merchandising/docs/concepts/siteidtoglobalid.html.

eBay Marketplace Account Deletion/Closure Notifications Workflow

You should also pay attention to eBay Marketplace account deletion/closure. You need to subscribe to a webhook that will receive notifications about eBay Marketplace account deletions.

On the Alerts and Notifications page for the Production environment, select the Marketplace Account Deletion checkbox. You can choose to opt-out of receiving deletion notifications or subscribe to them.

To receive notifications, you need to prepare a callback that will respond with a specific response. Fill in the fields accordingly:

  • Callback URL: Fill in the URL of your callback endpoint.
  • Callback Method: Select the appropriate method (e.g., POST).
  • Request Headers: Define any required headers for the callback.
  • Request Body: Configure the request body format (e.g., JSON).

After clicking Save, eBay will send data that needs to be processed in a specific way and return a generated hash as a response.

Your callback endpoint should respond with the following JSON response:

{ "challengeResponse": "52161ff4651cb71888801b47bae62f44d7f6d0aab17e70d00f64fc84368ca38f" }

For an example, you can use a workflow on a service like https://pipedream.com/ with the appropriate code.

More details on how to do this can be found https://developer.ebay.com/marketplace-account-deletion.

After successful validation of the callback, the Send Test Notification button will become active.

Once everything is set up, eBay will start sending deletion account notifications to the specified URL.

First, you must ensure that the WooCommerce REST API is working. The following conditions must be met:



Next, you need to create API keys:



The following fields must be filled in:



In the User field, you need to specify a user who has the Administrator role. The Permissions field must be Read/Write


As a result, we will get Consumer key and Consumer secret, which are needed to add a store to the API2Cart:



To add a store in the API2Cart admin panel, fill in the fields as follows:



Troubleshooting

If you receive the following message while adding a store:


First of all, you need to check whether you have specified the correct store_url, wc_consumer_key and wc_consumer_secret.


If all the fields are correct, another reason can be that your server may be configured in such a way that it does not accept authorization tokens in request headers. You need to add the following line to the .htaccess file in the folder with the woocommerce project:


RewriteRule ^index\.php$ - [E=HTTP_AUTHORIZATION:%{HTTP:Authorization},L]


You can find additional information in the Woocommerce guide.


https://github.com/woocommerce/woocommerce/wiki/Getting-started-with-the-REST-API

To add a store from Etsy APIv3, you need etsy_client_id і etsy_refresh_token



etsy_client_id is a keystring of the App created in Development Apps. To manage your apps, go to https://www.etsy.com/developers/your-apps and add a new application.




For successful registration of the application, the store registration must be fully completed (all supporting documents sent to Etsy, connected card for payment, etc.), otherwise there may be nuances with the registration of the application or its authorization with OAuth 2.0 for further work.



Once an app is registered, Etsy reviews and approves it. After the Etsy app is approved, you can authorize it via Oauth 2.0 and perform requests.



You can do it with the help of a postman. For this, you need to create a new request and select the Oauth2.0 authorization type on the Authorization tab.




  • Token Name - an arbitrary name for the token to be used in postman
  • Grant Type - Authorization Code (With PKCE)
  • Callback URL - callback_url, which is registered for this application
  • Auth URL - https://www.etsy.com/oauth/connect
  • Access Token URL - https://api.etsy.com/v3/public/oauth/token
  • Client ID - keystring of created application (parameter etsy_client_id)
  • Code Challenge Method - SHA-256
  • Scope - following scopes can be used for the applicationі: address_r address_w billing_r cart_r cart_w email_r favorites_r favorites_w feedback_r listings_d listings_r listings_w profile_r profile_w recommend_r recommend_w shops_r shops_w transactions_r transactions_w
  • https://developer.etsy.com/documentation/essentials/authentication/ - here you can find the information about scopes
  • State - a one-time marker created specifically for this request. An arbitrary set of symbols and numbers.
  • Client Authentication - Send client credentials in body

When receiving a token, you need to confirm access permission for the application.



After successful authorization, we will receive a refresh_token, which can be used to add a store to the app.




Important! Please note that Etsy does not have a sandbox environment, and you must test your APP on a production store. Therefore, we advise you to read and strictly follow the API Testing Policy.

To integrate with Zid platform, you need to follow this instruction.

  1. In order to get the needed credentials, you need to have a Zid developer account https://partner.zid.sa/.
  2. It is necessary to create an application.

    Instruction-on-Zid-integration

    All information can be filled in English and Arabic.

    Instruction-on-Zid-integration-1

    It is required to select the necessary scopes. It is recommended to select all permissions because, in case of their change, you will need to get all tokens again. The page below contains the Client ID and Client Secret that will be needed to receive the tokens.

    Instruction-on-Zid-integration-2

    Next, you need to fill in detailed information about the application.

    Instruction-on-Zid-integration-3

    There is no need to fill in anything on the following page.

    Instruction-on-Zid-integration-4

    On this page, if necessary, you can set up a paid subscription to the application.

    Instruction-on-Zid-integration-5
  3. It is necessary to generate a URL for adding the application to the store, using the data from the previous step.
  4. https://oauth.zid.sa/oauth/authorize?client_id=&redirect_uri=&response_type=code

    After that, you need to use the mentioned URL in the browser. It is necessary to provide the access requested by the application.

    Instruction-on-Zid-integration-6

    As a result, it should redirect to the Redirect URL. You will see the code in the browser line.

    Instruction-on-Zid-integration-7
  5. You need to make a request.
  6. 
    curl -X POST \
      https://oauth.zid.sa/oauth/token \
      -H 'Content-Type: application/json' \
      -d '{
        "grant_type": "authorization_code",
        "client_id": ,
        "client_secret": ,
        "redirect_uri": ,
        "code": 
    }'
    

    The result of the request will be access_token, authorization and refresh_token.

    Instruction-on-Zid-integration-8

    To add a Zid store to API2Cart, you need to fill in the appropriate fields.

    Instruction-on-Zid-integration-9

In order to connect Magento 2 API to API2Cart, you need to do the following:

  1. Choose Integrations in the menu (System -> Integrations)

  2. magento 2 api
  3. Press the button "Add New Integration"

  4. Enter the name and data of the admin account

  5. In the API tab, set access to all entities. After that, choose "Save"

  6. Activate the integration


  7. Fill in the received data for authorization on the API2Cart APP

To integrate with Wix, you need to have a Wix developer account https://dev.wix.com/.

1. First of all, you need to create your own application.

Specify Redirect URL and App URL.

On this page, you should copy App ID and Secret Key which will be needed in the next steps.

You also need to select the necessary permissions. The minimum required permissions to add a store to API2Cart are full access to Wix Stores -> Read Stores, Wix Developers -> Manage Your App and Business Info -> Manage Consent Policy.

It is worth giving full access here. If you change permissions later, you will have to re-add the application to the store.

2. Next, you need to add an application to the store.

Here you should select added store or add the new one.


Next, the window opens with a page you specified in the App URL. You need to copy the token from the URL.

3. Here you form the URL for installing the application. Note: You need to obtain approval from the Wix and list of your application on the Wix Marketplace.

    https://www.wix.com/installer/install?code=<code>&appId=<app_id>&redirectUrl=<redirect_url></redirect_url>
    

code is the token that you copied in the previous step.

After that, you should follow this URL in a browser and click Add to Site.

Next, there will be a redirect to redirectUrl, where you need to take the code from the URL.

4. After that you need to make the following request:

curl -X POST \
  https://www.wixapis.com/oauth/access \
  -H 'Content-Type: application/json' \
  -d '{
    "grant_type": "authorization_code",
    "client_id": <APP_ID>,
    "client_secret": <APP_SECRET>,
    "code": <AUTH_CODE>
}'

As a result, you get refresh_token.

5. In order to add a store to API2Cart you need to specify the following fields:

To integrate with Shift4Shop via the REST API, you need to create and authorize an application with necessary scopes for the store. To do this, you need to have a Shift4Shop developer account https://developer.3dcart.com/".

In the dashboardhttps://devportal.3dcart.com/dashboard.asp you need to create a new application.

Choose the necessary scopes.

It is recommended to select all scopes, because after adding the store they cannot be changed.

Next, you need to authorize this application in your store.

After that, you will be redirected to a page where you will need to specify the URL of the Shift4Shop store.

Next, you will be redirected to a page where you need to accept the terms and authorize the application on the store.

After that, information about the store will appear on the application page in the dashboard.

To connect Shift4Shop to API2Cart, you need a private_key and an access_token credentials.

To connect Lightspeed store to API2Cart you need to specify the following credentials:

  • lightspeed_api_key
  • lightspeed_api_secret

There are two ways to get them:

  1. The store owners can contact the LightSpeed Customer Service department in order to receive api_key and api_secret credentials.
  2. You can develop your App and publish it on LightSpeed App Store. After that, you will get APP_KEY and APP_SECRET. Then you should specify the callback URL to which store credentials come. You can do it in the partner environment (Under ‘Apps > (APP NAME) > Success URL’).

When the store owner installs your App, credentials to the store will come to your callback URL (language, shop id, signature, timestamp, token, and cluster_id). From all the credentials you need only a token.

Now you have credentials needed for adding Lightspeed store to API2Cart.

  • lightspeed_api_key = APP_KEY
  • lightspeed_api_secret = md5(token + APP_SECRET);

More info you can find on LightSpeed docs.

Getting credentials

Create a client

Set token lifetime

To work with orders endpoint, you need to add a store with the parameters hybris_username, hybris_password.

Also, the user must belong to groups such as customersupportagentgroup and customermanagergroup.

To work with warehouses and get store data via cart.info, the admin user must also belong to a group warehouseadministratorgroup.

This can be done by simply assigning the user to a group, or if the user is already in a group and there is a need to expand its capabilities, then you can add its subgroup to the group.

If everything is done correctly, you can add a store.

The parameter hybris_websites is an array of objects in a JSON string with the following structure:

If, when trying to add a store, an error occurs due to incorrect permissions, for example, due to the absence of a group, it is necessary to delete the incorrectly generated OAuth Access Token. If you try to regenerate it, Hybris will still give the same token until it expires.

In order to connect Amazon SP-API to API2Cart account, you need to fill out the credentials, which is shown in the screenshot below: Amazon SP API store parameters The seller account that is planned to be connected to API2Cart must have an active "Professional" selling plan at Amazon.

We recommend reading the original guide from the Amazon Selling Partner API Developer Guide.

1. amazon_seller_id - can be seen in Sellercentral -> Settings -> Account Info -> Business Information -> Merchant Token. Direct link: https://sellercentral.amazon.com/sw/AccountInfo/MerchantToken/step/MerchantToken How to connect Amazon SP-API to API2Cart? 2. To determine which value should be substituted into amazon_sp_aws_region you need to use the table Selling Partner API endpoints.

Selling region AWS Region
North America (Canada, US, Mexico, and Brazil marketplaces) us-east-1
Europe (Spain, UK, France, Belgium, Netherlands, Germany, Italy, Sweden, South Africa, Poland, Saudi Arabia, Egypt, Turkey, United Arab Emirates, and India marketplaces) eu-west-1
Far East (Singapore, Australia, and Japan marketplaces) us-west-2

For example, if the seller sells in the US, you must select us-east-1.

3. To get amazon_sp_client_id and amazon_sp_client_secret you need to go to an Amazon seller account registered as a developer. If there is no such an account, you have to register a seller account, and then register in it as a developer here - Register as a developer.

Go to Developer Central and add a new client.

Develop Apps Add new client Create SP API app

Click “View” to see amazon_sp_client_id and amazon_sp_client_secret.

LWA credentials

Please note that the lifetime of amazon_sp_client_id and amazon_sp_client_secret credentials is limited to 180 days. Therefore, you should periodically update them in the "Amazon developer console" and then in our system using the account.config.update method.

4. To get the last parameter - amazon_sp_refresh_token you need to implement OAuth authentication in one of the following ways:
  1. Website workflow
  2. Marketplace Appstore workflow
  3. Self authorization

Let's consider the 3rd way, it is the most convenient when you need to quickly get an amazon_sp_refresh_token to test the work.

Autorize app Copy the refresh token 5. Now, when you have all the necessary credentials, you can add a store in API2Cart. Add store Important details:
  • Amazon restricts API access to personally identifiable information (PII), such as addresses in orders. If your app requires this data, you need to get access to it. To do this, you need to select the “Direct-to-Consumer Shipping” role and fill out the application form on Amazon Developer Profile https://sellercentral.amazon.com/developer/register

  • We do not have our app with access to personal data, and we do not plan to do so because, in this case, we would be forced to place our app on the Amazon marketplace. That will cause a white label will be impossible, and sellers must install the API2Cart app instead of your app.

  • Sometimes you may get the API2Cart response with an error "Report is not ready yet, please try again later (report_request_id=XXXXXXXXXXXX)". This is because the Amazon API, in many cases, does not provide real-time data, so API2Cart is forced to work through the Reports API. For example, when requesting "product.list" or "product.info", API2Cart requests a report and waits for its result, the maximum waiting time is 15 seconds, and if the report information is not ready during this time, the above error text will be returned. When receiving this error, you need to wait 1-5 minutes and try to repeat the request with the same parameters. Reports are cached on our side for 15 minutes. If you pass the parameter disable_report_cache=true, the cache is not used.

To connect CommerceHQ store to API2Cart and start working with the data from it, you need to register a new account.

To add the store built on CommerceHQ, you will need to have the Store URL, commercehq_api_key and commercehq_api_password.

To get commercehq_api_key and commercehq_api_password, you have to create a Private App in CommerceHQ admin panel.

For that go to Dashboard, choose Apps Store in the menu, press the button Add a Private App.

After the creation of Private App, you will see the required data for connecting CommerceHQ store to API2Cart.

There are two ways to connect Squarespace to API2Cart. To connect Squarespace to API2Cart using the first method, utilizing the squarespace_api_key parameter, follow these steps:

The first method, using the squarespace_api_key parameter, does the following:

 
  • To get squarespace_api_key:
 

It would be best if you went to the Squarespace administrator panel. Click on 'Settings,' select the 'Advanced' option from the menu, click 'Developer API Keys,' and then 'Create Key.'


If you plan to use webhooks on Squarespace, please connect using the second method. To connect Squarespace to API2Cart using the second method, utilizing squarespace_client_id, squarespace_secret, squarespace_access_token, squarespace_refresh_token parameters, follow these steps:
  1. Obtain your client_id and client_secret:

    • Fill out the form at https://partner.squarespace.com/oauth-form to get your_client_id and your_client_secret.
    • The application processing is manual and may take up to 7 days. After approval, Squarespace support will send your client_id and client_secret to the provided email.

  2. Authorize your application:

    • Go to the following link in your browser: https://login.squarespace.com/api/1/login/oauth/provider/authorize
    • Set the parameters:

      • client_id - obtained in step 1
      • redirect_uri - callback URL for receiving POST requests with data
      • scope - required scopes (e.g., website.orders, website.orders.read, website.transactions.read, website.inventory, website.inventory.read, website.products, website.products.read)
      • state - any value for CSRF protection, to be used in step 3
      • access_type - set as "offline"
      • After clicking "Allow," you will be redirected to the specified callback URL with a parameter code, which is needed for the next step.
  3. Exchange the code for tokens:

    • Make a POST request to the URL https://login.squarespace.com/api/1/login/oauth/provider/tokens with the following parameters:

      • grant_type - set to "authorization_code" for the first request and "refresh_token" for token refresh
      • code - the value obtained in step 2
      • redirect_uri - the URL to which the request with parameters will be sent
      • refresh_token - specify the refresh_token in case of token refresh and grant_type=refresh_token

  4. Use the obtained tokens in your application:

    • After step 3, you will receive a POST request to the callback URL specified in step 2 with the necessary parameters, including access_token and refresh_token.
    • Fill out the form in your application using the parameters:

      • squarespace_client_id - client_id from step 1
      • squarespace_client_secret - client_secret from step 1
      • squarespace_access_token - access_token from step 3
      • squarespace_refresh_token - refresh_token from step 3


To connect Ecwid store via API2Cart, you need to register and list your branded External APP on Ecwid App Marketplace. It will only serve to receive OAuth Access Token which is later on used to add a store to the API2Cart system.


Find out what you need to register here.


During the registration process, you will need to specify OAuth Scopes - the resources that will be accessed through Ecwid API. That will directly affect which of our methods will work through the Access Token that your App receives.


Why do you need to register your App?


If API2Cart lists its App on the Ecwid marketplace, then the store owner will install the API2Cart App, not yours


Ecwid API works only on a paid subscription. For more details click here.


However, you can specify that you need such an account for testing and the Ecwid team will provide you with a paid account for free for development and testing purposes.


If you have an Ecwid store with a paid subscription, you can get an Access Token without waiting for the approval of your APP. To do this, you need to install the "Play with Ecwid API and Postman" App.


  • 1. Install App by clicking on the link

  • 2. After installation, click “Connect with Ecwid”

  • 3. Next, you need to copy Postman collection url

  • 4. Import collection


  • 5. Copy the token from the request settings


  • 6. Add a store to API2Cart. To do this, you need to specify:

  • - Ecwid Store Id (where to get it you can find here)
  • - Ecwid Access Token (value received in step 5)
  • - Store Url (which can be found in the Ecwid Control Panel)

To connect Walmart store you will need:

  • Client Id
  • Client Secret
  • Walmart environment

Log in to the seller account and go to the API Key Management section. (Or you can switch to https://developer.walmart.com/ and log in there under your account).





There you can get access to existing keys for production and sandbox environments.



You can also generate a new pair of client id and client secret, providing full access for this key.



Use Client Id and Client Secret when adding store (walmart_client_id and walmart_client_secret parameters).

Parameter walmart_environment you can leave empty or specify the value production if the production key is used. In case the sandbox key is used be sure to specify the sandbox value for walmart_environment parameter.



To install SDK, download an SDK file for programing language you need.
To install SDK for PHP language, download the file, and run "composer install" command from it.
We don’t have composer packages.

This API is no longer supported by Etsy, use Etsy API V3 instead.

To connect Etsy account to API2Cart you’ll need to either:

  • - create an application with marketplace-wide access (needs to go through approval process by Etsy);
  • - or create private application that will have access to a single store data only.
  • Both could be done via link below:

https://www.etsy.com/developers/register

Once you register an account and you will receive following credentials for your app:

KEYSTRING

SHARED SECRET

how to integrate etsy
  1. Perform GET request to https://openapi.etsy.com/v2/oauth/request_token using Oauth 1.0 authorization

Consumer Key - KEYSTRING from step 1

Consumer Secret - SHARED SECRET from step 1

integrate etsy

Response body will look like “login_url=URL

You should urldecode URL and provide it to the account owner.

  1. Account owner follows URL, confirms application access to the account and receives VERIFICATION CODE.
etsy integration
  1. Perform GET request to https://openapi.etsy.com/v2/oauth/access_token?oauth_verifier=VERIFICATION CODE

Using Oauth 1.0 authorization

Consumer Key - KEYSTRING from step 1

Consumer Secret - SHARED SECRET from step 1

Access Token=(oauth_token from URL from step 2)

Token Secret=(oauth_token_secret from URL from step 2)

Verifier=(VERIFICATION CODE from step 2)

Response should look like

oauth_token=<ACCESS TOKEN>&oauth_token_secret=<TOKEN SECRET>

  How to connect Etsy to API2Cart?
  1. Finally you can connect Etsy store in your API2Cart account using the following parameters: KeyString - KEYSTRING from step 1

Shared Secret - SHARED SECRET from step 1

Access Token - ACCESS TOKEN from step 4

Secret Token - TOKEN SECRET from step 4

To upload the bridge to Magento Commerce cloud stores and make it available on the URL, the store developer should do the following steps:

1) Add the bridge folder to the project root directory via GIT:

2) Edit the file .magento.app.yaml:

Add the following configurations:

"/bridge2cart":

root: "/"

passthru: "/bridge.php"

index:

bridge.php

expires: -1

scripts: true

allow: true

3) Push changes to the repository and merge them to master.

First, go to the Account Manager page (https://account.demandware.com/dw/account/Home), generate dw_client_id (Client Id) and dw_api_pass (Api Password).

Please provide the API client name and password, and select your organization.

Add the necessary roles for your API client and allowed scopes.

You can find a list of scopes here:
https://developer.salesforce.com/docs/commerce/commerce-api/guide/auth-z-scope-catalog

Select "client_secret_post" for the Token Endpoint Auth Method field.

For the Redirect URIs field, specify your Redirect URI.

For a detailed guide on creating an API Сlient in Demandware, you can find it at the following link.

The API Сlient ID and password created during setup will be used as parameters "demandware_client_id" and "demandware_api_password" when adding a store on Api2Cart.

Then, add permissions for API2Cart API, so that our API could retrieve data from the store. Go to your Admin panel: Administration > Open Commerce API Setting > Select type: Shop & Data > Select context: Global

Then, specify client application-specific configurations:

For Type Shop:

Global permissions

  
  {
    "_v":"22.6",
    "clients":[
       {
          "client_id":"YOUR_CLIENT_ID",
          "allowed_origins": [

          ],
          "resources":[
             {
                "resource_id":"/products/*/prices",
                "methods":["get"],
                "read_attributes":"(**)",
                "write_attributes":"(**)",
                "config":{
                   "product.prices.price_book_ids":"PRICE_BOOK_ID_1,PRICE_BOOK_ID_2,...,PRICE_BOOK_ID_N"
                }
             },
             {
                "resource_id":"/**",
                "methods":[
                   "put",
                   "get",
                   "post",
                   "patch"
                ],
                "read_attributes":"(**)",
                "write_attributes":"(**)"
             }
          ]
       }
    ]
  }
  

Or per resource permissions

  
  {
  "_v": "22.6",
  "clients": [
    {
      "client_id": "YOUR_CLIENT_ID",
      "allowed_origins": [],
      "resources": [
        {
          "resource_id": "/products/*/prices",
          "methods": [ "get" ],
          "read_attributes": "(**)",
          "write_attributes": "(**)",
          "cache_time": 0,
          "config": {
             "_comment": "Add a comma-separated list of the price book ids currently active in the organization",
             "product.prices.price_book_ids": "REPLACE_ME_WITH_PRICE_BOOK_IDS"
          }
        },
        {
          "resource_id": "/baskets",
          "methods": [ "post" ],
          "read_attributes": "(**)",
          "write_attributes": "(**)"
        },
        {
          "resource_id": "/baskets/*",
          "methods": [ "get", "patch", "delete" ],
          "read_attributes": "(**)",
          "write_attributes": "(**)"
        },
        {
          "resource_id": "/baskets/*/billing_address",
          "methods": [ "put" ],
          "read_attributes": "(**)",
          "write_attributes": "(**)"
        },
        {
          "resource_id": "/baskets/*/coupons",
          "methods": [ "post" ],
          "read_attributes": "(**)",
          "write_attributes": "(**)"
        },
        {
          "resource_id": "/baskets/*/coupons/*",
          "methods": [ "delete" ],
          "read_attributes": "(**)",
          "write_attributes": "(**)"
        },
        {
          "resource_id": "/baskets/*/customer",
          "methods": [ "put" ],
          "read_attributes": "(**)",
          "write_attributes": "(**)"
        },
        {
          "resource_id": "/baskets/*/gift_certificate_items",
          "methods": [ "post" ],
          "read_attributes": "(**)",
          "write_attributes": "(**)"
        },
        {
          "resource_id": "/baskets/*/items",
          "methods": [ "post" ],
          "read_attributes": "(**)",
          "write_attributes": "(**)"
        },
        {
          "resource_id": "/baskets/*/items/*",
          "methods": [ "patch", "delete" ],
          "read_attributes": "(**)",
          "write_attributes": "(**)"
        },
        {
          "resource_id": "/baskets/*/notes",
          "methods": [ "post", "get" ],
          "read_attributes": "(**)",
          "write_attributes": "(**)"
        },
        {
          "resource_id": "/baskets/*/payment_instruments",
          "methods": [ "post" ],
          "read_attributes": "(**)",
          "write_attributes": "(**)"
        },
        {
          "resource_id": "/baskets/*/payment_instruments/*",
          "methods": [ "patch", "delete" ],
          "read_attributes": "(**)",
          "write_attributes": "(**)"
        },
        {
          "resource_id": "/baskets/*/payment_methods",
          "methods": [ "get" ],
          "read_attributes": "(**)",
          "write_attributes": "(**)"
        },
        {
          "resource_id": "/baskets/*/shipments",
          "methods": [ "post" ],
          "read_attributes": "(**)",
          "write_attributes": "(**)"
        },
        {
          "resource_id": "/baskets/*/shipments/*",
          "methods": [ "patch" ],
          "read_attributes": "(**)",
          "write_attributes": "(**)"
        },
        {
          "resource_id": "/baskets/*/shipments/*/shipping_address",
          "methods": [ "put" ],
          "read_attributes": "(**)",
          "write_attributes": "(**)"
        },
        {
          "resource_id": "/baskets/*/shipments/*/shipping_method",
          "methods": [ "put" ],
          "read_attributes": "(**)",
          "write_attributes": "(**)"
        },
        {
          "resource_id": "/baskets/*/shipments/*/shipping_methods",
          "methods": [ "get" ],
          "read_attributes": "(**)",
          "write_attributes": "(**)"
        },
        {
          "resource_id": "/baskets/*",
          "methods": [ "post" ],
          "read_attributes": "(**)",
          "write_attributes": "(**)"
        },
        {
          "resource_id": "/customers",
          "methods": [ "post" ],
          "read_attributes": "(**)",
          "write_attributes": "(**)"
        },
        {
          "resource_id": "/customers/auth",
          "methods": [ "post" ],
          "read_attributes": "(**)",
          "write_attributes": "(**)"
        },
        {
          "resource_id": "/customers/password_reset",
          "methods": [ "post" ],
          "read_attributes": "(**)",
          "write_attributes": "(**)"
        },
        {
          "resource_id": "/customers/*",
          "methods": [ "get", "patch" ],
          "read_attributes": "(**)",
          "write_attributes": "(**)"
        },
        {
          "resource_id": "/customers/*/addresses",
          "methods": [ "get", "post" ],
          "read_attributes": "(**)",
          "write_attributes": "(**)"
        },
        {
          "resource_id": "/customers/*/addresses/*",
          "methods": [ "get", "patch", "delete" ],
          "read_attributes": "(**)",
          "write_attributes": "(**)"
        },
        {
          "resource_id": "/customers/*/baskets",
          "methods": [ "get" ],
          "read_attributes": "(**)",
          "write_attributes": "(**)"
        },
        {
          "resource_id": "/customers/*/orders",
          "methods": [ "get" ],
          "read_attributes": "(**)",
          "write_attributes": "(**)"
        },
        {
          "resource_id": "/customers/*/password",
          "methods": [ "put" ],
          "read_attributes": "(**)",
          "write_attributes": "(**)"
        },
        {
          "resource_id": "/customers/*/payment_instruments",
          "methods": [ "get", "post" ],
          "read_attributes": "(**)",
          "write_attributes": "(**)"
        },
        {
          "resource_id": "/customers/*/payment_instruments/*",
          "methods": [ "get", "delete" ],
          "read_attributes": "(**)",
          "write_attributes": "(**)"
        },
        {
          "resource_id": "/orders",
          "methods": [ "post" ],
          "read_attributes": "(**)",
          "write_attributes": "(**)"
        },
        {
          "resource_id": "/orders/*",
          "methods": [ "get", "patch" ],
          "read_attributes": "(**)",
          "write_attributes": "(**)"
        },
        {
          "resource_id": "/orders/*/notes",
          "methods": [ "get", "post" ],
          "read_attributes": "(**)",
          "write_attributes": "(**)"
        },
        {
          "resource_id": "/orders/*/payment_methods",
          "methods": [ "get" ],
          "read_attributes": "(**)",
          "write_attributes": "(**)"
        },
        {
          "resource_id": "/orders/*/payment_instruments",
          "methods": [ "post" ],
          "read_attributes": "(**)",
          "write_attributes": "(**)"
        },
        {
          "resource_id": "/order_search",
          "methods": [ "post" ],
          "read_attributes": "(**)",
          "write_attributes": "(**)"
        },
        {
          "resource_id": "/products/*",
          "methods": [ "get" ],
          "read_attributes": "(**)",
          "write_attributes": "(**)"
        },
        {
          "resource_id": "/products/*/availability",
          "methods": [ "get" ],
          "read_attributes": "(**)",
          "write_attributes": "(**)",
          "cache_time": 0
        },
        {
          "resource_id": "/site",
          "methods": [ "get" ],
          "read_attributes": "(**)",
          "write_attributes": "(**)"
        },
        {
          "resource_id": "/categories/*",
          "methods": [ "get" ],
          "read_attributes": "(**)",
          "write_attributes": "(**)"
        }
      ]
    }
  ]
}
  
For Type Data

Global permissions


{
  "_v":"22.6",
  "clients":[
     {
        "client_id":"YOUR_CLIENT_ID",
        "resources":[
           {
              "resource_id":"/**",
              "methods":[
                 "put",
                 "get",
                 "post",
                 "patch"
              ],
              "read_attributes":"(**)",
              "write_attributes":"(**)"
           }
        ]
     }
  ]
}

Or per resource permissions

      
      {
  "_v": "22.6",
  "clients": [
    {
      "client_id": "YOUR_CLIENT_ID",
      "resources": [
        {
          "resource_id": "/sites",
          "methods": [
            "get"
          ],
          "read_attributes": "(**)",
          "write_attributes": "(**)"
        },
        {
          "resource_id": "/sites/**",
          "methods": [
            "get"
          ],
          "read_attributes": "(**)",
          "write_attributes": "(**)"
        },
        {
          "resource_id": "/catalog_search",
          "methods": [
            "post"
          ],
          "read_attributes": "(**)",
          "write_attributes": "(**)"
        },
        {
          "resource_id": "/product_search",
          "methods": [
            "post"
          ],
          "read_attributes": "(**)",
          "write_attributes": "(**)"
        },
        {
          "resource_id": "/products/*",
          "methods": [
            "get",
            "patch"
          ],
          "read_attributes": "(**)",
          "write_attributes": "(**)"
        },
        {
          "resource_id": "/products/*/variant_search",
          "methods": [
            "post"
          ],
          "read_attributes": "(**)",
          "write_attributes": "(**)"
        },
        {
          "resource_id": "/products/*/variations",
          "methods": [
            "get"
          ],
          "read_attributes": "(**)",
          "write_attributes": "(**)"
        },
        {
          "resource_id": "/products/*/variation_attributes",
          "methods": [
            "get"
          ],
          "read_attributes": "(**)",
          "write_attributes": "(**)"
        },
        {
          "resource_id": "/customer_lists/**",
          "methods": [
            "get",
            "post"
          ],
          "read_attributes": "(**)",
          "write_attributes": "(**)"
        },
        {
          "resource_id": "/inventory_lists/*",
          "methods": ["patch"],
          "read_attributes": "(**)",
          "write_attributes": "(**)"
        },
        {
          "resource_id": "/inventory_lists/*/product_inventory_records/*",
          "methods": ["patch", "put", "get"],
          "read_attributes": "(**)",
          "write_attributes": "(**)"
        },
        {
           "resource_id":"/system_object_definitions/**",
           "methods":["get", "put" , "patch", "post", "delete"],
           "read_attributes":"(**)",
           "write_attributes":"(**)"
        }
      ]
    }
  ]
}
      
    
You need to specify store admin username and password, no API key is required.

WooCommerce Plugin Installation

To add a plugin or an extension on WooCommerce:
  1. Go to your admin panel and click on ‘Plugins” menu -> "Add New"
  2. Choose API2Cart Connector and click “Install Now” button.
  3. After downloading the plugin, click “Activate Plugin” to get it rolling.
The plugin tab should now appear on your admin panel.


Magento Plugin Installation

To add a plugin or an extension on Magento 1:
  1. Go to the Magento admin panel and navigate System -> Magento connect -> Magento connect manager.
  2. Login with the same credentials you use to access your admin panel.
  3. Then under Direct package file upload you can Upload package file. Click the Choose File button, select the extension .tgz file, and click Upload. To ensure the plugin is installed correctly, use the PHP version that matches the Magento version requirements.
  4. If the version of PHP conflicts with the version of Magento in use, we suggest that you should install it using the following instructions:
    • Unzip the archive and upload the files to the server.
    • Clear the Magento cache by going into System-> Cache Management, selecting all in the list, choosing the Refresh option in the dropdown menu, and finally clicking Submit.
  5. Go to System-> Configuration and find API2CART Bridge in the menu on the left.

The installation process will begin and show a message when it’s finished. You can optionally click on “Refresh” button to see whether the extension is installed or not.


PrestaShop Plugin Installation

To perform the installation:
  1. Login into your Prestashop admin panel.
  2. Go to the module tab and click “Add a module from my computer”
  3. In “Module file” box click “Browse” button.
  4. Select module *.zip file from your computer.
  5. Complete the process by pressing “Upload this module” button.

The page will reload, and you should see the new module in a list of your modules.


Cs-Cart Plugin Installation

To perform the installation:
  1. Login into your Cs-Cart admin panel.
  2. Click on the navigation "Add-ons" -> "Manage Add-ons".
  3. Click on the "+" button to upload the plugin.
  4. In the dialog box that appears, click on the "Local" option to download the plug-in *.zip file
  5. Click the "Upload & install" to upload the installation.

After a successful installation, in the "Add-ons" page you will see the API2Cart plugin.


OpenCart Plugin Installation


Note: After any of these plugins is successfully installed, the store owner needs to give the information on his unique store key to B2B provider for the proper work through the API.

Categories API methods allow you to manage categories in the store. It is possible to:

  • Create - add categories
  • Read - retrieve list, info, find
  • Update - update
  • Delete - delete

Run category.add method, to add customers to the store, and provide all necessary parameters.

public function apiAdd($params)
{
  $params = array(
    'name' => 'Shoes'
  );

  return $api->request('category.add', $params);
}

If you want to update the category, call category.list method to get category id.

public function apiList($params)
{
  $params = array(
    'start'  => 2,
    'count'  => 2,
  );
  
  return $api->request('category.list', $params);
}

When you get your category id, you are able to perform category.update method.

public function apiUpdate($params)
{
  $params = array(
    'id'         => 20,
    'avail'      => 'false',
    'meta_title' => 'meta title for category'
  );
    
  return $api->request('category.update', $params);
}

If you want to assign your product to some category, simply call product.list method and category.list method to get product id and category id.

After that, run category.assign method.

public function apiAssign($params)
{
  $params = array(
    'product_id'     => 69,
    'category_id'    => 20,
  );
    
  return $api->request('category.assign', $params);
}

For more methods jump into documentation.

Customer API methods allow you to manage customers in the store. It is possible to:

  • Create - add customers
  • Read - retrieve list, info, find
  • Update - update
  • Delete - delete

Run customer.add method, to add customers to the store, and provide all necessary parameters.

public function apiAdd($params)
{
  $params = array(
    'email'      => '[email protected]',
    'first_name' => 'John',
    'last_name'  => 'Smith',
  );

  return $api->request('customer.add', $params);
}

If you want to update the customer, call customer.list method  to retrieve customer id.

public function apiList($params)
{
  $params = array(
    'start' => 0,
    'count' => 5
  );

  return $api->request('customer.list', $params);
}

When you get your customer id, you are able to perform customer.update method.

public function apiUpdate($params)
{
  $params = array(
    'id'         => 11,
    'first_name' => 'Jack',
    'last_name'  => 'Smith',
  );    

  return $api->request('customer.update', $params);
}

For more methods jump into documentation.

Order API methods allow you to manage orders in the store. It is possible to:

  • Create - add orders
  • Read - retrieve list, info, find
  • Update - update
  • Delete - delete

Run order.add method to add orders to the store, and provide all necessary parameters.

public function apiAdd($params)
{
  $params = array(
    'customer_email'         => '[email protected]',
    'order_status'           => 'Complete',
    'bill_first_name'        => 'Adam',
    'bill_last_name'         => 'Smith',
    'bill_address_1'         => 'Green str. 35',
    'bill_city'              => 'Chicago',
    'bill_postcode'          => '12345',
    'bill_state'             => 'IL',
    'bill_country'           => 'US',
    'total_price'            => '23.56',
    'order_item_id_1'        => 8,
    'order_item_name_1'      => 'Bag',
    'order_item_model_1'     => 'bag_01',
    'order_item_price_1'     => 89,
    'order_item_quantity_1'  => 3,
  );

  return = $api->request('order.add', $params);
}

If you want to update an order, call order.list method to get order id.

public function apiList($params)
{
  $params = array(
    'start'  => 0,
    'count'  => 5,
    'params' => 'id,customer,status'
  );

  return $api->request('order.list', $params);
}

When you get your order id, you are able to update comment and order status by calling  order.update method

public function apiUpdate($params)
{
  $params = array(
    'order_id'     => 11,
    'order_status' => 'Pending',
    'comment'      => 'Order comment'
  );

  return $api->request('order.update', $params);//returns the number of updated orders
}

Note: You are able to count orders in the store by calling order.count method.

For more methods jump into documentation.

Product API methods allow you to manage products in the store. It is possible to:

  • Create - add products
  • Read - retrieve list, info, find
  • Update - update
  • Delete - delete

Run product.add method, in order to add new products to the store, and provide all necessary parameters.

public function apiAdd($params)
{
  $params = array(
    'name'        => 'Bag',
    'model'       => 'bag_01',
    'description' => 'This is new product',
    'price'       => 99.9,
    'quantity'    => 12,
    'manufacturer'=> 'Test',
  );

  return $api->request('product.add', $params);
}

Note: You may add image, tax, manufacturer, option, variant or other info to the product by calling these methods: product.image.add, product.variant.add, product.manufacturer.add, product.tax.add, product.option.add, product.option.value.add, product.option.assign, product.option.value.assign

For more methods jump into documentation.

If you want to update the product, call product.list method  to retrieve product id.

public function apiList($params)
{
  $params = array(
    'start'  => 0,
    'count'  => 50,
    'params' => 'id,name,price',
  );

  return $api->request('product.list', $params);
}

When you get product id, you are able to update price and inventory(quantity) for this product, simply calling product.update method.

public function apiUpdate($params)
{
  $params = array(
    'id' => 69,
    'price' => 89,
  );

  return $api->request('product.update', $params);
}

Note: You may update variant, image and product option value by calling the following methods: product.variant.update, product.image.update, product.option.value.update

For more API methods visit our documentation.

The process of connecting the store to API2Cart depends on the type of shopping cart. There are two major types: Hosted (3dcart, Volusion, Shopify) and Open-source (PrestaShop, WooCommerce, OpenCart, etc.) Get the type of carts here.

For Hosted Carts

You are able to add your stores in 2 ways:

  1. Through the interface in your account. Simply press ‘Add store button’, paste your store’s URL, select type, valid API key and API password.
  2. By calling account.cart.add method.  In order to add store correctly, provide all necessary parameters that are described in documentation.
public function apiCreate()
{
  $params = array(
    'cart_id'      => 'BigcommerceApi',
    'store_url'    => 'https://example.com',
    'verify'       => 'false',//set this param=false for test only
    'store_key'    => 'ab37fc230bc5df63a5be1b11220949be',//for self-hosted cart only
    'AdminAccount' => 'admin',
    'ApiPath'      => 'https://example.com/api/v1',
    'ApiKey'       => '6b89704cd75738cb0f9f6468d5462aba',
  );

  return $api->request('account.cart.add', $params);
}

Note: Store key is generated automatically for hosted carts (Shopify, Bigcommerce, Volusion, etc.)

For Open-source Carts.

When talking about Open-source platforms, it’s worth mentioning that API2Cart connects to such type of solutions through connection bridge.

You are able to add your stores in 2 ways:

  1. Through the interface in your account. Simply press ‘Add store button’, paste your store’s URL, select type, download bridge and paste it to your store’s root folder via FTP client. (Read our FAQ on what is the connection bridge and why do you need it)
  2. By calling these methods:
  • Call cart.bridge method from which you could get store_key.
  • Call bridge.download method and pass store_key which was generated in cart_bridge.
  • Upload the bridge to the root ftp server folder.
  • Call account.cart.add method and paste previously generated store_url.
Volusion requires API Key (URL) and Encrypted Password
  1. Login to the Admin Area of your Volusion store.
  2. Click the Inventory tab followed by the Import/Export link at the top, below the Inventory tab.
  3. Click the Volusion API tab.
  4. Point to Get Help in the top right and click Get help with this page.
  5. Click the Volusion API Integration Help link at the bottom of the page.
  6. Select to view instructions for Generic Orders and expand the URL with Query Stringsection at the bottom. The Encrypted Password can be found in the URL displayed, between the Encrypted Password= and &API_Name.
Please note, you must have a Volusion Gold plan or higher in order to have API access for your store.

To connect Shopify store to API2Cart you need to specify the following credentials:

Required credentials:

  1. shopify_api_key + shopify_api_password - for connection via Private app
  2. shopify_access_token - for connection via Custom app
  3. shopify_shared_secret - is needed to work with Live Shipping Rates or Webhooks

Note. Private apps are deprecated and can`t be created as of January 2022. Custom apps are used instead

To receive shopify_access_token you need to create a Custom app. There are 2 ways:

Let's consider the 2nd way.

  In Shopify admin  

Open Apps section and press Develop apps for your store.

Press Allow custom app development.

Next step - Create Custom app.

Choose scopes and permissions to the store data.

Webhook Subscriptions Event version - leave without any changes.

Next, open Overview tab and Install the app.

Access token and shared secret will be available in API credentials section.

Please note that Access token could be seen just once. If you lose it you will need to create another App.

Use needed credentials to connect the store.

You can find additional information in Shopify guide.

https://shopify.dev/apps/auth/admin-app-access-tokens.

If you are interested in oAuth authorization proceed with the first way via Partner dashboard. Here is a Shopify guide https://shopify.dev/apps/auth/oauth/getting-started .

To access personal data such as customer names, addresses, email addresses, and phone numbers, you must have a plan other than Basic.

1. Log into the store.

2. Copy store URL from your browser address bar.

3. Go to Advanced Settings.

4. Click API Accounts.

5. Click Create API Account.

6. Type the name of the user in the Username box.

7. There you will find API Path box. Copy the part of the value that placed between api.bigcommerce.com and /v3/ as shown.

8. Click Content - modify, Checkout Content - modify, Customers - modify, Customers Login - login, Information Settings - modify, Marketing - modify, Orders - modify, Order Transactions - modify, Products - modify, Themes - modify, Carts - modify.

9. Click the Save button. There will appear a window BigCommerce API Credential with Client ID and Access Token.

10. Add BigCommerce store to your API2Cart account, using credential you've got in steps 2, 7 and 9.

This API is no longer supported by 3DCart, use Shift4Shop instead.


You need to retrieve API Key from your 3DCart (Shift4Shop) admin account.
  1. Log in to your admin panel and go to Settings -> General -> Store Settings.
  2. Go to the Advanced Settings section located at the far bottom of the page.
  3. Click on Change Settings next to API Settings.
  4. Check Enable API if it isn't enabled yet.
  5. Copy API User Key and save changes.
API key is a code that consists of 32 characters and is generated by API2Cart for each user individually. In order to get it, you need to register your account first. After that service will automatically provide you with API key. You can find it on the page with your stores list.
 
This parameter is generated automatically for hosted carts (Shopify, Bigcommerce, Volusion, etc.). If you are working with self-hosted carts (Magento, WooCommerce, OpenCart, etc.) follow these steps:
  • Call cart_bridge method from which you could get store_key.
  • Call bridge_download method and pass store_key which was generated in cart_bridge.
  • Upload the bridge to the root ftp server folder.
  • Call cart_create method and paste previously generated store_url.
All described above is concerned to manual way of bridge upload.
API key is a code generated by API2Cart for each user individually. It provides you with access rights on the API. You will use your API key to establish connection between service and stores you are going to work with. Personal API Key helps us to identify users who perform API requests, allows to track and control API usage.

When signing up for API2Cart account, you are asked to provide name, e-mail address, password.

When adding a new store, you are asked to provide API key and store URLs. You may also be asked to provide your direct database connection to speed up the process. We take appropriate security measures to protect your information. Find out more about our Privacy Policy.

To start working with the service you have to register an account, sign in and connect store by providing the required information (store’s URL, API credentials, etc). Also, you need to install the plugin if you have to work with open-source platforms. Quick Demo tour will provide you with more detailed information on how to start working with the service.

In most cases the system automatically defines the prefix of specific shopping cart and uses it. However if you have several shopping carts of one type, the automatic defining will not work. In this case you should use the method account.cart.add and define the prefix of your shopping cart with a parameter db_tables_prefix.

In order to see all additional parameters that are unique for your shopping cart, call product.list API method with the params=force_all parameter. Or set the necessary fields separated by comma in parameter "params" (params=length,depth).

In order to integrate your client’s store with your business system via API2Cart you will have to:
    • provide API Key/Token and password if it is a hosted platform
    • or use bridge files to establish connection to other carts.

See the full list below (in alphabetic order):

 
3dcart API Key
Amazon MWS Auth Token, Seller ID, Marketplace IDs, Secret Key, Access Key ID
AceShop Bridge files uploaded to store folder
AspDotNetStorefront Admin User and Password
Bigcommerce Client ID, Access Token, Context
CS-Cart Bridge files uploaded to store folder / plugin
CubeCart Bridge files uploaded to store folder
Demandware API Client ID, API Password, User Name, User Password, Environment Type
Ebay App ID, Shared Secret, Refreshed Token, Environment, Global ID
Ecwid Store ID, Access Token
Etsy KeyString, Shared Secret, Access Token, Secret Token
Gambio Bridge files uploaded to store folder
Hybris Client ID, Client Secret, User Name, User Password
Interspire Bridge files uploaded to store folder
JooCart Bridge files uploaded to store folder
LightSpeed eCommerce API Key, API Secret
Loaded Commerce Bridge files uploaded to store folder
Magento Bridge files uploaded to store folder / plugin
MijoShop Bridge files uploaded to store folder
Neto API Key, User Name
OpenCart Bridge files uploaded to store folder
osCMax Bridge files uploaded to store folder
osCommerce Bridge files uploaded to store folder
Oxid Bridge files uploaded to store folder
Pinnacle Cart Bridge files uploaded to store folder
PrestaShop Bridge files uploaded to store folder / plugin
Shop-Script Premium Bridge files uploaded to store folder
Shopify API Key, API Password, Access Token, Shared Secret
Shopware Bridge files uploaded to store folder
Squarespace API Key
TomatoCart Bridge files uploaded to store folder
Ubercart Bridge files uploaded to store folder
VirtueMart Bridge files uploaded to store folder
Volusion Login and API Password
Walmart Client ID, Client Secret
WooCommerce Bridge files uploaded to store folder / plugin
WebAsyst Shop-Script Bridge files uploaded to store folder
WPEcommerce Bridge files uploaded to store folder
XCart Bridge files uploaded to store folder
Xtcommerce Bridge files uploaded to store folder
Xtcommerce Veyton Bridge files uploaded to store folder
Zencart Bridge files uploaded to store folder

For more information about how to get your API Key/Token follow this link.

You can use the parameter verify=false to skip the validation.

Glossary

It is one of the FTP parameters that defines a precise store location at the host.

It is the main folder of the store where its files are located. An 'index.php' file located among them is usually but not necessarily a marker that this very folder is the root folder.
It is a unique key generated when a bridge is downloaded. It is used to access a store located on a shopping cart.
These e-Commerce platforms store your shop data for you, so you do not have to pay for a server.
It is a message sent by your service to get/manipulate store data.
It is a process of assembling smaller pieces into a unity that functions as one. In the light of your cooperation with API2Cart, integration is performed to obtain the ability to connect to numerous shopping carts in order to retrieve and manipulate store data such as orders, products, categories, customers, etc. according to the specific needs of your e-Commerce business software.
These are shopping platforms that do not store your e-commerce website data, which means that you will have to pay for this service.
These are used to upload a bridge in order to specify connection with self-hosted carts.
It is a  response string carrying certain data.
It is a shop created online to run the dealing on the web.
These are requests going through simultaneously in a split second.
It is a software that provides all the necessary tools for merchants to build their e-stores.
See a detailed explanation here.
It is a string of characters that is given in order to identify the user. In other words, it acts as a form of authentication, which leads to access control.
They represent the operations you can perform over the store data. For instance, the order.add API method indicates that you can add orders made by your clients.
It is a string of characters that is used to get access to the shop's data. Read more in order to find the credentials needed to add the store. These credentials are unique for each hosted platform.
To avoid the complexity of technical explanations, it is what makes it possible for you, as a businessman, to retrieve and manipulate the necessary store data from shopping cart databases.

Pricing & Billing

You do not need to pay VAT if you are a business with a valid VAT ID. To avoid being charged VAT, enter your VAT id in the corresponding field. If you have paid the VAT, send an e-mail to [email protected] with your order id and VAT id specified. Our accounting department will refund you the VAT.

Please note that private individuals cannot have VAT refunded. Provide the legal body details when making the payment to avoid being charged VAT.

According to international rules, every API2Cart account refill is accompanied with tax collection. To be more specific, PayPro, the company handling taxes from API2Cart, collects VAT from Canada and EU countries.

For EU, VAT is collected according to the international rules of VAT and then sent to the state the purchaser is from.

For Canada, the GST/HST is collected and paid to the Government of Canada. However, according to the Canadian law, you can get a compensation from the State by providing GST number of the company receiving the payment, i.e. API2Cart. Please, contact our support team via a chat or email ([email protected]) to request the GST number.

Every EU country has its specific VAT percentage that can be seen after the country is chosen. You do not need to pay VAT if you are a business with a valid VAT ID. If you have paid the vat, provide us with your valid VAT id and our accounting department will refund you the VAT. Private individuals cannot have VAT refunded.

Fixed VAT is collected with each recurring payment. Here you can find more information about VAT rates for different countries. The residences of the countries not included into the list won’t be charged while refilling API2Cart account. After each successful payment, PayPro is sending an invoice to the customers email indicated on the order page.

Find out how to avoid paying VAT.
API2Cart has 5 pricing plans to fit the needs and budget of different size business. You can find prices on the dedicated pricing page.  You can contact our Customer Success Manager at [email protected] to discuss which plan to choose or any other details.  
To subscribe to the API2Cart service and pay for it, please contact our Customer Success Manager at [email protected].
We provide 30-day free trial to test API2Cart API. No functionality is hidden. Create an account and see how API2Cart will work for your business. You can add your stores or try service functionality on our demo store. Check API2Cart documentation to find out more about the methods you can use.

Security and Privacy

API2Cart doesn’t store any data, but only transmit it via API requests. The scheme below shows data flow between our customers’ software, API2Cart and shopping platforms.

You can disable automatic notifications from API2Cart in the two different ways:

  1. Click the right mouse button on the notification and choose “disable notifications from www.api2cart.com”.
  2. Go to API2Cart website and press on the lock symbol in the address field. Choose “Use global default” from the drop down list.

disable-notifications

API2Cart service takes serious measures to protect our clients personal and store information.

Sensitive data is protected from unauthorized access. We guarantee not to share your personal account data and keep it confidential. Terms of service security and information protection are provided by our Privacy Policy.

Bridge file. To be able to work with some shopping platforms, it is necessary to install the connection bridge to the store’s root folder. The list of all the platforms that require the bridge installing you can find here.

A connection bridge is the most secure method to access store data. The data received will be used only for providing the work of API2Cart API methods. API2Cart doesn't collect and save any data retrieved from the stores. As an exception, we save the credentials needed for making API requests to the stores. Also, we are caching the store configuration (e.g., the list of supported currencies, time zones, etc.) as it helps reduce the number of requests to the stores.

Here, you can find a video tutorial on how to download bridge for bridge platforms easily. A similar tutorial for all the rest platforms can be found here. The bridge can be downloaded automatically with the help of the bridge.download method. More details related to the bridge you can find here.

Technical side of bridge security

IMPORTANT: For each request from API2Cart to the bridge, we form the signature based on request parameters and srore_key. When the request comes to the bridge, the signature is calculated on the bridge and compared with the one sent from API2Cart. If it matches then the request will be performed. Otherwise, the bridge will present an error. That is the way we do the authorization.

FTP credentials are used to upload a bridge in order to specify connection with self-hosted platforms. When adding a store to API2Cart using FTP, credentials are used only for bridge uploading, and they are not stored in our system.

In order to investigate issues and troubleshoot reported problems or install the connection bridge file, API2Cart support technicians may require access to the online store, web server and database.

It is recommended to temporarily change the password of the admin account before providing a technician with access to your online store. Once your issue is resolved, you should change the passwords of all the provided accounts as soon as possible. The technician will make it clear to you what access exactly we need to solve your problem. More details on which accesses API2Cart techs may ask can be found here.

We highly respect API2Cart customers’ privacy. We have adopted all the necessary measures so that you could be confident about how we protect and manage personal information. For more information please get familiar with the Privacy Policy of our company.

In order to investigate issues and to troubleshoot reported problems, or download the connection bridge file API2Cart support technicians may require access to online store, web server and database.

We understand that this kind of access information is sensitive, and are best kept to a need-to-know basis. With this in mind, we will only require access to your online store where it is absolutely necessary.

We have taken every precaution to ensure that our systems which store access information is highly secure. However, there are additional precautions that we advise our customers take before providing us with access credentials.

In all cases where we require access to online store, we will make it clear to you exactly what access is needed, and why.

Summary of this FAQ

  • When providing a technician with access to your online store, it is always best to change the password of admin account been provided with a random password temporarily, while the issue is being traced by us.
  • Once your issue has been resolved, you should change the passwords of all provided accounts as soon as possible.
  • In all issues that require access to your online store, the technician will make it clear to you exactly what access we need.

Access to your online store

Depending on the task which needs to be performed, an API2Cart technician may require access to your online store. We strongly advise you to change the password of Admin/FTP accounts being provided with a random password for API2Cart support for the duration of the issue, with only the essential permissions to your online store.

  • Change the existing password of user/staff account with a random and complex password.
  • Once your issue has been resolved, you should change its password as soon as possible.

Access to a web-online store administrator account

More often than not, we will require access to an administrator account on your online store. Follow the steps outlined in the Access to your online store section of this article.

Access to an FTP or SSH account

In order to investigate the problems, API2Cart support may require access to the files of your online store installation. Follow the steps outlined in the Access to your online store section of this article.

Make sure that this account is a user-level account that has access to the directory in which your online store is installed, unless our technician specifically requests an unrestricted access account (see below).

'Root' (unrestricted access) to your server

If a technician asks for 'root access' to your server (a root account with unrestricted permissions), please do not be alarmed. Only in the rarest of cases will we ask for such access - i.e. when our ability to diagnose and resolve your issue absolutely requires it (such as generating or monitoring server logs, or making server configuration changes).

When providing us with root/unrestricted access to your server, it is imperative that you follow the temporary account creation steps outlined in the Access to your online store section of this article.

Firewalls and IP based authentication

If your systems are protected by IP address authentication (e.g. if you have a firewall), please let us know and we will provide you with the list of our office IP addresses to allow through.

API2Cart service requires bridge downloading to establish integration with your software and retrieve data from stores. A connection bridge is the most secure method to access store data. The data you retrieve will be used only in order to perform certain API2Cart methods.
API2Cart service takes serious measures to protect our customers' personal and store data.  
Sensitive data is protected from unauthorized access. We guarantee that we will not share your personal account information and will keep it totally confidential. Terms of service security and information protection are provided by Privacy Policy.

Troubleshooting

Web browsers request for information from the server, and when it is performed, it sends an Accept header. In case if the server is not able to send that data in the requested format in the Accept header, then the server sends the 406 Not Acceptable error.

 

Reasons

The 406 error can appear accordingly to your mod_security rule on the server. Mod_security is a security module of Apache web server, usually permitted automatically on all hosting profiles. In case if a site, page or even function violates one of the rules, server can send the 406 error.

 

How to Prevent

You can turn mod_security off. Also, there is a possibility to disable a specific rule or each domain individually. Thus, if you wish to disable mod_security, go to mod_security using modsec manager plugin in control panel.

 

Note: There may not be the option of turning mod_security on/off in your cPanel or dedicated servers. In such cases, use command line using SSH or contact tech support to enable/disable this option.

 
shopping cart integration via API2Cart  

With API2Cart shopping platforms integration is easy

Integrate once, save 4-8 weeks and thousands of dollars on each integration.

Never worry about maintaining separate connections.

 

Redirection errors (3xx)

300 Multiple Choices - indicates multiple options for the resource that the client may follow.

301 Moved Permanently - This and all future requests should be directed to the given URL

302 Found - required the client to perform a temporary redirect (the original describing phrase was "Moved Temporarily")

303 See Other - The response to the request can be found under another URL using a GET method.

304 Not Modified - Indicates that the resource has not been modified since the version specified by the request headers If-Modified-Since or If-Match

306 Switch Proxy - No longer used.Originally meant "Subsequent requests should use the specified proxy."

307 Temporary Redirect (since HTTP/1.1) - In this case, the request should be repeated with another URL; however, future requests should still use the original URL.

308 Permanent Redirect - the request, and all future requests should be repeated using another URL.

Client errors (4xx)

400 Bad Request - the request cannot be fulfilled due to bad syntax.

401 Unauthorized - similar to 403 Forbidden, but specifically for use when authentication is required and has failed or has not yet been provided.

402 Payment Required - reserved for future use.

403 Forbidden - the request was a valid request, but the server is refusing to respond to it.

404 Not Found - the requested resource could not be found but may be available again in the future.

405 Method Not Allowed - a request was made of a resource using a request method not supported by that resource

406 Not Acceptable - the requested resource is only capable of generating content not acceptable according to the Accept headers sent in the request.

407 Proxy Authentication Required - the client must first authenticate itself with the proxy.

408 Request Timeout - the server timed out waiting for the request.

409 Conflict - indicates that the request could not be processed because of conflict in the request, such as an edit conflict in the case of multiple updates.

410 Gone - indicates that the resource requested is no longer available and will not be available again.

411 Length Required - the request did not specify the length of its content, which is required by the requested resource.

412 Precondition Failed - the server does not meet one of the preconditions that the requester put on the request.

413 Request Entity Too Large - the request is larger than the server is willing or able to process.

414 Request-URI Too Long - the URI provided was too long for the server to process.

415 Unsupported Media Type - the request entity has a media type which the server or resource does not support.

416 Requested Range Not Satisfiable - the client has asked for a portion of the file, but the server cannot supply that portion.

417 Expectation Failed - the server cannot meet the requirements of the Expect request-header field.

418 I'm a teapot - this code was defined in 1998 as one of the traditional IETF April Fools' jokes, in RFC 2324, Hyper Text Coffee Pot Control Protocol, and is not expected to be implemented by actual HTTP servers.

419 Authentication Timeout - not a part of the HTTP standard, 419 Authentication Timeout denotes that previously valid authentication has expired.

420 Method Failure - not part of the HTTP standard, but defined by Spring in the HttpStatus class to be used when a method failed.

420 Enhance Your Calm - not part of the HTTP standard, but returned by version 1 of the Twitter Search and Trends API when the client is being rate limited.

422 Unprocessable Entity - the request was well-formed but was unable to be followed due to semantic errors.

423 Locked - еhe resource that is being accessed is locked.

424 Failed Dependency - еhe request failed due to failure of a previous request.

425 Unordered Collection - defined in drafts of "WebDAV Advanced Collections Protocol", but not present in "Web Distributed Authoring and Versioning (WebDAV) Ordered Collections Protocol".

426 Upgrade Required - the client should switch to a different protocol such as TLS/1.0.

428 Precondition Required - the origin server requires the request to be conditional.

429 Too Many Requests - the user has sent too many requests in a given amount of time.

431 Request Header Fields Too Large - the server is unwilling to process the request because either an individual header field, or all the header fields collectively, are too large.

440 Login Timeout - a Microsoft extension. Indicates that your session has expired.

444 No Response - used in Nginx logs to indicate that the server has returned no information to the client and closed the connection.

449 Retry With - a Microsoft extension. The request should be retried after performing the appropriate action.

450 Blocked by Windows Parental Controls - a Microsoft extension. This error is given when Windows Parental Controls are turned on and are blocking access to the given webpage.

451 Unavailable For Legal Reasons - defined in the internet draft "A New HTTP Status Code for Legally-restricted Resources".

451 Redirect - used in Exchange ActiveSync if there either is a more efficient server to use or the server cannot access the users' mailbox.

494 Request Header Too Large - Nginx internal code similar to 431 but it was introduced earlier.

495 Cert Error - Nginx internal code used when SSL client certificate error occurred to distinguish it from 4XX in a log and an error page redirection.

496 No Cert - Nginx internal code used when client didn't provide certificate to distinguish it from 4XX in a log and an error page redirection.

497 HTTP to HTTPS - Nginx internal code used for the plain HTTP requests that are sent to HTTPS port to distinguish it from 4XX in a log and an error page redirection.

499 Client Closed Request - used in Nginx logs to indicate when the connection has been closed by client while the server is still processing its request, making server unable to send a status code back.

Server Errors (5xx)

500 Internal Server Error - a generic error message, given when an unexpected condition was encountered and no more specific message is suitable.

501 Not Implemented - the server either does not recognize the request method, or it lacks the ability to fulfill the request.

502 Bad Gateway - the server was acting as a gateway or proxy and received an invalid response from the upstream server.

503 Service Unavailable - the server is currently unavailable (because it is overloaded or down for maintenance).

504 Gateway Timeout - the server was acting as a gateway or proxy and did not receive a timely response from the upstream server.

505 HTTP Version Not Supported - the server does not support the HTTP protocol version used in the request.

506 Variant Also Negotiates - transparent content negotiation for the request results in a circular reference.

507 Insufficient Storage - the server is unable to store the representation needed to complete the request.

508 Loop Detected - the server detected an infinite loop while processing the request.

509 Bandwidth Limit Exceeded - this status code is not specified in any RFCs. Its use is unknown.

510 Not Extended - further extensions to the request are required for the server to fulfill it.

511 Network Authentication Required - the client needs to authenticate to gain network access.

520 Origin Error - this status code is not specified in any RFCs, but is used by Cloudflare's reverse proxies to signal an "unknown connection issue between CloudFlare and the origin web server" to a client in front of the proxy.

521 Web server is down - this status code is not specified in any RFCs, but is used by Cloudflare's reverse proxies to indicate that the origin web server refused the connection.

522 Connection timed out - this status code is not specified in any RFCs, but is used by Cloudflare's reverse proxies to signal that a server connection timed out.

523 Proxy Declined Request - this status code is not specified in any RFCs, but is used by Cloudflare's reverse proxies to signal a resource that has been blocked by the administrator of the website or proxy itself.

524 A timeout occurred - this status code is not specified in any RFCs, but is used by Cloudflare's reverse proxies to signal a network read timeout behind the proxy to a client in front of the proxy.

598 Network read timeout error - this status code is not specified in any RFCs, but is used by Microsoft HTTP proxies to signal a network read timeout behind the proxy to a client in front of the proxy.

599 Network connect timeout error - this status code is not specified in any RFCs, but is used by Microsoft HTTP proxies to signal a network connect timeout behind the proxy to a client in front of the proxy.

API2Cart uses Bridge file that enables API interaction for some shopping carts. This folder should be uploaded to store directory via FTP client. In some cases a user may not have enough rights to change the corresponding folder. In order to fix it you have to change folder permissions:
  • 644 or 666 for "bridge.php", depending on your server configuration;
  • 755 or 777 for "/bridge2cart" folder, depending on your server configuration.
In order to update an entity please specify the attribute you want to change, for example &price=14.99. You can find the list of supported attributes in our Documentation section.

You can report a bug or request a new feature by contacting us. You are also welcome to contact our Customer Success manager at [email protected] in case of any issues.

In this case there are several simple steps that you can follow:

  • Re-upload a Connection Bridge file to store’s root folder using an FTP client. Click here for more info.
  • Change Store Key manually: in bridge2cart folder open config.php file with any kind of text editor (i.e. Notepad). In the bottom of the file you will be able to change your Store Key that you can find at https://www.api2cart.com/app/stores.
  • If none of the methods above are working don’t hesitate to contact us.
API2Cart can’t disconnect the store while you perform API request to it. If you see this error for a long time, most likely you are using a program, that makes periodical requests to the store through API2Cart. Please disable it before disconnecting. If you don’t know which specific program performs requests or how to disable it feel free to contact our Support Team.
The store belongs to another account. Please make sure there are no typing errors in the store_key parameter. If you have multiple API2Cart accounts, probably you’re using an api_key from a wrong one.
Double-check the root folder where your store is located. If the shop is placed in the subdomain of your site please indicate the subdomain folder. In case you can't solve this issue feel free to contact API2Cart Support Team.
API2Cart already has a store with the same URL. If you don’t see it in your profile, please contact us.
Probably your firewall blocks our IP or the site is down. If you can access the site from your browser it means that your website is working. In this case, please, contact your hosting provider and ask him to add the API2Cart IP to the white list. If it still doesn’t help, contact our Support Team.

Check if you enter the correct APi Key. It can be found on the store management page https://www.api2cart.com/app/stores as well as here https://www.api2cart.com/app/profile.

Probably, you didn’t enter one of required parameters. To see the list of all the required and optional parameters, visit our Documentation section.

This kind of error comes when API2Cart can’t create the entity due to shopping cart restriction. For example, if you’re trying to create a user with e-mail that is already registered.

We can’t create an entity with identified parameters, because of the SQL UNIQUE constraint - a row with a field which is meant to be unique already exists.
Please, specify the API method you would like to proceed working with. You can find the list of supported API methods here.

There are two possible reasons for that. Either you have entered the incorrect store_key or the store doesn’t exist. The list of available stores can be found on the following page: https://www.api2cart.com/app/stores.

Please, make sure you have passed an ID of the entity in the API request. Feel free to contact API2Cart Support Team in case if you still have any issues.

If this error occurs, it means that the cart or cart version, where the store is located, is not supported by API2Cart.

Another reason of the error formation is the database structure that has been changed because of the third-party module.

If this error occurs, contact your server administrator to enable Base 64 support.

If this error occurs:

  • Check whether API2Cart IP is in the server’s firewall white list and restart the requests. (How to add IP to white list)
  • Your server’s characteristics isn’t suitable for particular shopping cart. Optimize your server configurations to establish proper work.
  • Increase the server’s RAM

If this error occurs:

  • Check whether API2Cart IP is in the server’s firewall white list and restart the requests. (How to add IP to white list)
  • Your server’s characteristics isn’t suitable for particular shopping cart. Optimize your server configurations to establish proper work.
  • Increase the server’s RAM

If this error occurs:

  • Check whether API2Cart IP is in the server’s firewall white list and restart the requests. (How to add IP to white list)
  • Your server’s characteristics isn’t suitable for particular shopping cart. Optimize your server configurations to establish proper work.
  • Increase the server’s RAM

Webhooks

There is a special API method account.failed_webhooks that allows you to list recently failed webhooks. Please note that information about failed webhooks is stored for 24 hours.

If a particular e-commerce platform does not support native webhooks (e.g Magento, Opencart), webhooks functionality is emulated by querying store data periodically. Currently, this period is set to 300 seconds, so you can expect 5 minutes delay when receiving webhooks from some platforms.

We suggest to try one of the publicly available webhook testing services, for example requestbin.com, webhook.site or similar. Use url generated by the service as webhook callback. If webhook still doesn’t work, contact our support for further assistance

Please check if your callback URL accepts POST requests. It should also return 200 OK HTTP response or else webhook will be considered as “failed” and after several attempts will be dropped.