Add Microdata Tags in Item Feed File (Optional)

You can use these protocols to add the microdata:

  • OpenGraph — Place the microdata in the header of your website.
  • Schema.org — Place the microdata across the product page where the products are located.
  • JSON-LD for Schema.org — Place the microdata within the script tag (see the example below).

Depending on the type of protocol you choose, the microdata needs to be in the right location on your website.

To test if your microdata tags are working, use this microdata debugger tool.

OpenGraph – Required Tags

NameDescription

og:title

Title of the item.

og:description

Description of the item.

og:url

Complete URL for the product page.

og:image

Link to the image used on the product page.

product:brand

Brand name of the item.

product:availability

Current availability of the item: in stock, out of stock, preorder, available for order, discontinued.

product:condition

Current condition of the item: new, refurbished, used.

product:price:amount

Current price of the item. Don't include symbols, such as “$” in the price.

product:price:currency

Currency for the price in ISO format (for example, USD).

product:retailer_item_id

Retailer's ID for the item.

Example - OpenGraph

<meta property="og:title" content="Facebook T-Shirt">

<meta property="og:description" content="Unisex Facebook T-shirt, Small">

<meta property="og:url" content="https://example.org/facebook">

<meta property="og:image" content="https://example.org/facebook.jpg">

<meta property="product:brand" content="Facebook">

<meta property="product:availability" content="in stock">

<meta property="product:condition" content="new">

<meta property="product:price:amount" content="9.99">

<meta property="product:price:currency" content="USD">

<meta property="product:retailer_item_id" content="facebook_tshirt_001">

Schema.org – Required Tags

NameDescription

name

Title of the item.

brand

Brand of the item.

description

Description of the item.

productID

Retailer's ID for the item.

url

Complete URL for the product page.

image

Link to the image used on the product page.

price

Current price of the item. Don't include symbols, such as “$” in the price. Include this entry under “offers”.

priceCurrency

Currency for the price, in ISO format (for example, USD). Include this entry under “offers”.

availability

Current availability of the item: in stock, out of stock, preorder, available for order, discontinued. Include this entry under “offers”.

condition

Current condition of the item: new, refurbished, or used. Include this entry under “offers”.

Example - Schema.org

curl \
    <div itemscope itemtype="http://schema.org/Store">
<div id="..." class="..." itemscope="" itemtype="http://schema.org/Product">
...
<meta itemprop="brand" content="facebook">
<meta itemprop="name" content="Facebook T-Shirt">
<meta itemprop="description" content="Unisex Facebook T-shirt, Small">
<meta itemprop="productID" content="facebook_tshirt_001">
<meta itemprop="url" content="https://example.org/facebook">
<meta itemprop="image" content="https://example.org/facebook.jpg">
...
<span itemprop="offers" itemscope itemtype="http://schema.org/Offer" itemref="schema-offer">
<link itemprop="availability" href="http://schema.org/InStock">
<link itemprop="itemCondition" href="http://schema.org/NewCondition">
<div class="..." itemprop="price"&gt;7.99&lt;/div>
<meta itemprop="priceCurrency" content="USD">
...
        </span>
        ...
       </div><div itemscope itemtype="">

JSON-LD for Schema.org

Extracted from schema.org/Product

NameDescription

name

Title of the item.

brand

Brand of the item.

description

Description of the item.

productID

Retailer's ID for the item.

url

Complete URL for the product page.

offers

Vector of objects of type schema.org/Offer.

image

Link to the image used on the product page.

Extracted from schema.org/Offer (as a part of product offers)

NameDescription

price

Current price of the item. Don't include symbols, such as “$” in the price. Include this entry under “offers”.

priceCurrency

Currency for the price, in ISO format (for example, USD). Include this entry under “offers”.

availability

Current availability of the item: in stock, out of stock, preorder, available for order, discontinued. Include this entry under “offers”.

condition

Current condition of the item: new, refurbished, or used. Include this entry under “offers”.

Example — schema.org/Offer

