AWS Marketplace Catalog API

The AWS Marketplace Catalog API service provides an API interface to manage AWS Marketplace for your AWS Organization or AWS account. For approved sellers, you can programmatically manage your products, including the self-service publishing capabilities on the AWS Marketplace Management Portal. For private marketplace administrators, you can programmatically manage your private marketplace.

Catalog API actions allow you to view and update your existing product programmatically. You can automate your product update process by integrating the AWS Marketplace Catalog API with your AWS Marketplace product build or deployment pipelines. You can also create your own applications on top of the Catalog API to manage your products on AWS Marketplace. You can manage the products that users in your AWS account or AWS organization can see and purchase through your private marketplace.

The AWS Marketplace Catalog API service provides standard AWS API functionality. You can directly use the Rest APIs described here (see Getting Started with AWS to learn more about AWS application development), or you can use one of the AWS SDKs to access an API that's tailored to the programming language or platform that you're using. For more information, see AWS SDKs.

Catalog API entities

AWS Marketplace entities are containers of data which serve different business purposes. Entities are categorized by types. Each entity type encapsulates data related to a specific business domain (for example, a product or a seller account).

To simplify this paradigm, entities are designed with some level of commonality in their structures. As a result, introducing a new business domain does not require you to learn a completely new structure.

General structure

The general structure of any entity is:

• A named type

• An identifier

• A facet

Versioning

Every named type has a type and version associated with it, for example, EntityProduct@1.0. The type (EntityProduct) represents the classification of the content. The version (1.0) represents the structure of EntityProduct.

The version gives you details about the structure of the entity.

• Existing entities won't be restructured without changing the version. Additions of optional new fields will result in a minor version update.

• Any feature that fundamentally changes the structure of a type leads to a major version update. Examples include:

  • Removing a field

  • Renaming a field (different name for the same semantic)

  • Changing the semantic of an existing field (for example, changing the expected type)

• A major version update can retain a subset of facets from the previous version.

• Users are provided notifications and documentation for new versions.

Identifier

Each entity represents a unique thing within a business domain. To identify the unique thing, we use an identifier associating an EntityId with a RevisionId, for example, prod-ad8EXAMPLE651@12345. In this example, the EntityId is prod-ad8EXAMPLE651 and the RevisionId is 12345. Every successful change request to the entity will update the revision.

• Each entity is uniquely identified by its EntityId, which is the key to globally distinguish one entity from another.

• Each published revision of an entity has a RevisionId. The revisionId, along with the EntityId, distinguish one published revision from another.

• AWS Marketplace generates EntityIds and RevisionIds.

You can use the DescribeEntity action to find the details and the Identifier with the most recent revisionId.

The RevisionId is an optional part of requests to StartChangeSet (see Working with change sets). If you include a RevisionId, then the request to StartChangeSet will fail with a ValidationException if the RevisionId is not the latest revision of the entity. This allows you to implement optimistic locking in your application.

Note

When you include a RevisionId that is not the latest revision, the ValidationException message includes the latest RevisionId.

If you omit the RevisionId, the request is performed on the latest revision of the entity automatically.

Warning

Two requests to change the same object could result with one request overwriting the changes of the other request, as the second request rewrites data changed by the first request. Using RevisionIds in your requests prevents this issue by not allowing a change to an earlier revision to overwrite the current revision.

Facets

A facet is a logical grouping of attributes. An entity usually includes several facets which represent different aspects of the entity. The attributes within a facet have the following properties.

• Each attribute has a unique name within the scope of the container it belongs to.

• Attributes can be of a simple type (string, integer, or floating number).

• Attributes can be of a complex type (container/structure or array).

Product entity

A software product you own and list on AWS Marketplace is represented by a product entity. Product entities have different types. Regardless of type, product entities have some common facets in addition to product type specific facets. The example below is an example of common facets: Description, PromotionalResources, RegionAvailability, and SupportInformation. Details is an example of a product type specific facet.

