Product Type Definitions API v2020-09-01 Use Case Guide

sfgoods AmazonSPAPI

# What is the Product Type Definitions API?

Using the Selling Partner API for Product Type Definitions (Product Type Definitions API), you can search and retrieve Amazon product type definitions. Amazon product type definitions describe the attribute and data requirements for items in the Amazon catalog using JSON Schema.

For more details on the JSON Schema format provided by the Product Type Definitions API, see the accompanying Amazon Product Type Definition Meta-Schema (v1) (opens new window) documentation.

See the Product Type Definitions API Reference (opens new window) for details about API operations and associated data types and schemas.

Key Features

JSON Schemas: The Product Type Definitions API provides JSON Schemas that describe the seller-agnostic requirements for a given Amazon product type. This includes the data format, attribute constraints (i.e. required, length, maximum, etc.), and conditionally applied attribute constraints (i.e. if batteries are included, what type of battery).
Compatible with Open-Source Libraries: The JSON Schemas provided can be used with widely available open-source and commercial libraries, applications, and services to understand data requirements, create data mappings, generate user interfaces, and validate listings data before submission to Amazon.
Localized Presentation Details: The JSON Schemas provided include display labels and descriptions for attributes in any supported locale for any marketplace.

Terminology

JSON Schema: JSON Schema is a vocabulary that allows you to annotate and validate JSON documents. See json-schema.org (opens new window) for more details.
Meta Schema: Meta schemas describe the vocabulary used by JSON Schema documents. For example, Amazon product type schemas include vocabulary for selectors and editable. This vocabulary is described in a meta schema, enabling libraries and applications to understand and validate JSON data based on these extensions to the standard JSON Schema vocabulary.
Product Type: An Amazon product type is a hierarchical categorization of items in the Amazon catalog. Item data requirements are tied to the associated product type of the item.

# Tutorial: Search Available Product Type Definitions

Use this tutorial to search and identify Amazon product types available in the Product Type Definitions API for a given Amazon marketplace and type of selling partner account.

Prerequisites

To complete this tutorial, you will need:

Authorization from the selling partner for whom you are making calls. See the Selling Partner API Developer Guide (opens new window) for more information.
Approval for the Product Listing role in your developer profile.
The Product Listing role selected in the App registration page for your application.

# Step 1. Search Product Type Definitions

Call the searchDefinitionsProductTypes (opens new window) operation to search product types available in the Product Type Definitions API.

Request Parameters

Parameter	Example	Description	Required
`marketplaceIds`	`ATVPDKIKX0DER`	Comma-delimited list of Amazon marketplace identifiers. See the Selling Partner API Developer Guide for the list of Amazon marketplace identifiers.	Yes
`keywords`	`LUGGAGE`	Comma-delimited list of keywords to search available product types by name. Default: When no keywords are provided, the complete list of available product types is provided.	No

Example Request

GET https://sellingpartnerapi-na.amazon.com/definitions/2020-09-01/productTypes
	?marketplaceIds=ATVPDKIKX0DER
	&keywords=LUGGAGE

1
2
3

Response

A successful response includes the following:

Name	Example	Description
`productTypes`	See Example Response	List of product types that match the search request.
`name`	`LUGGAGE`	Name of the Amazon product type.
`marketplaceIds`	`ATVPDKIKX0DER`	List of Amazon marketplace identifiers for which the product type is available (within the requested marketplace identifiers).

Example Response

{
  "productTypes": [
    {
      "name": "LUGGAGE",
      "marketplaceIds": [
        "ATVPDKIKX0DER"
      ]
    }
  ]
}

1
2
3
4
5
6
7
8
9
10

# Tutorial: Retrieve a Product Type Definition

Use this tutorial to return Amazon product type definitions and related schemas from the Product Type Definitions API for a given selling partner, Amazon product type, and Amazon marketplace.

Prerequisites

To complete this tutorial, you will need:

Authorization from the Selling Partner for whom you are making calls. See the Selling Partner API Developer Guide (opens new window) for more information.
Approval for the Product Listing role in your developer profile.
The Product Listing role selected in the App registration page for your application.

# Step 1. Retrieve Product Type Definition

Call the getDefinitionsProductType (opens new window) operation to retrieve an Amazon product type definition from the Product Type Definitions API.

Request Parameters

Path Parameters