<script type="application/ld+json">

       {
  
        "@context":"https://schema.org",
        "@type":"Product",
        "productID":"facebook_tshirt_001",
        "name":"Facebook T-Shirt",
        "description":"Unisex Facebook T-shirt, Small",
        "url":"https://example.org/facebook",
        "image": "https://example.org/facebook.jpg",
        "brand":"facebook",
        "offers":[
        {
        "@type":"Offer",
        "price":"7.99",
        "priceCurrency":"USD",
        "itemCondition":"https://schema.org/NewCondition",
        "availability":"https://schema.org/InStock"
        }
        ]
        <script>

Learn more about microdata tags for catalogs.

Set Metadata Tags in Item Feed File (Optional)

You can optionally set metadata tags in your product feed files. This enables Facebook to attribute catalogs using this feed to your app. Once a catalog is attributed to your app, the meta tag is not required in subsequent feed uploads to that catalog.

Include the following two elements as space-delimited comments at the top of TSV/CSV feeds or inside a metadata tag in your XML feeds:

  • ref_application_id — Your Facebook app ID
  • ref_asset_id - ID that uniquely identifies this feed in your system

Feed Formats


Feed Format Description

CSV

Sample CSV Feed file with reference information inside the metadata tag.

Download (Right-Click > Save Link As)

TSV

Sample TSV Feed file with reference information inside the metadata tag.

Download (Right-Click > Save Link As)

RSS XML

Sample RSS XML Feed file with reference information inside the metadata tag.

Download (Right-Click > Save Link As)

ATOM XML

Sample Atom XML Feed file with reference information inside the metadata tag.

Download (Right-Click > Save Link As)

Example - TSV Feed Format

# ref_application_id <YOUR_APP_ID>
# ref_asset_id <YOUR_ASSET_ID>
id  title  ios_url  ios_app_store_id  ios_app_name  android_url  android_package  android_app_name  windows_phone_url  windows_phone_app_id  windows_phone_app_name  description  google_product_category  product_type  link  image_link  condition  availability  price  sale_price  sale_price_effective_date  gtin  brand  mpn  item_group_id  gender  age_group  color  size  shipping  custom_label_0
DB_1  Dog Bowl In Blue  example-ios://electronic/db_1  123  Electronic Example iOS  example-android://electronic/db_1  com.electronic.example  Electronic Example Android  example-windows://electronic/db_1  64ec0d1b-5b3b-4c77-a86b-5e12d465edc0  Electronic Example Windows  Solid plastic Dog Bowl in marine blue color  Animals > Pet Supplies  Bowls & Dining > Food & Water Bowls  http://www.example.com/bowls/db-1.html  https://www.facebook.com/images/product_image_template.png?id=1  new  in stock  9.99 GBP        Example    DB_GROUP_1          UK::Standard:9.95 GBP  "Made in Waterford, IE"
...

Example - XML Feed Format

...
<?xml version="1.0"?>
<rss xmlns:g="http://base.google.com/ns/1.0" version="2.0">
  ...
  <metadata>
    <ref_application_id><YOUR_APP_ID></ref_application_id>
    <ref_asset_id><YOUR_ASSET_ID></ref_asset_id>
  </metadata>
  ...
</rss>
...

Enable More Frequent Data Feed Fetches

When you enable the Automatically upload new versions option for your scheduled feed, your data feed file is uploaded whenever we detect the file has changed.

We use the following HTTP headers to detect whether the file has changed:

  • If your server provides an ETag header in the HTTP response, we send the If-None-Match header in the next HTTP request with the entity tag from the ETag header.
  • If your server provides a Last-Modified header in the HTTP response, we send the If-Modified-Since header in the next HTTP request with the timestamp from the Last-Modified header.

If your server returns the following HTTP status codes:

  • 304 Not Modified — We consider the file to be unchanged since the last feed file fetch.
  • 200 OK — The feed file will be uploaded.

Example - ETag header

When we download your feed file, your server provides the ETag header with the feed file hash in the HTTP response:

ETag: "9fc22f3c8e9ab7ff8b7ebd0b3e34cb42bb2f9b22"

In the next HTTP request, we provide the If-None-Match header with the same entity tag:

If-None-Match: "33a64df551425fcc55e4d42a148795d9f25f89d4"

If your server returns the following HTTP status codes:

  • 304 Not Modified — We consider the file to be unchanged since the last feed file fetch.
  • 200 OK — The feed file will be uploaded.

Example - Last-Modified header

When we download your feed file, your server will provide the Last-Modified header with the timestamp of the last feed file change in the HTTP response:

Last-Modified: Thu, 15 Aug 2019 18:24:03 GMT

In the next HTTP request, we provide the If-Modified-Since header with the same timestamp:

If-Modified-Since: Thu, 15 Aug 2019 18:24:03 GMT

If your server returns the following HTTP status codes:

  • 304 Not Modified — We consider the file to be unchanged since the last feed file fetch.
  • 200 OK — The feed file will be uploaded.

Schedule Data Feed Fetches

Scheduled feeds don't support uploads more frequently than once per hour. If you need to update inventory faster, we recommend to use the Direct Upload API.

If you're using our API to create and manage your feeds, you need to send us an API request with details for the update schedule you want to create:

curl \
  -F 'name=Test Feed' \
  -F 'update_schedule={ 
    "interval": "HOURLY", 
    "url": "http:\/\/www.example.com\/sample_feed_updates.tsv",
    "hour": 22
  }' \
  -F 'access_token=<ACCESS_TOKEN>' \
  https://graph.facebook.com/<API_VERSION>/<CATALOG_ID>/product_feeds

