Business - WhatsApp Rust

The business API lets you read a WhatsApp Business account’s profile, browse its product catalog and collections, look up an order’s line items, and manage the authenticated account’s own business profile and cover photo.

Access

Reading a business’s profile stays a direct client method. Everything else — catalog, collections, orders, and profile writes — goes through client.business():

let profile = client.get_business_profile(&jid).await?;
let business = client.business();

Catalog, collection, and order lookups go over MEX (persisted GraphQL) — WhatsApp Web has no IQ fallback for these. Business profile writes and the cover photo go over IQ (w:biz). See the MEX API for the underlying GraphQL transport.

Methods

get_business_profile

Fetch the business profile for a WhatsApp Business account.

pub async fn get_business_profile(
    &self,
    jid: &Jid,
) -> Result<Option<BusinessProfile>, IqError>

Parameters:

jid - JID of the account to query

Returns:

Some(BusinessProfile) if the account is a business with a profile
None if the account is not a business or has no profile

Example:

let jid: Jid = "15551234567@s.whatsapp.net".parse()?;

if let Some(profile) = client.get_business_profile(&jid).await? {
    println!("Description: {}", profile.description);
    
    if let Some(email) = &profile.email {
        println!("Email: {}", email);
    }
    
    for site in &profile.website {
        println!("Website: {}", site);
    }
    
    if let Some(addr) = &profile.address {
        println!("Address: {}", addr);
    }
    
    for category in &profile.categories {
        println!("Category: {} (ID: {})", category.name, category.id);
    }
    
    if let Some(tz) = &profile.business_hours.timezone {
        println!("Timezone: {}", tz);
    }
    
    if let Some(configs) = &profile.business_hours.business_config {
        for config in configs {
            println!(
                "  {:?}: {:?} ({:?}–{:?})",
                config.day_of_week,
                config.mode,
                config.open_time,
                config.close_time,
            );
        }
    }
} else {
    println!("Not a business account");
}

get_catalog

Fetch one page of a business’s product catalog, over MEX.

pub async fn get_catalog(
    &self,
    jid: &Jid,
    options: &CatalogOptions,
) -> Result<Catalog, BusinessError>

Parameters:

jid - JID of the business account
options - paging and thumbnail size; see CatalogOptions

Example:

use whatsapp_rust::CatalogOptions;

let mut options = CatalogOptions::default();

loop {
    let catalog = client.business().get_catalog(&jid, &options).await?;

    for product in &catalog.products {
        println!("{}: {:?}", product.id, product.name);
        if let Some(price) = &product.price {
            println!("  {} {:?}", price.amount_1000 as f64 / 1000.0, price.currency);
        }
    }

    match catalog.after_cursor {
        Some(cursor) => options.after = Some(cursor),
        None => break,
    }
}

get_collections

Fetch one page of a business’s product collections, each with its products inline, over MEX.

pub async fn get_collections(
    &self,
    jid: &Jid,
    options: &CollectionOptions,
) -> Result<Collections, BusinessError>

Parameters:

jid - JID of the business account
options - paging and thumbnail size; see CollectionOptions

Example:

use whatsapp_rust::CollectionOptions;

let mut options = CollectionOptions::default();

loop {
    let collections = client.business().get_collections(&jid, &options).await?;

    for collection in &collections.collections {
        println!("{:?}: {} products", collection.name, collection.products.len());
        if collection.products.len() as u32 == options.item_limit {
            println!("  (may be truncated — this collection may have more products)");
        }
    }

    match collections.after_cursor {
        Some(cursor) => options.after = Some(cursor),
        None => break,
    }
}

Collection::products is a possibly-truncated prefix — the collections query returns no per-collection cursor, so products.len() == item_limit is the only signal that more products may exist in that collection. Equality doesn’t prove it: a collection with exactly item_limit products and no more looks identical.

get_order

Look up an order’s line items and totals, over MEX.

pub async fn get_order(
    &self,
    jid: &Jid,
    order_id: &str,
    token: &str,
) -> Result<Order, BusinessError>

Parameters:

jid - the business the order was placed with
order_id / token - taken from the order message itself (OrderMessage.order_id / OrderMessage.token on the Rust struct — orderId/token on the wire); the token is a per-order capability, so an order cannot be read without the message that announced it

Example:

let order = client.business().get_order(&jid, &order_id, &token).await?;