Parameter	Example	Description	Required
`productType`	`LUGGAGE`	Name of the Amazon product type. Type: string	Yes

Query Parameters

Parameter	Example	Description	Required
`sellerId`	`AXXXXXXXXXXXXX`	The selling partner identifier. When provided, seller-specific requirements and values are populated within the product type definition schema, such as brand names associated with the selling partner. Type: string	No
`marketplaceIds`	`ATVPDKIKX0DER`	Comma-delimited list of Amazon marketplace identifiers. Note: This parameter is limited to one marketplaceId at this time See the Selling Partner API Developer Guide for the list of Amazon marketplace identifiers. Type: < string > array(csv)	Yes
`productTypeVersion`	`U1d1eorqMs3U=`	Version of the Amazon product type definition to retrieve. Prerelease versions of product type definitions may be retrieved with `RELEASE_CANDIDATE`. If no prerelease version is currently available, the `LATEST` live version will be provided. Default: `LATEST` Type: string	No
`requirements`	`LISTING`	Name of the requirements set to retrieve requirements for. `LISTING` - Requirements inclusive of product facts and sales terms. `LISTING_OFFER_ONLY` - Requirements inclusive of sales terms only. `LISTING_PRODUCT_ONLY` - Requirements inclusive of product facts only. Default: `LISTING` Type: enum (Requirements)	No
`requirementsEnforced`	`ENFORCED`	Identifies if the required attributes for a requirements set are enforced by the product type definition schema. Non-enforced requirements enable structural validation of individual attributes without all required attributes being present (such as for partial updates). `ENFORCED` - Required attributes are enforced by the schema. `NOT_ENFORCED` - Required attributes are not enforced by the schema. Default: `ENFORCED` Type: enum (RequirementsEnforced)	No
`locale`	`en_US`	Locale to retrieve presentation details (labels and descriptions) for. Defaults to the primary locale of the Amazon marketplace. Default: `DEFAULT` Type: enum (Locale)	No

Example Request

GET https://sellingpartnerapi-na.amazon.com/definitions/2020-09-01/productTypes/LUGGAGE
	?marketplaceIds=ATVPDKIKX0DER
	&requirements=LISTING
	&locale=en_US

1
2
3
4

Response

A successful response includes the following:

Name	Example	Description
`metaSchema`	"metaSchema": { "link": { "resource": "https://...", "verb": "GET" }, "checksum": "QFQDmPwMARO7vwMEyLhOtw==" }	Link to retrieve the Amazon Product Type Definition Meta-Schema document (valid for 7 days). Checksum provided for comparison with previously retrieved documents. Type: SchemaLink
`schema`	"schema": { "link": { "resource": "https://...", "verb": "GET" }, "checksum": "TBr8ubaxXrUyay9hmxUXUw==" }	Link to retrieve the JSON Schema document for the Amazon product type definition (valid for 7 days). Checksum provided for comparison with previously retrieved documents. Type: SchemaLink
`requirements`	`LISTING`	Name of the requirements set the Amazon product type definition applies to. `LISTING` - Requirements inclusive of product facts and sales terms. `LISTING_OFFER_ONLY` - Requirements inclusive of sales terms only. `LISTING_PRODUCT_ONLY` - Requirements inclusive of product facts only. Default: `LISTING` Type: enum (Requirements)
`requirementsEnforced`	`ENFORCED`	Identifies if the required attributes for a requirements set are enforced by the product type definition schema. Non-enforced requirements enable structural validation of individual attributes without all required attributes being present (such as for partial updates). `ENFORCED` - Required attributes are enforced by the schema. `NOT_ENFORCED` - Required attributes are not enforced by the schema. Default: `ENFORCED` Type: enum (RequirementsEnforced)
`propertyGroups`	"propertyGroups": { "offer": { "title": "Offer", "description": "Product Offer", "propertyNames": [ "purchasable_offer" ] } }	Property groups define logical segmentations of properties described in the Amazon product type definition JSON Schema document. This segmentations can be used for grouping properties in user interfaces, identifying purpose, and so forth. Property groups are informational only and do not impact the structure or formatting of data. Type: < string, PropertyGroup > map
`locale`	`en_US`	The locale of the presentation details (labels and descriptions) provided in the Amazon product type definition JSON Schema document. Type: enum (Locale)
`marketplaceIds`	`ATVPDKIKX0DER`	Amazon marketplace identifiers for which the Amazon product type definition is applicable. Type: < string > array
`productType`	`LUGGAGE`	The name of the Amazon product type that this product type definition applies to. Type: string
`productTypeVersion`	`U8L4z4Ud95N16tZlR7rsmbQ==`	Version of the Amazon product type definition. Type: (ProductTypeVersion)

