> ## Documentation Index
> Fetch the complete documentation index at: https://docs.readyforcommerce.com/llms.txt
> Use this file to discover all available pages before exploring further.
> ## Agent Instructions
> Ready for Commerce is an ecosystem that currently contains two products, PIM and Repricer, standing on one shared foundation: one identity, one organization, one team, one bill. Do not call it a platform with features, and never hint at an unreleased product.
> PIM connects to Shopify, Amazon, Square, Google Merchant Center and BigCommerce. Repricer connects to Amazon, Walmart, Shopify, BigCommerce, eBay and Square. The two products do not share one list, and each integration is authorized separately inside each product. The roster grows on purpose, so describe what the product does and let a table carry which integrations do it today, instead of counting them or writing that only one does something.
> Integration is the word this product uses, and it is the default in the documentation: the connection, the account, the Integrations screen, the per-account settings and the sync state are all integrations. Channel is reserved for the narrow sense of a destination where a listing lives, as in a product being live on a channel or archived on the channel.
> Newegg is not a supported channel. Do not describe it.
> On Amazon, PIM manages the offer only: price, availability and condition. It does not publish listing content such as titles, descriptions, images or specifications.
> Sign-in is passwordless: a single-use code emailed to the user, or Google. There are no passwords anywhere, so never describe a password, a sign-up with a password, or an email confirmation link.
> There is no public API for customers and no customer-facing webhooks. There is no organization-wide activity feed and no audit export, but the PIM does keep version history on products, brands, categories, tags and specifications, with who changed what and a restore, so never write that changes are not recorded or that an edit cannot be undone. Do not describe capabilities that are not documented here.
> Never write that the products have no AI, and never write that anything is AI-powered. Both are wrong. The PIM's image Optimizer runs AI-backed transforms the seller starts on purpose: Upscale, Remove background, and the region selection behind Refine. The Repricer reads competitor prices off web pages on the server. No control, badge or tooltip in either product names AI, and the seller never writes a prompt, so describe what the buttons do in the app's own words instead of reaching for the word.
> A PIM product, brand, category or variant can be switched off per connected integration account. Hover the channel badge and the switch is beside the account name in the card that opens. It carries no visible caption, so never call it the Sync switch: Sync is only its accessible name. On a variant-grained provider, Amazon today, the switch moves into the variant editor. On a product it asks whether to delete it from the channel, archive it there, or leave it live. Disabling stops publishing, not reading. There is still no per-field sync toggle.
> The PIM's image Optimizer replaced a feature called Squarify, which no longer exists. It resizes to an aspect ratio or to exact dimensions, removes backgrounds, upscales, trims the transparent margin around a cutout and re-centers it, pads, fills and re-encodes, and it always publishes a new asset instead of changing the original. Nothing crops into the picture: the subject is always contained whole.
> The PIM has no repricing engine and never reacts to a competitor's price. It does build the price it publishes to each integration account from the seller's own fields, configured in that account's settings, so do not write that the PIM has no pricing rules.
> Neither product has an in-app notification center, bell or inbox. Notifications are delivered by email only.
> Billing is per organization and per product, and only the organization owner can see or change it. Team members are free and uncounted, so never describe seats or per-user pricing.
> The seller never picks a plan. Each product has twelve price tiers assigned automatically from usage: the PIM from catalog product count, which includes drafts and archived products, and the Repricer from trailing 30-day sales. Nothing is feature-gated by plan and exceeding a tier never blocks work, so never write that a feature requires a higher plan.
> A subscription that is past due or paused makes the product read-only, which stops repricing and blocks edits without deleting data. Only a canceled subscription locks the seller out. Nothing is ever charged without a payment method on file.
> Pages containing the text 'This page has not been written yet', or its Spanish equivalent 'Esta página todavía no está escrita', are placeholders. Do not treat their headings as documented behavior.
# Pull
> A pull is the PIM reading a connected integration on its own schedule to write down what it found, so your own product stays exactly as you left it.
A pull is the PIM reading one of your connected integrations and writing down what it found. It runs on a schedule. It needs nothing from you, and no button anywhere starts one.
Most people come to this page for one of two reasons. Something changed on the integration and they are waiting for it to show up in the PIM. Or a colored dot turned up on one of their products and they want to know what the last read found.
What a pull does with what it finds is the part to learn, and the answer is the same on every integration. A pull reports. It writes down where your listing stands, what the integration thinks of it, and how much stock is there, and it leaves everything you typed alone. Your catalog here is the version that counts, and the publishing is what sends it out.
You see the results in two places. Click a card on `Integrations` in the left sidebar, and the dialog that opens shows you a `Last pull` time. Open a product from `Catalog` and hover an integration's logo at the top of the editor, and a panel tells you what the last pull found about that one product.
## Before you start
One thing decides what you can see here. Everything else on this page can wait until you need it.
### What your role lets you do
| Role | Open `Integrations` | Read the panel on a product | Turn `Sync` off for one product |
| --- | --- | --- | --- |
| Admin | Yes | Yes | Yes |
| Manager | No | Yes | Yes |
| Editor | No | Yes | Yes |
`Integrations` is not in your sidebar at all below Admin, so most of your team cannot open `Last pull`. The panel on a product is not. Anyone who can open a product can hover a logo and read what the last pull found there. Roles are set in [team, roles and permissions](/team#what-each-pim-role-can-do).
## How to see what a pull brought in
Click `Catalog` in the left sidebar, which opens on `Products`, and click the row you want. The editor opens over your table.
They are in the top row of the editor, to the right of your title and the score badge. You get one logo for every integration your organization has connected, whether or not this product ever went there.
A small panel opens under it, with one card for each account you have on that integration.
`Sync status` tells you where this product stands with the PIM. `Integration status` tells you what the integration itself says about the listing. `Last pull` tells you when that integration was last read, and `Advisories` appears only when there is something to say about a field.
That is the whole flow. The colored dot on the logo says the same thing at a glance, so a green dot means nothing on that account needs you.
Everything below explains what each integration sends back, and what to do when a line in that panel tells you something went wrong. You do not need any of it to read a panel.
## Every option in detail
### When a pull runs
A pull runs every 30 minutes, once for each destination you have switched on. A destination is the part of one of your accounts that actually syncs. It means something different on each integration, which [integrations](/pim/integrations) sets out for you.
A pass is skipped for a destination you switched off, and for an account that is paused, needs re-authorizing, or has failed. A lapsed subscription on your organization stops every one of them at once. You will find the table of account states, and what clears each one, in [integrations](/pim/integrations).
Where an integration can announce a stock change the moment it happens, that count arrives in seconds instead of half an hour. The PIM then re-reads only that one thing, not your whole store.
| Integration | What it announces the moment it happens |
| --- | --- |
| Shopify | A stock count that moved |
| BigCommerce | A stock count that moved |
| Square | A stock count that moved |
| Amazon | Nothing. Every read waits for the scheduled pass |
| Google | Nothing. Every read waits for the scheduled pass |
### Reading an integration's panel on a product
Hover an integration's logo at the top of the product editor and you get a panel about that one product on that one integration. Which rows you get depends on what happened. A healthy product shows you three or four of them, and a product with a problem shows you more.
| Row | What it tells you |
| --- | --- |
| `Sync status` | Where this product stands with the PIM, in one short phrase |
| `Integration status` | What the integration itself says about the listing |
| `Variant status` | One line per variant, giving its SKU, the state the integration reports, `FBA` or `FBM` on Amazon, and where its push stands |
| `Listed` | How many of your variants got there, like `3 of 4 variants`. It appears only where one variant is one listing, on a product with more than one |
| `Last push` | How long ago the PIM last wrote to it |
| `Last pull` | How long ago that integration was last read |
| `Restrictions` | A rule on the integration is stopping this product from being shown, and the line says which |
| `Push issues` | One line for each field the last publish could not send as it stood |
| `Advisories` | One line for each field that needs looking at but stops nothing |
| `Pull error` | The last read failed on this product, and this is the reason |
Your name for the account is at the top of the panel, with a `Sync` switch next to it. That switch is about publishing and not about reading. Clicking the logo itself opens your listing on the integration in a new tab, which is the quickest way to see whatever the pull was reading.
With one account, the top line of the panel is that account. It reads like the integration's name and then your name for the account, and the `Sync` switch is on that line.
With two or more, the top line is the integration alone. Each account then gets a line of its own under it, with its own dot, its own status, and its own switch.
The dot on the logo is the worst state among your accounts this product actually got to. An account of yours it never got to does not drag the dot down, so a gray account never hides a green one. Clicking the logo opens the listing on one of your accounts, not a choice of them.
### What each integration reports back
No integration's pull writes into your catalog. They all report, and what each one reports is where they differ.
| Integration | What a pull writes into your catalog | What it only reports |
| --- | --- | --- |
| Shopify | Nothing, once the first sync is done | Whether the listing is still there, the store's stock, and the store's locations |
| BigCommerce | Nothing, once the first sync is done | Whether the listing is still there, and the store's stock |
| Square | Nothing, once the first sync is done | The counter's stock, and the merchant's locations |
| Amazon | Nothing | The offer's state, its ASIN, who ships it, and the stock Amazon has |
| Google | Nothing | Whether each product may be shown, and why not |
**The PIM decides what your products say, everywhere.** So a pull reads back the outcome and stops there. An item someone creates in your Shopify store, in your BigCommerce store or on Square after you connected never turns up in your catalog on its own. If you want it here, create it here.
**Amazon reports your offer and nothing about the product.** It reads back how healthy your offer is, the ASIN for that marketplace, and whether Amazon ships the listing or you do. On a listing Amazon ships for you, it also copies Amazon's own quantity in as a read-only number. That stock is Amazon's, and the PIM never writes it.
**Google reports a verdict.** Publishing to Google answers right away even when your product cannot be shown, and the real decision comes minutes later. So the pull exists to go and fetch it. Whatever Google objects to names the field it is about. A product Google will not show at all reads under `Restrictions`, and one it shows less prominently reads under `Advisories`.
| What `Integration status` says | What it means |
| --- | --- |
| `Approved` | Your product can be shown |
| `Limited` | It is shown, less prominently, and the reasons arrive as lines in `Advisories` |
| `In review` | Google has not decided yet |
| `Rejected` | It cannot be shown, and the reasons arrive as lines in `Restrictions` |
| `Unknown` | Google answered with something the PIM does not recognize |
A problem with your account instead of a product does not appear here at all. It goes into a card headed `Account setup` at the top of your account's dialog, and [integrations](/pim/integrations) covers reading one.
Stock is left out everywhere, and the section below explains where it goes instead.
A Square first sync does bring the merchant's images into your [assets](/pim/assets). It turns Square categories into PIM categories too, so your publishing after that reuses the same ones instead of building a second set beside them.
A BigCommerce first sync brings the images that are on a product in your store, and it leaves two things behind. Custom fields do not come across, because a flat name and value cannot be turned back into a PIM specification. Images attached to one variant do not come across either, only the ones on the product itself.
### What the first sync brings in
A first sync runs once when you connect an account, and it cannot be run again. It starts by itself the moment the connection exists. A dialog opens and counts what happened, and [integrations](/pim/integrations) covers that dialog. What it does to your catalog is different on each integration.
| Integration | What the first sync does |
| --- | --- |
| Shopify | Reads your whole store, matches what it can to products you already have, and imports the rest. Every Shopify status comes across, so drafts and archived products arrive too |
| BigCommerce | Reads your whole store once. A product it can match by SKU, and then by barcode, is linked to yours, and anything it cannot match becomes a new PIM product |
| Square | Reads the merchant's items once, matching the same way |
| Amazon | Imports nothing. It reads your listings and takes over every offer whose ASIN already matches one of your variants |
| Google | Imports nothing. Google has only what the PIM sent it, so a new account reads back an empty answer |
**A match links the two and changes nothing of yours.** Your version is the one that goes back out after that. So connecting a second store to a catalog you already built here does not overwrite what you built. Only a product the first sync could not match at all becomes a new product in your catalog.
**An item the first sync cannot decide about is skipped instead.** That happens when one item's identifiers point at two different PIM products, or when the PIM product it matched was already taken. Those come to you in the error report you download from the first sync dialog. A currency that does not match stops the whole thing before it starts, and [integrations](/pim/integrations) gives you that warning.
**Nothing that arrives on a first sync brings its stock with it.** An imported variant arrives with `Track Inventory` switched off, in the `Inventory` section of the product editor. The integration's real counts show up beside it as read-only numbers you cannot edit. Turn `Track Inventory` on when you want the PIM to publish a quantity of its own, which [inventory](/pim/catalog/inventory) works through.
This is the one and only time an integration's own content becomes your content. Everything after it runs the other way.
### Where the stock a pull reads ends up
**A pull never writes your stock number.** Everything an integration reports about quantities goes next to your number instead of into it. Your number stays the one you set, and the two are side by side so you can see the gap.
Open a product from `Catalog`, scroll to the `Inventory` section, and under `Track Inventory` you get a table with one row per location. The columns you get are `Location`, `Integration`, `Available`, `Committed`, and `Incoming`. Every number in it is read-only, and nothing you type anywhere changes it.
Which locations you see in that table comes from the pull as well. Shopify, Square, and BigCommerce report the locations you keep with them. Amazon adds one for each marketplace where it has your stock. A location the integration stops using is marked inactive here instead of disappearing on you.
Whether a location counts toward the on-hand number the PIM publishes is yours to decide, from the `Locations` list in the account dialog, which [integrations](/pim/integrations) covers.
### Limits
| What | Limit |
| --- | --- |
| Time between scheduled reads | 30 minutes |
| First syncs on one account | 1 |
| Products one pull reads | No limit |
### What a pull cannot do
| You cannot | Do this instead |
| --- | --- |
| Read an integration on demand | Wait for the next pass |
| Run a first sync a second time | Nothing re-runs it. A fresh connection runs a first sync of its own |
| Look back at what earlier pulls did | Read `Last pull` in the integration dialog, and `Advisories` on the product |
| Stop the reading without stopping the publishing | Switch the destination off in the account dialog, which stops both directions |
| Bring an edit made on the integration back into your catalog | Make the edit here, and let the publishing send it out |
| Bring in an item created on the integration after you connected | Create it in your PIM catalog and let the publishing send it there |
## What happens to what you typed
### When somebody edits on the integration
**Your version is the one kept, always.** An edit somebody makes in Shopify Admin, in your BigCommerce store, on Square or on Amazon is never read back into your catalog. It stays on that integration until the PIM next publishes that product, and the publish writes your whole product over it.
So there is no race to win and no timestamp to compare. If you want a change that somebody made over there, make the same change here.
### Brands and tags the first sync creates
A Shopify product has a vendor and a set of tags, and your catalog has `Brands` and `Tags` of its own. So a first sync that finds a vendor your catalog does not have creates the brand for you. The same goes for a tag: one your catalog has never seen gets created too. You will find both under `Catalog`, in `Brands` and in `Tags`, and their `Created by` column reads `Integration` instead of a person's name.
Categories never move in this direction. A Shopify collection does not become a PIM category, however many syncs run, so your category tree is only ever what you built.
A vendor or a tag over 100 characters is skipped instead of created, and you get a line in `Advisories` on the product saying so.
### A product you deleted here stays gone
Deleting a PIM product on an account whose delete setting is `Archive` or `Keep` leaves your listing alive on the integration, which is what you asked for when you chose that setting in [integration settings](/pim/integrations/settings).
What the PIM does then is forget it. The link between your deleted product and that listing goes, nothing here points at the listing any more, and no later pass reads it back in. So a product you delete stays deleted, whatever you told the integration to do with what it was publishing.
### A listing deleted there comes back on its own
Every completed pull queues a publish for each product of yours whose SKU is missing on that integration. So deleting a listing in Shopify Admin, in your BigCommerce store, or in Square is not how you take a product off an integration. It goes back within half an hour, and [integrations](/pim/integrations) explains the same behavior from the publishing side.
The way to take one product off one account is the `Sync` switch in that account's card of your product's panel. [Products](/pim/catalog/products) covers what that switch asks you when your listing is already live.
Switching `Sync` off stops the publishing. A product you took off one account stays out of everything the PIM sends there. The listing you left behind keeps its place in the panel, so you can still click through to it on the integration.
## When something goes wrong
### The badge on a product
The dot on an integration's logo is one color, and the `Sync status` row in the panel spells that color out for you in words. These are the ones a pull gives you.
| What `Sync status` says | What it means |
| --- | --- |
| `Synced` | Nothing on this account needs you |
| `2 fields need attention` | That many fields have something to say, and `Advisories` lists them |
| `Read failed` | The last read could not take this product at all, and `Pull error` gives you the reason |
| `Listing needs attention` | The integration says your listing is not fully live |
| `Rejected by the integration` | The integration would not show it |
The worst one is the one shown, so a red state hides an orange one under it. Every other phrase you can see in that row comes from the publishing side or from your account's own state, and [products](/pim/catalog/products) and [integrations](/pim/integrations) cover those.
### The notes on a field
`Advisories` gives you one line for each field that needs looking at. Each line opens with the field's name, spelled the way your product editor spells it. So a title that ran long on the first sync reads `Title was too long (max 300 characters); shortened to fit.`
| How the line ends | What happened |
| --- | --- |
| `shortened to fit.` | The value came in, cut down to the limit |
| `not imported.` | The value could not be used, so the field arrived empty |
| `a unique one was assigned.` | Another product already had that `URL handle`, so yours got a different one |
| `temporary SKUs were assigned.` | Another product already had those SKUs |
| `that were removed.` | Invisible characters were taken out, and the rest came in |
| `skipped.` | A file could not be downloaded, so the product arrived without it |
Where the line came from decides how it clears. On Shopify these are all first sync notes, and they clear the next time that product publishes successfully, because the publish sends your version of the whole product. On Amazon and on Google the line is the integration's own verdict, so fix the value there and the next pull clears it for you.
### When the PIM emails you
A pull that keeps failing on an account emails you under the subject `Sync issue with {channel}`, with your integration's name in place of `{channel}`. It asks you to do nothing. The next pass tries again, and the first pull that completes closes it without you touching anything.
An authorization that expired or was revoked emails you a different one, asking you to reconnect. Both are under `Notifications` in your settings, in the group `Integrations & Sync`, as `Sync errors` and `Connection issues`. You can switch either of them off there.
### Two things that happen with no message
Nothing on screen tells you about either of these, so they are worth knowing.
A Shopify product whose pictures the store is still preparing waits rather than arriving without them. If they are still not ready after a while, the product comes in with the pictures that are, and a line in `Advisories` names what was left out. Nothing fetches the rest later, so those are files you upload here yourself.
While a catalog import of yours is running, the PIM holds back the publishes a pull would queue for products missing on a channel. They are queued once your import finishes, so a quiet half hour after you upload a big file is expected.
## Where to go next
The other direction, what starts it, and what each integration accepts.
Accounts, destinations, locations, and the states that stop a pull.
Your stock number, and the read-only numbers a pull writes beside it.
The editor, the logos at the top of it, and the switch inside the panel.