for product in &order.products {
    println!("{:?} x{:?}", product.name, product.quantity);
    for variant in &product.variant_properties {
        println!("  {:?}: {:?}", variant.name, variant.value);
    }
}

if let Some(details) = &order.price_details {
    println!("Total: {:?} {:?}", details.total, details.currency);
}

update_profile

Apply a delta to the authenticated account’s own business profile, over IQ (w:biz).

pub async fn update_profile(
    &self,
    update: &BusinessProfileUpdate,
) -> Result<(), BusinessError>

Parameters:

update - fields left None are untouched; see BusinessProfileUpdate for how to clear one instead

The update is validated client-side before anything is sent — an invalid delta returns BusinessError::InvalidUpdate without touching the wire. See Validation below. Example:

use whatsapp_rust::{BusinessHourMode, BusinessHoursConfig, BusinessHoursUpdate, BusinessProfileUpdate, DayOfWeek};

let update = BusinessProfileUpdate {
    description: Some("Fresh bread, baked daily.".into()),
    email: Some("orders@example.com".into()),
    websites: Some(vec!["https://example.com".into()]),
    business_hours: Some(BusinessHoursUpdate {
        timezone: Some("America/Sao_Paulo".into()),
        config: vec![
            BusinessHoursConfig::with_hours(DayOfWeek::Monday, BusinessHourMode::SpecificHours, 480, 1080),
            BusinessHoursConfig::new(DayOfWeek::Sunday, BusinessHourMode::AppointmentOnly),
        ],
        ..Default::default()
    }),
    ..Default::default()
};

client.business().update_profile(&update).await?;

set_cover_photo

Point the business profile at an already-uploaded cover photo, over IQ (w:biz).

pub async fn set_cover_photo(&self, upload: CoverPhotoUpload) -> Result<(), BusinessError>

Parameters:

upload - the fbid/meta_hmac/ts receipt from a biz-cover-photo media upload; see CoverPhotoUpload for why this crate does not perform that upload itself

Example:

use whatsapp_rust::CoverPhotoUpload;

let upload = CoverPhotoUpload {
    id: "1234567890".into(),      // fbid from the upload response
    token: "abcdef...".into(),    // meta_hmac from the upload response
    timestamp: 1_700_000_000,     // ts from the upload response
};

client.business().set_cover_photo(upload).await?;

remove_cover_photo

Remove the business profile’s cover photo, over IQ (w:biz).

pub async fn remove_cover_photo(&self, id: &str) -> Result<(), BusinessError>

Parameters:

id - the fbid the cover photo was set with

Example:

client.business().remove_cover_photo("1234567890").await?;

Types

BusinessProfile

#[non_exhaustive]
pub struct BusinessProfile {
    pub wid: Option<Jid>,
    pub description: String,
    pub email: Option<String>,
    pub website: Vec<String>,
    pub categories: Vec<BusinessCategory>,
    pub address: Option<String>,
    pub business_hours: BusinessHours,
}

BusinessProfile is #[non_exhaustive]: struct-literal construction and exhaustive struct destructuring from outside the crate are both disallowed. Field reads are unaffected; add .. to any exhaustive destructuring patterns.

BusinessCategory

#[non_exhaustive]
pub struct BusinessCategory {
    pub id: String,
    pub name: String,
}

BusinessCategory is #[non_exhaustive]: struct-literal construction and exhaustive struct destructuring from outside the crate are both disallowed. Field reads are unaffected; add .. to any exhaustive destructuring patterns.

BusinessHours

#[non_exhaustive]
pub struct BusinessHours {
    pub timezone: Option<String>,
    pub business_config: Option<Vec<BusinessHoursConfig>>,
}

BusinessHours is #[non_exhaustive]: struct-literal construction and exhaustive struct destructuring from outside the crate are both disallowed. Field reads are unaffected; add .. to any exhaustive destructuring patterns.

BusinessHoursConfig

The read side reports opening hours with this type; the write side (BusinessHoursUpdate::config) reuses it too.

#[non_exhaustive]
pub struct BusinessHoursConfig {
    pub day_of_week: DayOfWeek,
    pub mode: BusinessHourMode,
    pub open_time: Option<u32>,
    pub close_time: Option<u32>,
}

BusinessHoursConfig is #[non_exhaustive]: struct-literal construction and exhaustive struct destructuring from outside the crate are both disallowed. Field reads are unaffected; add .. to any exhaustive destructuring patterns. Constructors:

