Struct SpapiClient

pub struct SpapiClient { /* private fields */ }

Implementations

impl SpapiClient

pub fn new(config: SpapiConfig) -> Result<Self>

Create a new SP API client with the given configuration

Examples found in repository

examples/product_fees_v0.rs (line 6)

async fn main() -> Result<()> {
    let client = SpapiClient::new(SpapiConfig::from_env()?)?;

    let fee = client.get_fee_for_asin("B0DGJC52FP", 999.0, true).await?;
    println!("Fee for ASIN B0DGJC52FP: ${:.2}", fee);

    Ok(())
}

examples/sellers_v1.rs (line 7)

async fn main() -> Result<()> {
    let config = SpapiConfig::from_env()?;
    let client = SpapiClient::new(config.clone())?;

    let marketplace = client.get_marketplace_participations().await?;
    println!("Marketplace: {:#?}", marketplace);
    println!("{}", marketplace.payload.ok()?[0].marketplace.name);

    Ok(())
}

examples/fba_inventory_v1.rs (line 49)

async fn main() -> Result<()> {
    let client = SpapiClient::new(SpapiConfig::from_env()?)?;

    let inventory_summaries = get_inventory_summaries_all(&client, Some(false)).await?;
    log::info!("Fetched {} inventory summaries", inventory_summaries.len());
    for summary in inventory_summaries {
        log::info!("Inventory Summary: {:?}", summary);
    }

    Ok(())
}

examples/pricing_v0.rs (line 6)

async fn main() -> Result<()> {
    let client = SpapiClient::new(SpapiConfig::from_env()?)?;

    // let res = client
    //     .get_item_offers(client.get_marketplace_id(), "B0DGJC52FP", "New", None)
    //     .await?;
    // println!("Item offers: {:?}", res);

    let res = client
        .get_item_offers_batch_by_asins(vec!["B0DGJC52FP", "B0BN72FYFG"])
        .await?;
    println!("Batch item offers: {:?}", res);

    // let res = client
    //     .get_listing_offers_batch_by_skus(vec!["YOU_SKU1", "YOU_SKU2"])
    //     .await?;
    // println!("Batch listing offers: {:?}", res);
    

    Ok(())
}

examples/sellers_v1_use_raw_api.rs (line 8)

async fn main() -> Result<()> {
    let spapi_config = SpapiConfig::from_env()?;
    let spapi_client = SpapiClient::new(spapi_config.clone())?;
    {
        // Internally refresh the access token and create a configuration
        // Configuration must be created for each API call
        let configuration = spapi_client.create_configuration().await?;

        // Wait for rate limit before making the API call
        // When _guard is dropped, the rate limiter will mark the api call as having received a response
        let _guard = spapi_client
            .limiter()
            .wait("get_marketplace_participations", 0.016, 15)
            .await?;

        // Call the API to get marketplace participations
        let res = get_marketplace_participations(&configuration).await?;
        
        println!("Marketplace Participations: {:#?}", res);
    }
    Ok(())
}

examples/reports.rs (line 183)

async fn main() -> Result<()> {
    env_logger::init();

    let spapi_config = SpapiConfig::from_env()?;
    let client = SpapiClient::new(spapi_config.clone())?;
    let marketplace_ids = vec!["ATVPDKIKX0DER".to_string()]; // Amazon US Marketplace ID

    // create report specification
    let report_type = "GET_RESTOCK_INVENTORY_RECOMMENDATIONS_REPORT";
    let report_content = client
        .fetch_report(
            report_type,
            marketplace_ids.clone(),
            None,
            Some(|attempt, status| {
                println!("Attempt get report {}: {:?}", attempt, status);
            }),
        )
        .await?;

    // save report content to a file
    let report_file_path = "/tmp/restock_inventory_report.txt";
    std::fs::write(report_file_path, &report_content)
        .expect("Unable to write report content to file");

    // // load report content from the file
    // let report_file_path = "/tmp/restock_inventory_report.txt";
    // let report_content =
    //     std::fs::read_to_string(report_file_path).expect("Unable to read report content from file");

    let restocks = parse_restock_report(&report_content);

    println!("Restock inventory report generated successfully.");
    println!("{:#?}", restocks);

    Ok(())
}

Additional examples can be found in:

• examples/update_price.rs

pub fn limiter(&self) -> &RateLimiter

Examples found in repository

examples/sellers_v1_use_raw_api.rs (line 17)