We fetch item feeds from your system on a schedule you define. There are two types of schedules you can define:

  • update_schedule — The uploads create new items or update existing ones with the information provided in the data feed file.
  • schedule — The uploads result in a complete refresh operation on your data feed. We delete items not present in the file, update existing ones, and create new ones. You can use either of the schedules, or both, depending on your needs.

For example: update_schedule with frequency HOURLY and a replace schedule with frequency DAILY.

We recommend setting up an update_schedule with only changed data in the data feed file for faster processing of feed. This is particularly better for holiday sales and faster price and availability updates. It's also recommended to mark items as "out of stock" rather than deleting from the feed so that we can retarget the user with similar available items.

curl \
  -F 'name=Test Feed' \
  -F 'schedule={ 
    "interval": "DAILY", 
    "url": "http:\/\/www.example.com\/sample_feed.tsv"
  }' \
  -F 'update_schedule={ 
    "interval": "HOURLY", 
    "url": "http:\/\/www.example.com\/sample_feed_updates.tsv",
    "hour": 22
  }' \
  -F 'access_token=<ACCESS_TOKEN>' \
  https://graph.facebook.com/<API_VERSION>/<CATALOG_ID>/product_feeds

Response:

{ "id" : {FEED_ID} }

See Data Feed Reference, Data Feed Schedule Reference.

Perform One-Time Direct Upload

Along with scheduled feed fetches, you can manually perform one-time uploads.

Example — Feed files hosted on a public location

curl \
  -F "url=http://www.example.com/sample_feed.xml" \
  -F "access_token={ACCESS_TOKEN}" \
  https://graph.facebook.com/{API_VERSION}/{FEED_ID}/uploads

Example — Uploading feed files directly from the local machine. The path to the file needs to be changed according to your use case.

curl \
  -F "file=@catalog.csv;type=text/csv" \
  -F "access_token={ACCESS_TOKEN}" \
  https://graph.facebook.com/{API_VERSION}/{FEED_ID}/uploads

Optionally, you can set update_only to true. We create new items and update existing ones, but don't delete items from the feed. You only need to provide id to update existing items. This reduces time to fetch and process your file.

For example, to update only price and custom labels for 100 items in a feed, use direct upload. Provide a file with only id, price and custom_label_0 for those items and update_only set to true. We support all listed file formats; the most common ones are TSV and CSV. See Supported Feed Formats for more information.

Feed Format per Use Case

Feed Format Use Case Sample Feed

CSV

Update price and availability for a subset of items.

Download (Right-Click and Save Link As)

TSV

Reset sale_price and update custom_label_0 for a subset of items

Download (Right-Click and Save Link As)

See Manual Product Feed Uploads, Reference.

If you get errors in your feed, see Product Feed Upload Errors, Reference.

See also Uploading Inventory, Commerce Platform.

Upload Your Feed

To upload a feed, you need ads_management permission. See Marketing API, Permissions. After you create a catalog, use catalog id to create and schedule a Product Feed:

