> ## Documentation Index
> Fetch the complete documentation index at: https://docs.tryprofound.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Using Salsify in Agents

> Learn how to manage products and list memberships with Salsify Agent nodes

After you [connect your Salsify organization](/integrations/salsify/connect-salsify-to-profound), the following nodes become available in Profound Agents. Use them to read product content from a Salsify Product List, improve it with other Agent nodes, write it back, and record which products are done.

Every node runs against the organization you select under **Salsify Organization** and uses the permissions of the Salsify user that owns the API key.

<Note>
  New to Agents? See [Getting started with Agents](https://help.tryprofound.com/articles/2212787792-create-an-agent) in the Profound Help Center.
</Note>

## Available nodes

<Tabs>
  <Tab title="List Products" icon="list">
    ### List Products

    Reads a page of products from one or more Salsify Product Lists. A Product List scope is always required: Profound never reads the whole Salsify organization.

    #### Required inputs

    * **Salsify Organization** — Select a connected organization from the dropdown
    * **Product Lists** — The IDs of the Product Lists to read from

    #### Optional inputs

    | Input                                          | Default | Description                                                                                                                                           | Limits                                                                                                                                                                                                      |
    | ---------------------------------------------- | ------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
    | **Match**                                      | **OR**  | How the Product Lists combine. **OR** reads products in any of the lists, **AND** reads only products in every list.                                  | -                                                                                                                                                                                                           |
    | **Excluded Lists**                             | -       | The IDs of Product Lists whose members are left out of the result.                                                                                    | -                                                                                                                                                                                                           |
    | **Property Equality**                          | -       | One or more property and value pairs that a product must match. Select **Add clause**, then enter the case-sensitive property ID and the exact value. | An alternative to **Advanced Filter**, the two can't be used together. A property ID or value can't contain `,` `=` `^` `:` `'` `{` `}` or `*`. To match those characters, use **Advanced Filter** instead. |
    | **Raw Filter** (under **Query options**)       | -       | Edit the whole filter as JSON, including keys the fields above don't show.                                                                            | -                                                                                                                                                                                                           |
    | **Advanced Filter** (under **Query options**)  | -       | A raw [Salsify filter expression](https://developers.salsify.com/reference/salsify-filtering-language-syntax) that narrows the lists.                 | An alternative to **Property Equality**, the two can't be used together. Can't contain an equals sign (`=`).                                                                                                |
    | **Page** (under **Query options**)             | `1`     | Which page to read.                                                                                                                                   | Page multiplied by results per page can't exceed `10,000`.                                                                                                                                                  |
    | **Results per Page** (under **Query options**) | `100`   | Products per page.                                                                                                                                    | `100` is the maximum.                                                                                                                                                                                       |

    #### Output

    A JSON object with a `data` array of products and a metadata object with the pagination details and the total number of matching products.

    <Tip>
      Combine **Product Lists** with **Excluded Lists** to [build a work queue](#build-a-work-queue). Read the source list and exclude the destination list, so each run returns only the products that aren't done yet.
    </Tip>
  </Tab>

  <Tab title="Get Product" icon="box">
    ### Get Product

    Reads every property of one product.

    #### Required inputs

    * **Salsify Organization** — Select a connected organization from the dropdown
    * **Product ID** — Your organization's product ID, often the SKU. Case-sensitive. Enter it as text or use a variable from a previous node's output

    #### Output

    A JSON object with the product details under `data`. Localizable properties come back as objects keyed by locale, for example `"Entity Name": { "en-US": "Java Monster Energy Drink, 12-Pack, 15 Oz Cans", "fr-FR": ... }`.

    <Tip>
      Run this node once during setup. The output shows the property IDs your organization uses and which of them are localizable.
    </Tip>
  </Tab>

  <Tab title="Create Products" icon="plus">
    ### Create Products

    Creates up to 100 products in one run. Only creates the product records and doesn't add them to Product Lists.

    #### Required inputs

    * **Salsify Organization** — Select a connected organization from the dropdown
    * **Properties** — The properties to include in the new product record. Enter a **Sample product ID** to use an existing product as a template: list the properties that product carries, then pick the ones you need for the new product.
    * **Data format**:
      * **Structured** — Shows one card per product with a field for each property.
      * **Raw JSON** — Takes an array of objects that map property IDs to values. Accepts a variable from an earlier node's output.
    * **Products** — Up to 100 products. Every product must include your organization's product ID property, often the SKU, with a unique value.

    #### Output

    When the products are created, the node returns a JSON object with the count of created products. The node doesn't return the created products' data, use [**Get Product**](#get-product) to read it.
  </Tab>

  <Tab title="Update Products" icon="pen-to-square">
    ### Update Products

    Updates up to 100 existing products in one run. Only the properties you supply change, and every other property stays as is.

    #### Required inputs

    * **Salsify Organization** — Select a connected organization from the dropdown
    * **Properties** — Product properties to update. Enter a **Sample product ID** to use an existing product as a template: list the properties that product carries, then pick the ones you need to add to the product being updated.
    * **Data format**:
      * **Structured** — Shows one card per product with a field for each property.
      * **Raw JSON** — Takes an array of objects that map property IDs to values. Can accept variables from earlier nodes' outputs.
    * **Products** — Up to 100 products. Each product ID may appear once and is case-sensitive. Leave the property empty to remove the property in Salsify.

    #### Output

    The node returns a JSON object with the count and the IDs of the products it attempted to update. The updated products are listed under `product_ids`, and the products Salsify has no record of are listed under `not_found`.

    <Note>
      This node can change every property except the product's ID.
    </Note>
  </Tab>

  <Tab title="Add Products to List" icon="list-check">
    ### Add Products to List

    Adds up to 100 existing products to a Salsify Product List.

    #### Required inputs

    * **Salsify Organization** — Select a connected organization from the dropdown
    * **Product List ID** — The ID of the destination list, from the Salsify URL after `product_lists/` and before any query parameters (`?`)
    * **Product IDs** — A list of product IDs or a variable that holds the list

    #### Output

    When the products are added, the node returns a JSON object with the count of added products, their IDs, and the destination Product List ID.

    <Note>
      Salsify applies the changes asynchronously, so a [**List Products**](#list-products) node that runs immediately after this node may not show the change.
    </Note>
  </Tab>

  <Tab title="Remove Products from List" icon="minus">
    ### Remove Products from List

    Removes up to 100 products from a Salsify Product List. The change applies to list membership only, the product records stay in Salsify.

    #### Required inputs

    * **Salsify Organization** — Select a connected organization from the dropdown
    * **Product List ID** — The ID of the list, from the Salsify URL after `product_lists/` and before any query parameters (`?`)
    * **Product IDs** — A list of product IDs or a variable that holds the list

    #### Output

    When the products are removed, the node returns a JSON object with the count of removed products, their IDs, and the Product List ID.

    <Note>
      Salsify applies the changes asynchronously, so a [**List Products**](#list-products) node that runs immediately after this node may not show the change.
    </Note>
  </Tab>
</Tabs>

***

## Build a work queue

The Salsify nodes are designed to run as a loop: each run takes a batch of products from a source list, improves the content, writes it back to Salsify, and moves the finished products to a destination list. This work queue lets one Agent improve a whole product catalog one batch at a time.

Here's an example of a work queue.

<Steps>
  <Step title="Create a source list and a destination list" id="queue-step-1">
    In Salsify, create two Product Lists, for example `Profound: to optimize` and `Profound: optimized`. Add the products you want to work on to the `to optimize` list and leave the `optimized` list empty.
  </Step>

  <Step title="Read the source list with List Products" id="queue-step-2">
    Add a [**List Products**](#list-products) node. Enter the `to optimize` list ID under **Product Lists** and the `optimized` list ID under **Excluded Lists**, so a product that's already finished is never read again.
  </Step>

  <Step title="Improve the content" id="queue-step-3">
    Pass the products to your content nodes (such as a [Prompt LLM](https://help.tryprofound.com/articles/1457177722-prompt-llm)) to rewrite the marketing copy on each product record.
  </Step>

  <Step title="Write the content back with Update Products" id="queue-step-4">
    Add an [**Update Products**](#update-products) node. For each product, set **Product ID** and the properties to update with the new copy.
  </Step>

  <Step title="Record the finished products with Add Products to List" id="queue-step-5">
    Add an [**Add Products to List**](#add-products-to-list) node with the `optimized` list ID and the product IDs from this run. This Product List in Salsify is now your progress report.
  </Step>

  <Step title="Clear the products from the queue with Remove Products from List" id="queue-step-6">
    Add a [**Remove Products from List**](#remove-products-from-list) node with the `to optimize` list ID and the same product IDs. The products leave the queue but stay in Salsify.
  </Step>
</Steps>

## Troubleshooting

<AccordionGroup>
  <Accordion title="The property picker is empty or disabled">
    * Select a **Salsify Organization** first. The picker stays disabled until you do.
    * Enter a **Sample product ID**. The picker lists the properties of that one product, so use a product that carries the properties you want to write.
    * If the picker reads **Available when the payload below is a list of products**, the **Products** payload is text or a variable. Switch **Data format** to **Raw JSON** to edit it.
  </Accordion>

  <Accordion title="List Products fails with a Salsify error">
    * Confirm that the Product List ID is the URL segment after `product_lists/` and before any query parameters (`?`).
    * Confirm that the list still exists in Salsify.
    * If you use **Advanced Filter**, check that it's a valid [Salsify filter expression](https://developers.salsify.com/reference/salsify-filtering-language-syntax).
  </Accordion>

  <Accordion title="List Products returns no products from a list that has products">
    * Confirm the Product List ID. Two lists can have similar names.
    * Check that a **Property Equality** clause or an **Advanced Filter** doesn't exclude every product.
    * If you added the products to the list a moment ago, wait and run the node again. Salsify applies changes asynchronously, and your [**List Products**](#list-products) node may not have picked up the change yet.
  </Accordion>

  <Accordion title="A write node reports that properties don't exist">
    Property IDs are case-sensitive. Copy the exact ID from the property picker or from a [**Get Product**](#get-product) node output. If the property is new, create it in Salsify first.
  </Accordion>

  <Accordion title="Create Products reports that a product must name the product ID property">
    A product in the batch is missing the property that holds your organization's product ID. Add it, with a unique value, to every product in the batch.
  </Accordion>

  <Accordion title="Update Products reports products as not found">
    Salsify has no record of those product IDs. Read the IDs with a [**List Products**](#list-products) node and confirm they're correct.
  </Accordion>

  <Accordion title="A read is refused for going past the 10,000-result limit">
    Reduce **Page** or **Results per Page**, or scope the read to a smaller Product List. Alternatively, [build a work queue](#build-a-work-queue), which always reads the first page only.
  </Accordion>

  <Accordion title="A change made in Salsify doesn't appear in the next read">
    Salsify updates list membership asynchronously. Wait, then run the node again.
  </Accordion>

  <Accordion title="A node reports that the Salsify rate limit is reached">
    The error tells you how many seconds remain until the limit resets. Wait, then run the Agent again. To avoid reaching rate limits, read more products per page and run fewer Salsify nodes at the same time.
  </Accordion>
</AccordionGroup>