async fn main() -> Result<()> {
    let spapi_config = SpapiConfig::from_env()?;
    let spapi_client = SpapiClient::new(spapi_config.clone())?;
    {
        // Internally refresh the access token and create a configuration
        // Configuration must be created for each API call
        let configuration = spapi_client.create_configuration().await?;

        // Wait for rate limit before making the API call
        // When _guard is dropped, the rate limiter will mark the api call as having received a response
        let _guard = spapi_client
            .limiter()
            .wait("get_marketplace_participations", 0.016, 15)
            .await?;

        // Call the API to get marketplace participations
        let res = get_marketplace_participations(&configuration).await?;
        
        println!("Marketplace Participations: {:#?}", res);
    }
    Ok(())
}

pub fn get_user_agent() -> String

Get default user agent for the client

pub fn get_base_url(&self) -> String

Get the base URL for the client

pub fn get_marketplace_id(&self) -> &str

Get the region for the client

Examples found in repository

examples/fba_inventory_v1.rs (line 16)

async fn get_inventory_summaries_all(
    spapi: &SpapiClient,
    details: Option<bool>,
) -> Result<Vec<InventorySummary>> {
    let mut res: Vec<InventorySummary> = Vec::new();
    let mut next_token: Option<String> = None;

    loop {
        let granularity_type = "Marketplace";
        let granularity_id = spapi.get_marketplace_id();
        let marketplace_ids = vec![spapi.get_marketplace_id().to_string()];

        let inventory = spapi
            .get_inventory_summaries(
                granularity_type,
                granularity_id,
                marketplace_ids,
                details,
                None,
                None,
                None,
                next_token.as_deref(),
            )
            .await?;
        log::debug!("Fetched inventory summaries successfully: {:?}", inventory);

        if let Some(payload) = inventory.payload {
            res.extend(payload.inventory_summaries);
        }

        if let Some(pagination) = inventory.pagination {
            next_token = pagination.next_token;
        } else {
            break;
        }
    }

    Ok(res)
}

pub async fn get_access_token(&self) -> Result<String>

Get access token from the auth client

pub fn is_sandbox(&self) -> bool

Check if the client is in sandbox mode