BusinessHoursConfig::new(day_of_week, mode) — a day whose mode carries no explicit range (Open24H or AppointmentOnly)
BusinessHoursConfig::with_hours(day_of_week, mode, open_time, close_time) — a single opening range, in minutes past local midnight. A day with two ranges is two entries sharing a day_of_week.

There’s no “closed” mode or constructor. config holds one entry per day that has hours to report; a day closed every week is represented by leaving it out of config entirely, not by constructing an entry for it.

DayOfWeek

pub enum DayOfWeek {
    Sunday,       // "sun"
    Monday,       // "mon"
    Tuesday,      // "tue"
    Wednesday,    // "wed"
    Thursday,     // "thu"
    Friday,       // "fri"
    Saturday,     // "sat"
    Other(String),
}

BusinessHourMode

pub enum BusinessHourMode {
    Open24H,          // "open_24h"
    SpecificHours,    // "specific_hours"
    AppointmentOnly,  // "appointment_only"
    Other(String),
}

BusinessHoursUpdate

Opening hours carried by a profile mutation. Distinct from the read-side BusinessHours because the mutation also carries a free-text note, which the profile query does not return.

pub struct BusinessHoursUpdate {
    /// IANA zone name (e.g. `America/Araguaina`). Omitted when `None`.
    pub timezone: Option<String>,
    /// Free-text note shown under the hours. `Some("")` is not special-cased:
    /// WhatsApp Web drops empty notes, and so does the builder.
    pub note: Option<String>,
    /// One entry per opening range; see `BusinessHoursConfig::with_hours`.
    pub config: Vec<BusinessHoursConfig>,
}

BusinessProfileUpdate

A delta mutation of the business profile, passed to update_profile. This is a delta, not a replacement: every field defaults to None, and a None field is left untouched on the server. To clear a field instead of leaving it alone, set it to Some of an empty value — Some(String::new()) for text fields, Some(Vec::new()) for websites. None and an empty Some are not interchangeable: only the latter clears anything.

pub struct BusinessProfileUpdate {
    pub address: Option<String>,
    pub latitude: Option<f64>,
    pub longitude: Option<f64>,
    pub description: Option<String>,
    pub email: Option<String>,
    /// Up to `BUSINESS_PROFILE_MAX_WEBSITES` URLs. `Some(vec![])` clears the
    /// list, matching WhatsApp Web's lone empty `<website/>` node.
    pub websites: Option<Vec<String>>,
    /// Category *ids* (from the business categories directory), not names.
    pub categories: Option<Vec<String>>,
    pub business_hours: Option<BusinessHoursUpdate>,
}

BUSINESS_PROFILE_MAX_WEBSITES

pub const BUSINESS_PROFILE_MAX_WEBSITES: usize = 2;

WhatsApp Web emits at most two <website/> nodes per profile mutation. A websites list longer than this is rejected client-side (BusinessProfileUpdateError::TooManyWebsites) rather than silently truncated, since the real client would drop the extra entries without telling you.

CoverPhotoUpload

The upload receipt a cover photo mutation has to quote back.

pub struct CoverPhotoUpload {
    /// `fbid` from the upload response.
    pub id: String,
    /// `meta_hmac` from the upload response.
    pub token: String,
    /// `ts` from the upload response.
    pub timestamp: i64,
}

These three values come from a biz-cover-photo media upload, whose response carries fbid/meta_hmac/ts instead of the url/direct_path pair every other media type returns. This crate does not yet perform that upload — the upload pipeline (src/upload.rs) parses url/direct_path out of every response, which the cover-photo endpoint doesn’t return. Obtain the receipt yourself and pass it in.

CatalogOptions

Paging and thumbnail options for get_catalog.

pub struct CatalogOptions {
    /// Products per page.
    pub limit: u32,
    /// Cursor from a previous page's `Catalog::after_cursor`.
    pub after: Option<String>,
    pub image_width: u32,
    pub image_height: u32,
    /// Lets the server include products surfaced through Shop as well as the
    /// business's own catalog.
    pub allow_shop_source: bool,
}

Default: limit: 10, after: None, image_width: 100, image_height: 100, allow_shop_source: true. These defaults are this client’s choice — WhatsApp Web computes them per-surface at the call site, so there’s no bundle constant to match. Override them per request.

CollectionOptions

Options for get_collections.