{
  "Details": "{\"Description\":{}, \"PromotionalResources\":{}, \"RegionAvailability\":{}, \"SupportInformation\":{}}",
  "EntityArn": "arn:aws:aws-marketplace:us-east-1:0123456789012:AWSMarketplace/Entity-Type/9EXAMPLE-0123-4567-8901-74eEXAMPLE47",
  "EntityIdentifier": "9EXAMPLE-0123-4567-8901-74eEXAMPLE47@23",
  "EntityType": "Entity-Type@1.0",
  "LastModifiedDate": "2019-07-31T21:59:39Z"
}

The Details facet is a string that includes JSON. For more information, see Working with the Details attribute).

Supported AWS Regions

You can access the AWS Marketplace Catalog API from the US East (N. Virginia) AWS Region with the following endpoint.

catalog.marketplace.us-east-1.amazonaws.com

Working with change sets

When using the Catalog API, you perform many actions by creating change requests. You do this by creating and working with change sets. A change set is a list of change entities, each of which represents a request for a change in AWS Marketplace. You can make changes to the products that you provide (as a seller), or to the private marketplace that you maintain (as a buyer).

Note

Although you can request multiple changes in a single change set, you cannot request conflicting changes. You will receive a ResourceInUseException error in this case. This is true even across multiple change sets. If you want to modify the same entity twice, the safest way is to make a request, wait for it to complete, and then request the next change. For information about using RevisionIds in this case, see Identifier).

There are four actions that allow you to work with change sets:

• StartChangeSet – Requests a set of changes. The changes are added to a queue and processed.

• DescribeChangeSet – Gets the details of a set of changes, including the status of the request. The statuses include:

  • PREPARING – Getting ready to apply the changes.

  • APPLYING – In the process of making the requested changes.

  • SUCCEEDED – Request was completed successfully.

  • CANCELED – Request was canceled by the user.

  • FAILED – Request was completed unsuccessfully. Further details are available in the response.

• ListChangeSets – Gets a list of the change sets that are currently in process.

• CancelChangeSet – Requests a change set be canceled. Changes can only be canceled while in the PREPARING status.

A typical workflow is to request a change with StartChangeSet, and then use the returned ChangeSetId to poll the DescribeChangeSet action until the change is complete.

Note

When polling or working with change sets programmatically, you must follow the Service limits.

After your change is complete, you can use ListEntities to find the entity that you created or modified (and its associated EntityID). You can then use DescribeEntity with the EntityID to get details about it.

For more information about working with Change Requests in the console for sellers, see Creating a change request in the AWS Marketplace Seller Guide.

Working with the Details attribute

The Details attribute of the StartChangeSet operation is a string value. It's contents are JSON objects. To put a JSON object into a string attribute, you must convert the object to strings by escaping all JSON control characters, and removing linebreaks.

For example, if you are using the StartChangeSet operation with UpdateProcurementPolicy to disable requests from users in your private marketplace, you would make a request like the following.

POST /StartChangeSet HTTP/1.1
Content-type: application/json

{
   "Catalog": "AWSMarketplace",
   "ChangeSet": [ 
      { 
         "ChangeType": "UpdateProcurementPolicy",
         "Details": "<string>",
         "Entity": {
            "Type": "Experience@1.0",
            "Identifier" : "exp-1234example@5"
         }
      }
   ]
}

In this case, the JSON object that you use for the Details attribute would look like the following

{
    "Configuration": {
        "PolicyResourceRequests": "Deny"
    }
}

After converting this JSON object to a single line string, it would look like the following.

"{\"Configuration\" : {\"PolicyResourceRequests\" : \"Deny\"}}"

With this string, you can create the full change set request, as follows.

POST /StartChangeSet HTTP/1.1
Content-type: application/json

{
   "Catalog": "AWSMarketplace",
   "ChangeSet": [ 
      { 
         "ChangeType": "UpdateProcurementPolicy",
         "Details": "{\"Configuration\" : {\"PolicyResourceRequests\" : \"Deny\"}}",
         "Entity": {
            "Type": "Experience@1.0",
            "Identifier" : "exp-1234example@5"
         }
      }
   ]
}

Generally, examples in this API reference will show the JSON object already converted to a string. In some cases, more complicated samples with new lines are included for understandability.