curl -X POST \ -F 'name="Test Feed"' \ -F 'schedule={ "interval": "DAILY", "url": "http://www.example.com/sample_feed.tsv", "hour": "22" }' \ -F 'access_token=<ACCESS_TOKEN>' \ https://graph.facebook.com/v5.0/{product-catalog-id}/product_feeds
'use strict'; const bizSdk = require('facebook-nodejs-business-sdk'); const ProductCatalog = bizSdk.ProductCatalog; const ProductFeed = bizSdk.ProductFeed; const access_token = '<ACCESS_TOKEN>'; const app_secret = '<APP_SECRET>'; const app_id = '<APP_ID>'; const id = '<ID>'; const api = bizSdk.FacebookAdsApi.init(access_token); const showDebugingInfo = true; // Setting this to true shows more debugging info. if (showDebugingInfo) { api.setDebug(true); } const logApiCallResult = (apiCallName, data) => { console.log(apiCallName); if (showDebugingInfo) { console.log('Data:' + JSON.stringify(data)); } }; let fields, params; fields = [ ]; params = { 'name' : 'Test Feed', 'schedule' : {'interval':'DAILY','url':'http://www.example.com/sample_feed.tsv','hour':'22'}, }; const product_feeds = (new ProductCatalog(id)).createProductFeed( fields, params ); logApiCallResult('product_feeds api call complete.', product_feeds);
require __DIR__ . '/vendor/autoload.php'; use FacebookAds\Object\ProductCatalog; use FacebookAds\Object\ProductFeed; use FacebookAds\Api; use FacebookAds\Logger\CurlLogger; $access_token = '<ACCESS_TOKEN>'; $app_secret = '<APP_SECRET>'; $app_id = '<APP_ID>'; $id = '<ID>'; $api = Api::init($app_id, $app_secret, $access_token); $api->setLogger(new CurlLogger()); $fields = array( ); $params = array( 'name' => 'Test Feed', 'schedule' => array('interval' => 'DAILY','url' => 'http://www.example.com/sample_feed.tsv','hour' => '22'), ); echo json_encode((new ProductCatalog($id))->createProductFeed( $fields, $params )->exportAllData(), JSON_PRETTY_PRINT);
from facebook_business.adobjects.productcatalog import ProductCatalog from facebook_business.adobjects.productfeed import ProductFeed from facebook_business.api import FacebookAdsApi access_token = '<ACCESS_TOKEN>' app_secret = '<APP_SECRET>' app_id = '<APP_ID>' id = '<ID>' FacebookAdsApi.init(access_token=access_token) fields = [ ] params = { 'name': 'Test Feed', 'schedule': {'interval':'DAILY','url':'http://www.example.com/sample_feed.tsv','hour':'22'}, } print ProductCatalog(id).create_product_feed( fields=fields, params=params, )
import com.facebook.ads.sdk.*; import java.io.File; import java.util.Arrays; public class SAMPLE_CODE_EXAMPLE { public static void main (String args[]) throws APIException { String access_token = \"<ACCESS_TOKEN>\"; String app_secret = \"<APP_SECRET>\"; String app_id = \"<APP_ID>\"; String id = \"<ID>\"; APIContext context = new APIContext(access_token).enableDebug(true); new ProductCatalog(id, context).createProductFeed() .setName(\"Test Feed\") .setSchedule(\"{\\"interval\\":\\"DAILY\\",\\"url\\":\\"http://www.example.com/sample_feed.tsv\\",\\"hour\\":\\"22\\"}\") .execute(); } }
require 'facebook_ads' access_token = '<ACCESS_TOKEN>' app_secret = '<APP_SECRET>' app_id = '<APP_ID>' id = '<ID>' FacebookAds.configure do |config| config.access_token = access_token config.app_secret = app_secret end product_catalog = FacebookAds::ProductCatalog.get(id) product_feeds = product_catalog.product_feeds.create({ name: 'Test Feed', schedule: {'interval':'DAILY','url':'http://www.example.com/sample_feed.tsv','hour':'22'}, })

The schedule parameter enables you to schedule your feed upload. Options include interval, url, hour. It can also include day_of_week, minute, username, and password. For example:

schedule: {"day_of_week":"FRIDAY","hour":17,"interval_count":1,"interval":"DAILY","minute":42,"next_scheduled_upload_time":"","password":pwd123,"status":"active","timezone":"Atlantic/Canary","url":"https://www.abc.com","username":aname}

Learn how to read the Data Feed Upload Error Report.

Update an Individual Item

Update an individual item's data in real time. Include the updated fields in an HTTP POST:

https://graph.facebook.com/catalog:{CATALOG_ID}:{base64urlencode(retailer_id)}

Where retailer_id is the item ID from your feed. It must be base64url-encoded. See mutable fields in the Products, Reference.

Do not provide item feeds with individual item updates, creation, or deletion with the API. This can disrupt any updates or deletes of items you created with the API because we don't track these with the feed.

Update Inventory in Real-time

Universal Checkout Catalogs don't currently support using the Batch API for CREATE functions at this time. To create inventory, use the Feed API.

The system user (owner of the token) must be the admin of the catalog that you will change via the API.

Learn more about the Catalog Batch API.

To update products more frequently than the periodic fetches supported by Product Catalog, the Catalog Batch API may be used to perform real-time updates to individual products using retailer IDs. Any updates made through the Catalog Batch API should also be reflected in the product feed so that the updates are preserved after it is next fetched.

The Catalog Batch API supports updates to both availability and inventory parameters.

The Batch API does not provide error information in as much detail as the Feed API. Use Feed Upload errors as the source of truth.

The availability parameter is used in conjunction with inventory numbers. Items with availability of Out of Stock will not be purchasable even if inventory numbers are greater than zero. Items with availability of In Stock will not be purchasable if inventory is zero.

It is highly recommended not to remove Out of Stock items from your feed until a reasonable time has passed, since removing them will break deep links to the product from other sources.

Update Inventory in Commerce Catalogs

The inventory field in your product catalog represents the stock level for each product available to sell on your Facebook Shop or Instagram Shopping account. This value is reflected in the Product Details Page (PDP) and helps buyers understand how many items are available. Keeping it accurate and up-to-date is instrumental to the experience, as it dictates when your products are out-of-stock or can lead to overselling if incorrect.

The product feed is used as the source of truth for updating product catalogs on Facebook, and fetched by Facebook periodically according to the configured interval. You should store the product feed ID, and use it to get upload status, errors and to change upload schedule.

Commerce catalogs don't currently support using the Batch API for CREATE functions at this time. To create inventory programatically, use the supported fields.

POST https://graph.facebook.com/vX.X/{product-catalog-id}/product_feeds

Request


AttributeTypeRequired

name

string

Required

schedule

schedule

Required

schedule object

Read the Product Feed Schedule specification for more details.

AttributeTypeRequired

url

string

Required

interval

string

Required

hour

number

Optional

Scheduled feeds do not support uploads more frequently than once per hour. If you need to update inventory faster, use the Catalog Batch API.

Response

{
  "id": 215042069082048
}

This section describes important concepts associated with inventory management, including strategies to minimize over-selling:


Inventory Fluctuation

The inventory field is dynamic, which means that its value fluctuates as people buy products from your Facebook Shop or Instagram Shopping account. When a user places an order, the inventory level of the corresponding products is decremented.

The Commerce Platform automatically increment this value or restocks the product in case of user-initiated cancellations.

In the case of seller-initiated cancellations, you can restock a product at cancellation time and increment the corresponding inventory level, by setting the restock_items field of the cancellations API endpoint.

The value that you provide via your product catalog uploads or other techniques is considered the source of truth, and is always used to overwrite the value cached on our backend. Learn more about Inventory Update Strategies.


Out-Of-Stock Products

As people purchase products on your Facebook Shop or Instagram Shopping account, the inventory value is decremented. When this value reaches 0, we mark the product as "Out-Of-Stock" and restrict anyone from purchasing additional units. You should do a best-effort attempt at restocking your products regularly; "Out-Of-Stock" products negatively affect the user experience and your brand perception.

If a buyer finds an Out-Of-Stock product, we try our best to switch the product details page to a variant that has units In-Stock based on the inventory value of the product's variant in your product catalog.


Discontinued Products

Highly recommended — When a product is discontinued, don't delete it from your product catalog.

Deleting products from your catalog can cause undesirable effects, such as Instagram product tags disappearing or broken links. We strongly recommend that you only delete products after a significant time has passed (months). Instead of deleting products, you should set the visibility field of a discontinued product to staging. This ensures that the Commerce Platform can link your product back to a known entity and manage different situations gracefully.


Over-selling

To scale the Commerce Platform to thousands of merchants, we've made a conscious decision to not support synchronous inventory management. As a result, we don't support making atomic purchase transactions coupled with decrementing stock levels in your warehouse. If your inventory is shared across multiple channels, you may invariably over-sell products on Facebook or Instagram. This could happen for fast-selling products available in limited quantity.

When you can't fulfill orders due to over-selling situations, you should initiate a cancellation and set the reason_code to OUT_OF_STOCK.

An effective way to mitigate against over-selling is to track products being purchased on the Commerce Platform in an accurate and timely manner. Assuming that you're already tracking fulfilled orders (IN_PROGRESS or later stage), the real stock value for a given product can be calculated. Once this value is determined, you can override the inventory value in your product catalog accordingly.

A: Products available to sell
I: Inventory level in your warehouse
P: Quantity of products attached to orders in FB_PROCESSING state
C: Quantity of products attached to orders in CREATED state which you did not sync with your warehouse inventory

If you are frequently faced with overselling, you can fetch orders at a more frequent basis to identify the number of orders pending on the Commerce Platform, and adjust the inventory level of your products accordingly.


Inventory Update Strategies

Because of the asynchronous nature of distributed systems, the inventory value in your product catalog may go out-of-sync, regardless how fast you update your inventory levels. Here are some techniques that you may want to consider, to minimize race-conditions:

Pre-allocated Inventory

The most effective way to avoid over-selling is to pre-allocate inventory to your Facebook Shop or Instagram Shopping channels. Dedicating inventory for each of your sales channel guarantees that sales happening on any individual channel will not interfere with each other. This strategy can be applied to part or the totality of your product catalog.

Slow-Selling Products

For products that sell at a normal pace, or those with deep inventory, the risk of over-selling is relatively low. In this situation, you can keep your product catalog update strategy simple:

  • Configure a Replace Feed for daily updates. This feed should contain all fields, including the most up-to-date inventory value.
  • Configure a Update Feed with incremental updates (typically the inventory field) at a frequency that feels reasonable. You can start with updates every 12 hours, and increase the frequency as you see fit.

Fast-Selling Products

For fast-selling products, with shallow or very dynamic inventory, you may want to update volatile fields such as inventory in a more timely basis. You can use the Real-Time Batch API for this purpose. Here's a general strategy that you can follow:

  • Configure a Replace Feed for daily updates. This feed should contain all mandatory Product Catalog fields, and omit volatile fields such as inventory. The purpose of this feed is to update fields that are more static in nature, and defer the updates of volatile fields using the Real-Time API.
  • Use the Real-Time Batch API to update volatile fields such as inventory when the value changes in your backend, or at a fixed frequency. It is important that the fields updated using this technique are not included in your Replace Feed for consistency reasons.

Here's an example of updates using the Real-Time Batch API:

curl \
  -d @body.json \
  -H "Content-Type: application/json"
  {
    "access_token": "<ACCESS_TOKEN>",
    "item_type": "PRODUCT_ITEM",
    "requests": [      
      {
        "method": "UPDATE",
        "retailer_id": "SKU1234567",
        "data": {
          "inventory": "1337",
        }
      }
    ]
  } https://graph.facebook.com/<CATALOG_ID/batch

Batch API requests are asynchronous. You should check for the request status and its result to make sure that all your updates are successful. Learn more about Batch API, commerce.

If you're managing a small number of products, you can also update each product individually using the Graph API directly in lieu of the Real-Time Batch API. Because of Graph API rate-limiting and throttling, this approach is only applicable to a small number of products. The exact number of products you can update using this approach depends on the quota applied to your Facebook app. We recommend that you use the Real-Time Batch API if you're updating more than a dozen of products at a time.

Here's an example of updates using the Graph API:

curl -d "inventory=1337" -X POST https://graph.facebook.com/<FACEBOOK_PRODUCT_ID>
access_token: PAGE_ACCESS_TOKEN

If using the Graph API, use a Facebook product ID. If using the batch API, use your own ID (the retailer_id).

Hybrid Catalog (slow & fast selling products)

Not all of your products will sell at the same velocity. This obviously depends on the popularity of your products, but also how you market or promote them.

You can partition your products using multiple product feeds. For example, you may create one feed dedicated to fast-selling products, and another one specialized for slow-selling products. You could then apply different strategies described above to each of your product feeds. A given product (identified by the id field) can only exist in one and only one Product Feed at any time.

Inventory Thresholds

Another common technique to mitigate against over-selling is to take a pessimistic approach to inventory allocation. For example, when a particular item is close to running Out-Of-Stock as identified in your warehouse, you can set the inventory level in your Product Catalog to zero. This is effectively an optimization for under-selling, but can help if over-selling is a concern.

If you know how fast each of your products sell, you can partition them into different buckets and apply a different threshold for each bucket depending on its selling profile. Fast selling products typically need a higher threshold value, while slow selling products can probably use a lower threshold value for being marked "Out-Of-Stock".

Test Your Feed

Test your feed through our feed debug page.

  • For CSV or TSV, copy the first row (column header row) and a few products.
  • For XML, copy the XML with a few item/entry, paste the lines into the text area and validate.

To get feedback about the quality and performance of your different dynamic ads assets, see Catalog and Signals Quality.

Next Steps

If you encounter any data feed issues and need solutions, see Troubleshoot Your Data Feed.