pub struct CollectionOptions {
    /// Collections per page.
    pub collection_limit: u32,
    /// Products returned inline per collection.
    pub item_limit: u32,
    pub after: Option<String>,
    pub image_width: u32,
    pub image_height: u32,
}

Default: collection_limit: 51, item_limit: 51, after: None, image_width: 100, image_height: 100.

Catalog

One page of a business catalog, returned by get_catalog.

#[non_exhaustive]
pub struct Catalog {
    pub products: Vec<Product>,
    /// Cursor for the next page; `None` when this is the last page. Pass it
    /// back as `CatalogOptions::after`.
    pub after_cursor: Option<String>,
    /// Cursor for the previous page.
    pub before_cursor: Option<String>,
}

Collections

One page of a business’s collections, returned by get_collections.

#[non_exhaustive]
pub struct Collections {
    pub collections: Vec<Collection>,
    /// Cursor for the next page; `None` on the last page. Pass it back as
    /// `CollectionOptions::after`.
    ///
    /// Unlike the catalog, this response carries a forward cursor only — there
    /// is no `before` in the collections paging object.
    pub after_cursor: Option<String>,
}

Collection

A named group of products within a catalog.

#[non_exhaustive]
pub struct Collection {
    pub id: Option<String>,
    pub name: Option<String>,
    /// The first `CollectionOptions::item_limit` products, inline.
    pub products: Vec<Product>,
    pub review_status: Option<String>,
    /// Whether a rejected collection can still be appealed.
    pub can_appeal: Option<bool>,
    /// Why the collection was rejected. Present only on a rejection.
    pub reject_reason: Option<String>,
    /// Where to review or appeal the decision.
    pub commerce_url: Option<String>,
}

Collection::products can be truncated, and says so only by its length: the collections query returns a prefix with no per-collection cursor, so products.len() == item_limit is the only signal more products may exist — it isn’t conclusive, since a collection with exactly that many products and no more reads the same way. Reading a collection to the end would need a different, not-yet-wired-up operation.

Product

A catalog product. Only id is guaranteed — every other field is optional because the server omits rather than blanks a missing value (an absent name is None, never ""; an absent is_hidden is None, never false).

#[non_exhaustive]
pub struct Product {
    pub id: String,
    /// The merchant's own SKU, distinct from `id`.
    pub retailer_id: Option<String>,
    pub name: Option<String>,
    pub description: Option<String>,
    pub url: Option<String>,
    /// The link-shimmed form of `url`, sent alongside it rather than instead
    /// of it. Which one to open is a policy call left to the caller.
    pub shimmed_url: Option<String>,
    pub price: Option<Price>,
    pub sale_price: Option<SalePrice>,
    /// Hidden products stay in the catalog but are not shown to customers.
    pub is_hidden: Option<bool>,
    pub is_sanctioned: Option<bool>,
    /// Upper bound on the quantity a single order may contain.
    pub max_available: Option<i64>,
    pub availability: Option<ProductAvailability>,
    /// WhatsApp's review verdict, e.g. `APPROVED`.
    pub review_status: Option<String>,
    pub can_appeal: Option<bool>,
    /// Whether the product belongs to the queried business's own catalog.
    pub belongs_to: Option<bool>,
    pub images: Vec<ProductImage>,
    pub videos: Vec<ProductVideo>,
    pub compliance_category: Option<String>,
    pub country_code_origin: Option<String>,
    /// Importer of record, alongside `importer_address`.
    pub importer_name: Option<String>,
    pub importer_address: Option<ImporterAddress>,
}

Catalog and collection products never carry variant data (variant_info is opt-in on the wire and this crate doesn’t request it), so there’s no variant_properties field here. Order line items are the one place variant data is surfaced — see OrderProduct.

Price

A price, in thousandths of the currency’s main unit — not hundredths.

pub struct Price {
    /// Thousandths of one currency unit: `1_990` is 1.99 in `currency`.
    pub amount_1000: i64,
    /// ISO 4217 code. Absent when the server sends a price without one.
    pub currency: Option<String>,
}

WhatsApp Web’s protobuf field is priceAmount1000: int64, formatted through formatAmount1000. Keeping the raw integer avoids rounding — dividing by 1000 into a float is a display-time decision for the caller to make.

SalePrice