pub async fn request( &self, endpoint: &ApiEndpoint, query: Option<Vec<(String, String)>>, header: Option<Vec<(&'static str, String)>>, body: Option<&str>, ) -> Result<String>

Make a request to the SP API

pub async fn upload( &self, url: &str, content: &str, content_type: &str, ) -> Result<()>

Upload content to the feed document URL (direct S3 upload)

pub async fn download(&self, url: &str) -> Result<String>

Download content from a feed document URL

pub async fn get_rate_limit_status( &self, ) -> Result<HashMap<String, (f64, f64, u32)>>

Check if rate limiting is enabled and get token status

pub async fn check_rate_limit_availability( &self, endpoint_id: &String, ) -> Result<bool>

Check if a token is available for a specific endpoint without consuming it

pub async fn refresh_access_token_if_needed(&self) -> Result<()>

Refresh the access token if needed

pub async fn force_refresh_token(&self) -> Result<()>

Force refresh the access token

pub fn get_http_client(&self) -> &Client

Get access to the underlying HTTP client for direct requests

pub async fn create_configuration(&self) -> Result<Configuration>

Create a new configuration for the generated APIs This function refreshes the access token and sets up the configuration

Examples found in repository

examples/sellers_v1_use_raw_api.rs (line 12)

async fn main() -> Result<()> {
    let spapi_config = SpapiConfig::from_env()?;
    let spapi_client = SpapiClient::new(spapi_config.clone())?;
    {
        // Internally refresh the access token and create a configuration
        // Configuration must be created for each API call
        let configuration = spapi_client.create_configuration().await?;

        // Wait for rate limit before making the API call
        // When _guard is dropped, the rate limiter will mark the api call as having received a response
        let _guard = spapi_client
            .limiter()
            .wait("get_marketplace_participations", 0.016, 15)
            .await?;

        // Call the API to get marketplace participations
        let res = get_marketplace_participations(&configuration).await?;
        
        println!("Marketplace Participations: {:#?}", res);
    }
    Ok(())
}

pub fn from_json<'a, T>(s: &'a str) -> Result<T>

where T: Deserialize<'a>,

impl SpapiClient

pub async fn search_catalog_items( &self, marketplace_ids: Vec<String>, identifiers: Option<Vec<String>>, identifiers_type: Option<&str>, included_data: Option<Vec<String>>, locale: Option<&str>, seller_id: Option<&str>, keywords: Option<Vec<String>>, brand_names: Option<Vec<String>>, classification_ids: Option<Vec<String>>, page_size: Option<i32>, page_token: Option<&str>, keywords_locale: Option<&str>, ) -> Result<ItemSearchResults>

Search for a list of Amazon catalog items and item-related information. You can search by identifier or by keywords. Usage Plan: | Rate (requests per second) | Burst | | –– | –– | | 2 | 2 | The x-amzn-RateLimit-Limit response header contains the usage plan rate limits for the operation, when available. The preceding table contains the default rate and burst values for this operation. Selling partners whose business demands require higher throughput might have higher rate and burst values than those shown here. For more information, refer to Usage Plans and Rate Limits.

pub async fn get_catalog_item( &self, asin: &str, marketplace_ids: Vec<String>, included_data: Option<Vec<String>>, locale: Option<&str>, ) -> Result<Item>

Retrieves details for an item in the Amazon catalog. Usage Plan: | Rate (requests per second) | Burst | | –– | –– | | 2 | 2 | The x-amzn-RateLimit-Limit response header contains the usage plan rate limits for the operation, when available. The preceding table contains the default rate and burst values for this operation. Selling partners whose business demands require higher throughput might have higher rate and burst values than those shown here. For more information, refer to Usage Plans and Rate Limits.

pub async fn search_catalog_items_by_asin( &self, asin: &str, marketplace_ids: Vec<String>, included_data: Option<Vec<String>>, locale: Option<&str>, ) -> Result<ItemSearchResults>

Convenience method to search for items by ASIN.

pub async fn search_catalog_items_by_keywords( &self, keywords: Vec<String>, marketplace_ids: Vec<String>, included_data: Option<Vec<String>>, brand_names: Option<Vec<String>>, classification_ids: Option<Vec<String>>, page_size: Option<i32>, page_token: Option<&str>, keywords_locale: Option<&str>, ) -> Result<ItemSearchResults>

Convenience method to search for items by keywords.

impl SpapiClient

pub async fn add_inventory( &self, x_amzn_idempotency_token: &str, add_inventory_request_body: AddInventoryRequest, ) -> Result<AddInventoryResponse>

pub async fn create_inventory_item( &self, create_inventory_item_request_body: CreateInventoryItemRequest, ) -> Result<CreateInventoryItemResponse>

pub async fn delete_inventory_item( &self, seller_sku: &str, marketplace_id: &str, ) -> Result<DeleteInventoryItemResponse>

pub async fn get_inventory_summaries( &self, granularity_type: &str, granularity_id: &str, marketplace_ids: Vec<String>, details: Option<bool>, start_date_time: Option<String>, seller_skus: Option<Vec<String>>, seller_sku: Option<&str>, next_token: Option<&str>, ) -> Result<GetInventorySummariesResponse>

Get inventory summaries for FBA inventory

Returns a list of inventory summaries. The summaries returned depend on the presence of the startDateTime and sellerSkus parameters.

Examples found in repository

examples/fba_inventory_v1.rs (lines 20-29)

async fn get_inventory_summaries_all(
    spapi: &SpapiClient,
    details: Option<bool>,
) -> Result<Vec<InventorySummary>> {
    let mut res: Vec<InventorySummary> = Vec::new();
    let mut next_token: Option<String> = None;

    loop {
        let granularity_type = "Marketplace";
        let granularity_id = spapi.get_marketplace_id();
        let marketplace_ids = vec![spapi.get_marketplace_id().to_string()];

        let inventory = spapi
            .get_inventory_summaries(
                granularity_type,
                granularity_id,
                marketplace_ids,
                details,
                None,
                None,
                None,
                next_token.as_deref(),
            )
            .await?;
        log::debug!("Fetched inventory summaries successfully: {:?}", inventory);

        if let Some(payload) = inventory.payload {
            res.extend(payload.inventory_summaries);
        }

        if let Some(pagination) = inventory.pagination {
            next_token = pagination.next_token;
        } else {
            break;
        }
    }

    Ok(res)
}

impl SpapiClient

pub async fn list_transactions( &self, posted_after: String, posted_before: Option<String>, marketplace_id: Option<&str>, transaction_status: Option<&str>, next_token: Option<&str>, ) -> Result<ListTransactionsResponse>

impl SpapiClient

pub async fn list_financial_event_groups( &self, max_results_per_page: Option<i32>, financial_event_group_started_before: Option<String>, financial_event_group_started_after: Option<String>, next_token: Option<&str>, ) -> Result<ListFinancialEventGroupsResponse>

pub async fn list_financial_events( &self, max_results_per_page: Option<i32>, posted_after: Option<String>, posted_before: Option<String>, next_token: Option<&str>, ) -> Result<ListFinancialEventsResponse>

max_results_per_page: 1 to 100 default to 100

pub async fn list_financial_events_by_group_id( &self, event_group_id: &str, max_results_per_page: Option<i32>, posted_after: Option<String>, posted_before: Option<String>, next_token: Option<&str>, ) -> Result<ListFinancialEventsResponse>

pub async fn list_financial_events_by_order_id( &self, order_id: &str, max_results_per_page: Option<i32>, next_token: Option<&str>, ) -> Result<ListFinancialEventsResponse>

impl SpapiClient

pub async fn cancel_feed(&self, feed_id: &str) -> Result<()>

Cancels the feed that you specify. Only feeds with processingStatus=IN_QUEUE can be cancelled. Cancelled feeds are returned in subsequent calls to the getFeed and getFeeds operations. Usage Plan: | Rate (requests per second) | Burst | | –– | –– | | 2 | 15 | The x-amzn-RateLimit-Limit response header returns the usage plan rate limits that were applied to the requested operation, when available. The preceding table indicates the default rate and burst values for this operation. Selling partners whose business demands require higher throughput may have higher rate and burst values than those shown here. For more information, refer to Usage Plans and Rate Limits in the Selling Partner API.

pub async fn create_feed( &self, body: CreateFeedSpecification, ) -> Result<CreateFeedResponse>

Creates a feed. Upload the contents of the feed document before calling this operation. Usage Plan: | Rate (requests per second) | Burst | | –– | –– | | 0.0083 | 15 | The x-amzn-RateLimit-Limit response header returns the usage plan rate limits that were applied to the requested operation, when available. The preceding table indicates the default rate and burst values for this operation. Selling partners whose business demands require higher throughput may have higher rate and burst values than those shown here. For more information, refer to Usage Plans and Rate Limits in the Selling Partner API. The rate limit for the JSON_LISTINGS_FEED feed type differs from the rate limit for the createFeed operation. For more information, refer to the Building Listings Management Workflows Guide.

pub async fn create_feed_document( &self, body: CreateFeedDocumentSpecification, ) -> Result<CreateFeedDocumentResponse>

Creates a feed document for the feed type that you specify. This operation returns a presigned URL for uploading the feed document contents. It also returns a feedDocumentId value that you can pass in with a subsequent call to the createFeed operation. Usage Plan: | Rate (requests per second) | Burst | | –– | –– | | 0.5 | 15 | The x-amzn-RateLimit-Limit response header returns the usage plan rate limits that were applied to the requested operation, when available. The preceding table indicates the default rate and burst values for this operation. Selling partners whose business demands require higher throughput may have higher rate and burst values than those shown here. For more information, refer to Usage Plans and Rate Limits in the Selling Partner API.

pub async fn get_feed(&self, feed_id: &str) -> Result<Feed>

Returns feed details (including the resultDocumentId, if available) for the feed that you specify. Usage Plan: | Rate (requests per second) | Burst | | –– | –– | | 2 | 15 | The x-amzn-RateLimit-Limit response header returns the usage plan rate limits that were applied to the requested operation, when available. The preceding table indicates the default rate and burst values for this operation. Selling partners whose business demands require higher throughput may have higher rate and burst values than those shown here. For more information, refer to Usage Plans and Rate Limits in the Selling Partner API.

pub async fn get_feed_document( &self, feed_document_id: &str, ) -> Result<FeedDocument>

Returns the information required for retrieving a feed document’s contents. Usage Plan: | Rate (requests per second) | Burst | | –– | –– | | 0.0222 | 10 | The x-amzn-RateLimit-Limit response header returns the usage plan rate limits that were applied to the requested operation, when available. The preceding table indicates the default rate and burst values for this operation. Selling partners whose business demands require higher throughput may have higher rate and burst values than those shown here. For more information, refer to Usage Plans and Rate Limits in the Selling Partner API.

pub async fn get_feeds( &self, feed_types: Option<Vec<String>>, marketplace_ids: Option<Vec<String>>, page_size: Option<i32>, processing_statuses: Option<Vec<String>>, created_since: Option<String>, created_until: Option<String>, next_token: Option<&str>, ) -> Result<GetFeedsResponse>

Returns feed details for the feeds that match the filters that you specify. Usage Plan: | Rate (requests per second) | Burst | | –– | –– | | 0.0222 | 10 | The x-amzn-RateLimit-Limit response header returns the usage plan rate limits that were applied to the requested operation, when available. The preceding table indicates the default rate and burst values for this operation. Selling partners whose business demands require higher throughput may have higher rate and burst values than those shown here. For more information, refer to Usage Plans and Rate Limits in the Selling Partner API.

impl SpapiClient

pub async fn delete_listings_item( &self, seller_id: &str, sku: &str, marketplace_ids: Vec<String>, issue_locale: Option<&str>, ) -> Result<ListingsItemSubmissionResponse>

Delete a listings item for a selling partner. Usage Plan: | Rate (requests per second) | Burst | | –– | –– | | 5 | 5 | The x-amzn-RateLimit-Limit response header returns the usage plan rate limits that were applied to the requested operation, when available. The preceding table indicates the default rate and burst values for this operation. Selling partners whose business demands require higher throughput can receive higher rate and burst values than those shown here. For more information, refer to Usage Plans and Rate Limits in the Selling Partner API documentation.

pub async fn get_listings_item( &self, seller_id: &str, sku: &str, marketplace_ids: Vec<String>, issue_locale: Option<&str>, included_data: Option<Vec<String>>, ) -> Result<Item>

Returns details about a listings item for a selling partner. Usage Plan: | Rate (requests per second) | Burst | | –– | –– | | 5 | 10 | The x-amzn-RateLimit-Limit response header returns the usage plan rate limits that were applied to the requested operation, when available. The preceding table indicates the default rate and burst values for this operation. Selling partners whose business demands require higher throughput can receive higher rate and burst values than those shown here. For more information, refer to Usage Plans and Rate Limits in the Selling Partner API documentation.

Examples found in repository

examples/update_price.rs (lines 117-123)

async fn get_current_listing(
    client: &SpapiClient,
    seller_id: &str,
    sku: &str,
    marketplace_ids: &[String],
) -> Result<amazon_spapi::models::listings_items_2021_08_01::Item> {
    client
        .get_listings_item(
            seller_id,
            sku,
            marketplace_ids.to_vec(),
            None,                                                          // issue_locale
            Some(vec!["summaries".to_string(), "attributes".to_string()]), // included_data
        )
        .await
}

pub async fn patch_listings_item( &self, seller_id: &str, sku: &str, marketplace_ids: Vec<String>, body: ListingsItemPatchRequest, included_data: Option<Vec<String>>, mode: Option<&str>, issue_locale: Option<&str>, ) -> Result<ListingsItemSubmissionResponse>

Partially update (patch) a listings item for a selling partner. Only top-level listings item attributes can be patched. Patching nested attributes is not supported. Usage Plan: | Rate (requests per second) | Burst | | –– | –– | | 5 | 5 | The x-amzn-RateLimit-Limit response header returns the usage plan rate limits that were applied to the requested operation, when available. The preceding table indicates the default rate and burst values for this operation. Selling partners whose business demands require higher throughput can receive higher rate and burst values than those shown here. For more information, refer to Usage Plans and Rate Limits in the Selling Partner API documentation.

Examples found in repository

examples/update_price.rs (lines 97-105)

async fn update_listing_price(
    client: &SpapiClient,
    seller_id: &str,
    sku: &str,
    marketplace_ids: &[String],
    new_price: f64,
) -> Result<amazon_spapi::models::listings_items_2021_08_01::ListingsItemSubmissionResponse> {
    let mut purchasable_offer = HashMap::new();
    purchasable_offer.insert("audience".to_string(), json!("ALL"));
    purchasable_offer.insert("currency".to_string(), json!("USD"));
    purchasable_offer.insert("marketplace_id".to_string(), json!(marketplace_ids[0]));
    purchasable_offer.insert(
        "our_price".to_string(),
        json!([{
            "schedule": [{
                "value_with_tax": new_price
            }]
        }]),
    );

    let mut list_price = HashMap::new();
    list_price.insert("marketplace_id".to_string(), json!(marketplace_ids[0]));
    list_price.insert("currency".to_string(), json!("USD"));
    list_price.insert("value".to_string(), json!(new_price));

    let purchasable_offer_patch = PatchOperation {
        op: Op::Replace,
        path: "/attributes/purchasable_offer".to_string(),
        value: Some(vec![purchasable_offer]),
    };

    let list_price_patch = PatchOperation {
        op: Op::Replace,
        path: "/attributes/list_price".to_string(),
        value: Some(vec![list_price]),
    };

    let patch_request = ListingsItemPatchRequest {
        product_type: "PRODUCT".to_string(),
        patches: vec![purchasable_offer_patch, list_price_patch],
    };

    println!("{:#?}", patch_request);

    client
        .patch_listings_item(
            seller_id,
            sku,
            marketplace_ids.to_vec(),
            patch_request,
            None, // included_data
            None, // Some("VALIDATION_PREVIEW"), // mode - Can use "VALIDATION_PREVIEW" to validate first
            None, // issue_locale
        )
        .await
}

pub async fn put_listings_item( &self, seller_id: &str, sku: &str, marketplace_ids: Vec<String>, body: ListingsItemPutRequest, included_data: Option<Vec<String>>, mode: Option<&str>, issue_locale: Option<&str>, ) -> Result<ListingsItemSubmissionResponse>

Creates a new or fully-updates an existing listings item for a selling partner. Usage Plan: | Rate (requests per second) | Burst | | –– | –– | | 5 | 10 | The x-amzn-RateLimit-Limit response header returns the usage plan rate limits that were applied to the requested operation, when available. The preceding table indicates the default rate and burst values for this operation. Selling partners whose business demands require higher throughput can receive higher rate and burst values than those shown here. For more information, refer to Usage Plans and Rate Limits in the Selling Partner API documentation.

pub async fn search_listings_items( &self, seller_id: &str, marketplace_ids: Vec<String>, issue_locale: Option<&str>, included_data: Option<Vec<String>>, identifiers: Option<Vec<String>>, identifiers_type: Option<&str>, variation_parent_sku: Option<&str>, package_hierarchy_sku: Option<&str>, created_after: Option<String>, created_before: Option<String>, last_updated_after: Option<String>, last_updated_before: Option<String>, with_issue_severity: Option<Vec<String>>, with_status: Option<Vec<String>>, without_status: Option<Vec<String>>, sort_by: Option<&str>, sort_order: Option<&str>, page_size: Option<i32>, page_token: Option<&str>, ) -> Result<ItemSearchResults>

Search for and return a list of selling partner listings items and their respective details. Usage Plan: | Rate (requests per second) | Burst | | –– | –– | | 5 | 5 | The x-amzn-RateLimit-Limit response header returns the usage plan rate limits that are applied to the requested operation, when available. The preceding table contains the default rate and burst values for this operation. Selling partners whose business demands require higher throughput might have higher rate and burst values than those shown here. For more information, refer to Usage Plans and Rate Limits.

impl SpapiClient

pub async fn get_pricing( &self, marketplace_id: &str, item_type: &str, asins: Option<Vec<String>>, skus: Option<Vec<String>>, item_condition: Option<String>, offer_type: Option<String>, ) -> Result<GetPricingResponse>

Returns pricing information for a seller’s offer listings based on seller SKU or ASIN.

Arguments

• marketplace_id - A marketplace identifier. Specifies the marketplace for which prices are returned.
• item_type - Indicates whether ASIN values or seller SKU values are used to identify items. Possible values: “Asin”, “Sku”.
• asins - A list of up to twenty Amazon Standard Identification Number (ASIN) values used to identify items in the given marketplace.
• skus - A list of up to twenty seller SKU values used to identify items in the given marketplace.
• item_condition - Filters the offer listings based on item condition. Possible values: “New”, “Used”, “Collectible”, “Refurbished”, “Club”.
• offer_type - Indicates whether to request pricing information for the seller’s B2C or B2B offers. Default is “B2C”.

Rate Limits

• Rate: 0.5 requests per second
• Burst: 1

Examples

let response = client.get_pricing(
    "ATVPDKIKX0DER",
    "Asin",
    Some(vec!["B08N5WRWNW".to_string(), "B07XJ8C8F7".to_string()]),
    None,
    Some("New".to_string()),
    Some("B2C".to_string()),
).await?;

println!("Pricing information: {:?}", response);

pub async fn get_competitive_pricing( &self, marketplace_id: &str, item_type: &str, asins: Option<Vec<String>>, skus: Option<Vec<String>>, customer_type: Option<String>, ) -> Result<GetPricingResponse>

Returns competitive pricing information for a seller’s offer listings based on seller SKU or ASIN.

Arguments

• marketplace_id - A marketplace identifier. Specifies the marketplace for which prices are returned.
• item_type - Indicates whether ASIN values or seller SKU values are used to identify items. Possible values: “Asin”, “Sku”.
• asins - A list of up to twenty Amazon Standard Identification Number (ASIN) values used to identify items in the given marketplace.
• skus - A list of up to twenty seller SKU values used to identify items in the given marketplace.
• customer_type - Indicates whether to request Consumer or Business offers. Default is “Consumer”.

Rate Limits

• Rate: 0.5 requests per second
• Burst: 1

Examples

let response = client.get_competitive_pricing(
    "ATVPDKIKX0DER",
    "Asin",
    Some(vec!["B08N5WRWNW".to_string(), "B07XJ8C8F7".to_string()]),
    None,
    Some("Consumer".to_string()),
).await?;

println!("Competitive pricing: {:?}", response);

pub async fn get_item_offers( &self, marketplace_id: &str, asin: &str, item_condition: &str, customer_type: Option<String>, ) -> Result<GetOffersResponse>

Returns the lowest priced offers for a single item based on ASIN.

Arguments

• marketplace_id - A marketplace identifier. Specifies the marketplace for which prices are returned.
• asin - The Amazon Standard Identification Number (ASIN) of the item for which you want to retrieve offer information.
• item_condition - Filters the offer listings to be considered based on item condition. Possible values: “New”, “Used”, “Collectible”, “Refurbished”, “Club”.
• customer_type - Indicates whether to request Consumer or Business offers. Default is “Consumer”.

Rate Limits

• Rate: 0.5 requests per second
• Burst: 1

Examples

let response = client.get_item_offers(
    "ATVPDKIKX0DER",
    "B08N5WRWNW",
    "New",
    Some("Consumer".to_string()),
).await?;

println!("Item offers: {:?}", response);

pub async fn get_listing_offers( &self, marketplace_id: &str, seller_sku: &str, item_condition: &str, customer_type: Option<String>, ) -> Result<GetOffersResponse>

Returns the lowest priced offers for a single SKU listing.

Arguments

• marketplace_id - A marketplace identifier. Specifies the marketplace for which prices are returned.
• seller_sku - A seller identifier that you want to retrieve offer information for.
• item_condition - Filters the offer listings to be considered based on item condition. Possible values: “New”, “Used”, “Collectible”, “Refurbished”, “Club”.
• customer_type - Indicates whether to request Consumer or Business offers. Default is “Consumer”.

Rate Limits

• Rate: 1 request per second
• Burst: 2

Examples

let response = client.get_listing_offers(
    "ATVPDKIKX0DER",
    "MY-SKU-123",
    "New",
    Some("Consumer".to_string()),
).await?;

println!("Listing offers: {:?}", response);

pub async fn get_item_offers_batch( &self, request: GetItemOffersBatchRequest, ) -> Result<GetItemOffersBatchResponse>

Returns the set of responses that correspond to the batched list of up to 20 requests defined in the request body. The response for each successful (HTTP status code 200) request in the set includes the item offers for a given ASIN.

Arguments

• request - The batch of getItemOffers requests.

Rate Limits

• Rate: 0.1 requests per second
• Burst: 1

Examples

use spapi::models::pricing_v0::*;

let batch_request = GetItemOffersBatchRequest {
    requests: Some(vec![
        ItemOffersRequest {
            uri: "/products/pricing/v0/items/B123456789/offers".to_string(),
            method: HttpMethod::Get,
            marketplace_id: "ATVPDKIKX0DER".to_string(),
            item_condition: "New".to_string(),
            customer_type: Some("Consumer".to_string()),
            headers: None,
        },
    ]),
};

let response = client.get_item_offers_batch(batch_request).await?;
println!("Batch item offers: {:?}", response);

pub async fn get_listing_offers_batch( &self, request: GetListingOffersBatchRequest, ) -> Result<GetListingOffersBatchResponse>

Returns the set of responses that correspond to the batched list of up to 20 requests defined in the request body. The response for each successful (HTTP status code 200) request in the set includes the listing offers for a given SKU.

Arguments

• request - The batch of getListingOffers requests.

Rate Limits

• Rate: 0.5 requests per second
• Burst: 1

Examples

use spapi::models::pricing_v0::*;

let batch_request = GetListingOffersBatchRequest {
    requests: Some(vec![
        ListingOffersRequest {
            uri: "/products/pricing/v0/listings/MY-SKU-123/offers".to_string(),
            method: HttpMethod::Get,
            marketplace_id: "ATVPDKIKX0DER".to_string(),
            item_condition: "New".to_string(),
            customer_type: Some("Consumer".to_string()),
            headers: None,
        },
    ]),
};

let response = client.get_listing_offers_batch(batch_request).await?;
println!("Batch listing offers: {:?}", response);

pub async fn get_item_offers_batch_by_asins( &self, asins: Vec<&str>, ) -> Result<GetItemOffersBatchResponse>

Convenience method to get item offers for multiple ASINs in a single batch request.

• asins: length between 1 and 20

Examples found in repository

examples/pricing_v0.rs (line 14)

async fn main() -> Result<()> {
    let client = SpapiClient::new(SpapiConfig::from_env()?)?;

    // let res = client
    //     .get_item_offers(client.get_marketplace_id(), "B0DGJC52FP", "New", None)
    //     .await?;
    // println!("Item offers: {:?}", res);

    let res = client
        .get_item_offers_batch_by_asins(vec!["B0DGJC52FP", "B0BN72FYFG"])
        .await?;
    println!("Batch item offers: {:?}", res);

    // let res = client
    //     .get_listing_offers_batch_by_skus(vec!["YOU_SKU1", "YOU_SKU2"])
    //     .await?;
    // println!("Batch listing offers: {:?}", res);
    

    Ok(())
}

pub async fn get_listing_offers_batch_by_skus( &self, skus: Vec<&str>, ) -> Result<GetListingOffersBatchResponse>

Convenience method to get listing offers for multiple SKUs in a single batch request.

• skus: length between 1 and 20

impl SpapiClient

pub async fn get_my_fees_estimate_for_sku( &self, sku: &str, request: GetMyFeesEstimateRequest, ) -> Result<GetMyFeesEstimateResponse>

Get fees estimate for a product by seller SKU

pub async fn get_my_fees_estimate_for_asin( &self, asin: &str, request: GetMyFeesEstimateRequest, ) -> Result<GetMyFeesEstimateResponse>

Get fees estimate for a product by ASIN

pub async fn get_my_fees_estimates( &self, requests: Vec<FeesEstimateByIdRequest>, ) -> Result<Vec<FeesEstimateResult>>

Get fees estimates for multiple products (batch operation)

pub async fn get_fee_for_asin( &self, asin: &str, price: f64, is_amazon_fulfilled: bool, ) -> Result<f64>

Convenience method to get fees estimate for a single ASIN with price

Examples found in repository

examples/product_fees_v0.rs (line 8)

async fn main() -> Result<()> {
    let client = SpapiClient::new(SpapiConfig::from_env()?)?;

    let fee = client.get_fee_for_asin("B0DGJC52FP", 999.0, true).await?;
    println!("Fee for ASIN B0DGJC52FP: ${:.2}", fee);

    Ok(())
}

pub async fn get_fees_for_asins( &self, asins_with_prices: Vec<(String, f64)>, is_amazon_fulfilled: bool, ) -> Result<Vec<(String, f64)>>

Get fees estimates for multiple ASINs (batch operation)

pub async fn get_fee_for_sku( &self, sku: &str, price: f64, is_amazon_fulfilled: bool, ) -> Result<f64>

Convenience method to get fees estimate for a single SKU with price

pub async fn get_fees_for_skus( &self, skus_with_prices: Vec<(String, f64)>, is_amazon_fulfilled: bool, ) -> Result<Vec<(String, f64)>>

Get fees estimates for multiple SKUs (batch operation)

impl SpapiClient

pub async fn get_marketplace_participations( &self, ) -> Result<GetMarketplaceParticipationsResponse>

Examples found in repository

examples/sellers_v1.rs (line 9)

async fn main() -> Result<()> {
    let config = SpapiConfig::from_env()?;
    let client = SpapiClient::new(config.clone())?;

    let marketplace = client.get_marketplace_participations().await?;
    println!("Marketplace: {:#?}", marketplace);
    println!("{}", marketplace.payload.ok()?[0].marketplace.name);

    Ok(())
}

pub async fn get_account(&self) -> Result<GetAccountResponse>

impl SpapiClient

pub async fn cancel_report(&self, report_id: &str) -> Result<()>

pub async fn cancel_report_schedule( &self, report_schedule_id: &str, ) -> Result<()>

pub async fn create_report( &self, body: CreateReportSpecification, ) -> Result<CreateReportResponse>

pub async fn create_report_schedule( &self, body: CreateReportScheduleSpecification, ) -> Result<CreateReportScheduleResponse>

pub async fn get_report(&self, report_id: &str) -> Result<Report>

pub async fn get_report_document( &self, report_document_id: &str, ) -> Result<ReportDocument>

pub async fn get_report_schedule( &self, report_schedule_id: &str, ) -> Result<ReportSchedule>

pub async fn get_report_schedules( &self, report_types: Vec<String>, ) -> Result<ReportScheduleList>

pub async fn get_reports( &self, report_types: Option<Vec<String>>, processing_statuses: Option<Vec<String>>, marketplace_ids: Option<Vec<String>>, page_size: Option<i32>, created_since: Option<String>, created_until: Option<String>, next_token: Option<&str>, ) -> Result<GetReportsResponse>

pub async fn fetch_report( &self, report_type: &str, marketplace_ids: Vec<String>, max_wait_minutes: Option<u32>, progress_callback: Option<impl Fn(u32, ProcessingStatus) + Send + 'static>, ) -> Result<String>

Convenience method to fetch a report by type and marketplace IDs, defaulting to a 30-minute wait.

Examples found in repository

examples/reports.rs (lines 189-196)

async fn main() -> Result<()> {
    env_logger::init();

    let spapi_config = SpapiConfig::from_env()?;
    let client = SpapiClient::new(spapi_config.clone())?;
    let marketplace_ids = vec!["ATVPDKIKX0DER".to_string()]; // Amazon US Marketplace ID

    // create report specification
    let report_type = "GET_RESTOCK_INVENTORY_RECOMMENDATIONS_REPORT";
    let report_content = client
        .fetch_report(
            report_type,
            marketplace_ids.clone(),
            None,
            Some(|attempt, status| {
                println!("Attempt get report {}: {:?}", attempt, status);
            }),
        )
        .await?;

    // save report content to a file
    let report_file_path = "/tmp/restock_inventory_report.txt";
    std::fs::write(report_file_path, &report_content)
        .expect("Unable to write report content to file");

    // // load report content from the file
    // let report_file_path = "/tmp/restock_inventory_report.txt";
    // let report_content =
    //     std::fs::read_to_string(report_file_path).expect("Unable to read report content from file");

    let restocks = parse_restock_report(&report_content);

    println!("Restock inventory report generated successfully.");
    println!("{:#?}", restocks);

    Ok(())
}