Example Response

{
  "metaSchema": {
    "link": {
      "resource": "https://...",
      "verb": "GET"
    },
    "checksum": "QFQDmPwMARO7vwMEyLhOtw=="
  },
  "schema": {
    "link": {
      "resource": "https://...",
      "verb": "GET"
    },
    "checksum": "TBr8ubaxXrUyay9hmxUXUw=="
  },
  "requirements": "LISTING",
  "requirementsEnforced": "ENFORCED",
  "propertyGroups": {
    "offer": {
      "title": "Offer",
      "description": "Product Offer",
      "propertyNames": [
        "fulfillment_channel_availability",
        "purchasable_offer",
        "condition_type",
        "condition_note",
        "list_price",
        "product_tax_code",
        "merchant_release_date",
        "merchant_shipping_group",
        "max_order_quantity",
        "gift_options",
        "main_offer_image_locator",
        "other_offer_image_locator_1",
        "other_offer_image_locator_2",
        "other_offer_image_locator_3",
        "other_offer_image_locator_4",
        "other_offer_image_locator_5"
      ]
    },
    "images": {
      "title": "Images",
      "description": "Physical imagess or URL's",
      "propertyNames": [
        "main_product_image_locator",
        "other_product_image_locator_1",
        "other_product_image_locator_2",
        "other_product_image_locator_3",
        "other_product_image_locator_4",
        "other_product_image_locator_5",
        "other_product_image_locator_6",
        "other_product_image_locator_7",
        "other_product_image_locator_8",
        "swatch_product_image_locator"
      ]
    },
    "shipping": {
      "title": "Shipping",
      "description": "Information to determine shipping and storage of your product (e.g., package dimensions, weight, volume)",
      "propertyNames": [
        "item_dimensions",
        "item_package_dimensions",
        "item_package_weight"
      ]
    },
    "variations": {
      "title": "Variations",
      "description": "Variations that product will use",
      "propertyNames": [
        "parentage_level",
        "child_parent_sku_relationship",
        "variation_theme"
      ]
    },
    "safety_and_compliance": {
      "title": "Safety & Compliance",
      "description": "Information to indicate product compliance, hazardous materials, and legal and safety warnings (e.g., lithium batteries, choking hazards, Consumer Product Safety Information Act (CPSIA))",
      "propertyNames": [
        "country_of_origin",
        "warranty_description",
        "batteries_required",
        "batteries_included",
        "battery",
        "num_batteries",
        "number_of_lithium_metal_cells",
        "number_of_lithium_ion_cells",
        "lithium_battery",
        "supplier_declared_dg_hz_regulation",
        "hazmat",
        "safety_data_sheet_url",
        "item_weight",
        "ghs",
        "supplier_declared_material_regulation",
        "california_proposition_65",
        "pesticide_marking"
      ]
    },
    "product_identity": {
      "title": "Product Identity",
      "description": "Information to uniquely identify your product (e.g., UPC, EAN, GTIN, Product Type, Brand)",
      "propertyNames": [
        "item_name",
        "brand",
        "supplier_declared_has_product_identifier_exemption",
        "externally_assigned_product_identifier",
        "merchant_suggested_asin",
        "item_type_keyword",
        "item_type_name",
        "model_number",
        "manufacturer"
      ]
    },
    "product_details": {
      "title": "Product Details",
      "description": "Information and characteristics to describe the product to support search, browse and detail page content (e.g., bullets, product features, model, style name)",
      "propertyNames": [
        "product_description",
        "bullet_point",
        "generic_keyword",
        "special_feature",
        "style",
        "department",
        "target_gender",
        "age_range_description",
        "material",
        "outer",
        "fabric_type",
        "lining_description",
        "number_of_items",
        "number_of_wheels",
        "wheel",
        "model_name",
        "color",
        "size",
        "size_map",
        "part_number",
        "compliance_media"
      ]
    }
  },
  "locale": "en_US",
  "marketplaceIds": [
    "ATVPDKIKX0DER"
  ],
  "productType": "LUGGAGE",
  "productTypeVersion": {
    "version": "U8L4z4Ud95N16tZlR7rsmbQ==",
    "latest": true,
    "releaseCandidate": false
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

# Step 2. Retrieve Schema Documents

In the previous step, the retrieved Amazon product type definition includes details about the Amazon product type and links to retrieve the meta schema and product type schema documents. The links provided are valid for 7 days.

Schema documents can be retrieved programmatically with a standard HTTP client or manually with a web browser.

Important Note: The Amazon product type definition JSON Schema document references the meta schema by name. Some JSON Schema libraries attempt to resolve meta schema names online via the web, which the Amazon Product Type Definition Meta-Schema (v1) (opens new window) does not support. These libraries should be configured to use a downloaded copy of the meta schema instead. See the accompanying Amazon Product Type Definition Meta-Schema (v1) (opens new window) documentation for more details.

# Frequently Asked Questions

This documentation covers common questions and details for the Product Type Definitions API. For questions or concerns not covered by this documentation, contact Selling Partner API support or create an issue on the GitHub repository.

# How Fresh are Amazon Product Type Definitions?

Unless specifying a previous productTypeVersion, the Amazon product type definitions always describe the latest up-to-date Amazon catalog requirements.

# Are All Amazon Product Types Available with the Product Type Definitions API?

No.

Amazon is continually expanding support for new and existing Amazon product types in the Product Type Definitions API. For the up-to-date list of available Amazon product types, use the Product Type Definitions API.

# What Version of JSON Schema is Used?

Amazon product type definition JSON Schemas extend JSON Schema 2019-09 (opens new window). See the accompanying Amazon Product Type Definition Meta-Schema (v1) (opens new window) documentation for more details.

# How Will Future Versions of JSON Schema be Leveraged?

As future versions of JSON Schema are adopted by the Product Type Definitions API, they will be accompanied by a new version release of the Product Type Definitions API and Amazon Product Type Definition Meta-Schema (opens new window).

Future versions of JSON Schema will not be adopted by existing versions of the Product Type Definitions API or Amazon Product Type Definition Meta-Schema (opens new window).

# Do Product Type Definition JSON Schemas Include Custom Vocabulary?

Most Amazon catalog requirements are described utilizing standard JSON Schema 2019-09 (opens new window) vocabulary. However, there are a few requirements that necessitate extending JSON Schema with custom vocabulary. See the accompanying Amazon Product Type Definition Meta-Schema (v1) (opens new window) documentation for more details.

# Am I Required to Implement Validation for Custom Vocabulary?

No.

The Amazon Product Type Definition Meta-Schema (v1) (opens new window) uses custom vocabulary to fully describe Amazon catalog requirements. Validating data with custom data enables you to prevent most listings-related issues from occurring before submitting to Amazon. However, it is up-to-you to implement such validation. Without implementing this validation, submitting data to Amazon may produce listings-related issues after submission to Amazon.

# Do I Need Custom Code to Use JSON Schemas?

Yes.

The amount of custom code depends upon your application. Example scenarios:

Using Open-Source Library with Validation of Custom Vocabulary: Leveraging an open-source library to handle most JSON Schema validation means custom code is necessary to retrieve schemas from the Product Type Definitions API, to implement validation of custom vocabulary, and to integrate with the open-source library.
Using Open-Source Library without Validation of Custom Vocabulary: Leveraging an open-source library to handle most JSON Schema validation means custom code is necessary to retrieve schemas from the Product Type Definitions API and to integrate with the open-source library.

# What Open-Source Libraries are Available?

Dozens of open-source libraries and implementations are available to validate data, render user interfaces, and generate code. See JSON Schema Implementations (opens new window) for a full list.

Amazon does not directly support or endorse any specific open-source or commercial libraries and implementations. Examples provided in this documentation are for reference only.

# What Examples are Available for Validating Data with Product Type Schemas?

The accompanying Amazon Product Type Definition Meta-Schema (v1) (opens new window) documentation includes example integrations with open-source libraries to validate data with custom vocabulary in .NET (C#), Java, and JavaScript (Node.js).

# How Do I Report Issues with Amazon Product Type Definitions?

For issues specific to the Product Type Definitions API or the content of Amazon product type definition JSON Schemas, contact Selling Partner API support (opens new window).

Product Pricing API v0 Reports API v2020-09-04

Amazon Selling Partner API - spapi.cyou

Choose mode