#[non_exhaustive]
pub struct SalePrice {
    pub price: Price,
    /// Both ends or neither: a lone endpoint is normalized away rather than
    /// surfacing a period WhatsApp Web itself does not honour.
    pub start_date: Option<String>,
    pub end_date: Option<String>,
}

ProductImage

#[non_exhaustive]
pub struct ProductImage {
    pub id: Option<String>,
    /// URL at the dimensions the request asked for.
    pub request_image_url: Option<String>,
    /// URL at the image's stored dimensions.
    pub original_image_url: Option<String>,
}

ProductVideo

#[non_exhaustive]
pub struct ProductVideo {
    pub id: Option<String>,
    pub original_video_url: Option<String>,
    pub thumbnail_url: Option<String>,
}

ImporterAddress

A postal address, sent for a product’s importer of record. Every part is optional — the server omits what it does not hold rather than sending an empty string.

#[non_exhaustive]
pub struct ImporterAddress {
    pub street1: Option<String>,
    pub street2: Option<String>,
    pub city: Option<String>,
    pub region: Option<String>,
    pub postal_code: Option<String>,
    pub country_code: Option<String>,
}

ProductAvailability

Whether a product can currently be bought. The wire values are the GraphQL enum names.

#[non_exhaustive]
pub enum ProductAvailability {
    InStock,                        // "IN_STOCK"
    OutOfStock,                     // "OUT_OF_STOCK"
    AvailableForAnotherPostcode,    // "AVAILABLE_FOR_ANOTHER_POSTCODE"
    Other(String),
}

Order

Returned by get_order.

#[non_exhaustive]
pub struct Order {
    pub products: Vec<OrderProduct>,
    pub price_details: Option<OrderPriceDetails>,
    /// Unix seconds, as sent. Absent when the server omits it.
    pub creation_timestamp: Option<i64>,
}

OrderProduct

A line item on an order — a snapshot rather than a live product: the price is what was quoted when the order was placed.

#[non_exhaustive]
pub struct OrderProduct {
    pub id: Option<String>,
    pub name: Option<String>,
    pub price: Option<Price>,
    pub quantity: Option<i64>,
    pub images: Vec<ProductImage>,
    /// The variant the customer actually chose — size, colour, and the like.
    /// Empty for a product with no variants.
    pub variant_properties: Vec<VariantProperty>,
}

VariantProperty

One dimension of a chosen product variant, e.g. name: "Size", value: "Large".

#[non_exhaustive]
pub struct VariantProperty {
    pub name: Option<String>,
    pub value: Option<String>,
}

OrderPriceDetails

#[non_exhaustive]
pub struct OrderPriceDetails {
    pub currency: Option<String>,
    pub subtotal: Option<Price>,
    pub total: Option<Price>,
}

Validation

update_profile validates a BusinessProfileUpdate before sending anything, because the server rejects a business_profile delta on any single bad field — losing the other, valid fields in the same update. All of the following surface as BusinessError::InvalidUpdate(BusinessProfileUpdateError::...):

Empty delta (Empty) — every field is None, so the update would be a no-op.
Too many websites (TooManyWebsites { count }) — more than BUSINESS_PROFILE_MAX_WEBSITES (2) entries in websites.
Invalid coordinate (InvalidCoordinate { axis, value, limit }) — latitude/longitude outside ±90°/±180°, or non-finite (NaN/inf).
Invalid business-hour time (InvalidBusinessHourTime { day, field, value }) — open_time/close_time must be less than 1440 (minutes in a day). Ranges that cross midnight (open_time > close_time) are legal — WhatsApp Web’s picker UI discourages them, but the wire format doesn’t forbid them.
Incomplete business-hour range (IncompleteBusinessHourRange { day }) — open_time and close_time must both be set or both be absent.
Mismatched business-hour mode (MismatchedBusinessHourMode { day, mode, expectation }) — SpecificHours requires a range; Open24H and AppointmentOnly must not carry one. An unrecognized Other(...) mode is never checked this way.

Error handling

#[non_exhaustive]
pub enum BusinessError {
    Mex(MexError),
    Request(IqError),
    InvalidUpdate(BusinessProfileUpdateError),
    /// The response was structurally valid JSON but missing a field the
    /// operation is defined by, or carrying it with the wrong shape.
    MalformedResponse {
        operation: &'static str,
        detail: String,
    },
}

get_catalog, get_collections, and get_order return BusinessError::Mex on a failed MEX call and BusinessError::MalformedResponse on a structurally-unexpected (but successfully-fetched) response. update_profile, set_cover_photo, and remove_cover_photo return BusinessError::Request on a failed IQ, and update_profile additionally returns BusinessError::InvalidUpdate when client-side validation rejects the delta (see Validation).

Not yet supported

Product create/edit/delete. Only reads exist (get_catalog, get_collections, get_order) — there is no product-mutation surface in this crate. WhatsApp Web itself has no such operation to mirror; only third-party clients expose one against the legacy IQ transport.
Uploading a new cover photo. set_cover_photo requires a pre-uploaded CoverPhotoUpload receipt because the biz-cover-photo media type isn’t wired into this crate’s upload pipeline yet.
Reading a full (untruncated) collection. get_collections returns a possibly-truncated product prefix per collection with no way to page further within one collection.
Catalog/collection variant data. Only orders carry variant_properties; requesting variant info for catalog/collection products isn’t implemented.

Business events

Business account changes are reported through the event system. Subscribe to BusinessStatusUpdate events to track changes:

use wacore::types::events::{Event, BusinessStatusUpdate, BusinessUpdateType};

match event {
    Event::BusinessStatusUpdate(update) => {
        match update.update_type {
            BusinessUpdateType::VerifiedNameChanged => {
                println!("Verified name: {:?}", update.verified_name);
            }
            BusinessUpdateType::ProfileUpdated => {
                println!("Business profile updated for {}", update.jid);
            }
            BusinessUpdateType::RemovedAsBusiness => {
                println!("{} is no longer a business account", update.jid);
            }
            BusinessUpdateType::ProductsUpdated => {
                println!("Products updated: {:?}", update.product_ids);
            }
            BusinessUpdateType::CollectionsUpdated => {
                println!("Collections updated: {:?}", update.collection_ids);
            }
            BusinessUpdateType::SubscriptionsUpdated => {
                println!("Subscriptions: {:?}", update.subscriptions);
            }
            _ => {}
        }
    }
    _ => {}
}

See Events for the full BusinessStatusUpdate type.

Checking if a contact is a business

You can check if a contact is a business account using the contacts API:

let results = client.contacts().is_on_whatsapp(&[Jid::pn("15551234567")]).await?;

for result in &results {
    if result.is_business {
        println!("{} is a business account", result.jid);
    }
}

See Contacts API for details.

Automatic business stanza detection

When sending interactive business messages (native-flow buttons for payments, CTAs, catalogs, etc.), the library automatically injects a <biz> stanza child node on the outgoing message. This means you can send InteractiveMessage with NativeFlowMessage content through send_message or send_message_with_options without manually constructing business protocol nodes. See Send API - Automatic business node detection for the full list of supported button-to-flow mappings.

​Access

​Methods

​get_business_profile

​get_catalog

​get_collections

​get_order

​update_profile

​set_cover_photo

​remove_cover_photo

​Types

​BusinessProfile

​BusinessCategory

​BusinessHours

​BusinessHoursConfig

​DayOfWeek

​BusinessHourMode

​BusinessHoursUpdate

​BusinessProfileUpdate

​BUSINESS_PROFILE_MAX_WEBSITES

​CoverPhotoUpload

​CatalogOptions

​CollectionOptions

​Catalog

​Collections

​Collection

​Product

​Price

​SalePrice

​ProductImage

​ProductVideo

​ImporterAddress

​ProductAvailability

​Order

​OrderProduct

​VariantProperty

​OrderPriceDetails

​Validation

​Error handling

​Not yet supported

​Business events

​Checking if a contact is a business

​Automatic business stanza detection

​See also

Access

Methods

get_business_profile

get_catalog

get_collections

get_order

update_profile

set_cover_photo

remove_cover_photo

Types

BusinessProfile

BusinessCategory

BusinessHours

BusinessHoursConfig

DayOfWeek

BusinessHourMode

BusinessHoursUpdate

BusinessProfileUpdate

BUSINESS_PROFILE_MAX_WEBSITES

CoverPhotoUpload

CatalogOptions

CollectionOptions

Catalog

Collections

Collection

Product

Price

SalePrice

ProductImage

ProductVideo

ImporterAddress

ProductAvailability

Order

OrderProduct

VariantProperty

OrderPriceDetails

Validation

Error handling

Not yet supported

Business events

Checking if a contact is a business

Automatic business stanza detection

See also