The Elbuz Shopify integration pulls your store's catalog and orders via API, with no files, and keeps products in the base catalog with your other channels.
When you need this:
- A quick look at the catalog: the store address is enough, no key needed.
- Shopify is one of your channels: you edit in Elbuz, and prices and stock go back to the store.
- Catalog and stock in step with the store: a scheduled template updates prices, quantity and active status.
- Orders right away: a webhook creates a document the moment an order is placed.
Where to start: enter the store address, plus an Admin API access token for full mode.
What the Shopify connection can do
- Works in two modes: without a key, using the store address, or in full with an Admin token.
- Brings the product into the card: title, description, manufacturer, SKU, barcode, price, old price, stock, tags, category and photos.
- Splits out variants: each size or color becomes a separate card, and they're all linked into a family.
- Carries over the product status: drafts and archived products arrive disabled.
- Pulls orders on a schedule or by webhook and creates “Customer order” documents for them.
- Updates on a schedule and logs how many products and orders were read.
What you need from Shopify: store address or token
The “Connection” card has three fields:
- Store domain: your store's address, for example
mystore.myshopify.com; your store's own domain works too. For quick mode, this field alone is enough. - Admin API access token: the app token. Needed for full mode (the whole catalog plus orders).
- Client secret: the app secret used to verify webhook signatures. Optional; fill it in if you receive orders by webhook.
Two modes: without a key and with a token
There's no mode switch: Elbuz picks the mode itself. A token means full mode; no token means quick mode.
- Quick mode without a key: you enter only the store address, and Elbuz reads the catalog from the public product list that Shopify serves to anyone (the same
products.json). Only published products are visible; orders and exact stock aren't available. Good for a first look or a one-off import. - Full mode with a token: you create an app in the store and paste its Admin API access token. Elbuz sees the whole catalog and can pull orders. For ongoing work, this is the mode you need.
- Start or end
- Action or result
- Decision: the path depends on the answer
How quick mode without a key differs
The public list returns less data than the Admin API:
| What | With a token | Without a key |
|---|---|---|
| Catalog contents | all products, including drafts and hidden ones | published only |
| Stock | exact quantity | only “in stock / out of stock” |
| Barcode () | imported | not available |
| Category | the product's collection | product type |
| Orders | yes | no |
If you turned on “Orders” but didn't enter a token, the log shows a message that order import is unavailable without an API key. This is a limit of the public list itself, not a settings error.
Where to get the token: step by step
| Where | What to do |
|---|---|
| Shopify admin | Settings → Apps → “Develop apps” |
| Same place | Create a custom app and give it access scopes (API permissions): reading products and orders is required, including read_orders |
| Same place | Install the app on the store and get the Admin API access token |
| Elbuz | Import window → your “Shopify” template → the “Connection” card → the domain and token fields |
Custom apps are for developers, and Shopify changes the steps periodically: they now run through a separate Dev Dashboard, and new apps need a technical step with app keys for a token. A link code is simpler: install the Elbuz app and enter its code in the “Marketplace app” card. The token is set for you; leave its field empty.
Shopify's official help: Installing and setting up apps, the sections on creating your own app and getting an access token.
Once the token is entered, click “Check connection”: it tells you right away whether Shopify accepts your details and whether the token has the right permissions, before the first full import.
What goes into the card
In the “Select data to import” card, you use checkboxes to choose what to pull: Products (into the Elbuz base catalog), Photo and Orders. Category and manufacturer come with the product.
In full mode (with a token), each Shopify product maps to Elbuz card fields like this:
| Shopify data | Card field in Elbuz |
|---|---|
title | Product name (for a variant, “Title — Variant”) |
descriptionHtml | Full description |
vendor | Manufacturer |
Variant sku | SKU |
Variant barcode | Barcode (EAN) |
Variant price | Price |
compareAtPrice | Old price, if it's higher than the current one |
inventoryQuantity | Stock (availability) |
ACTIVE status | Card active status (a draft arrives disabled) |
tags | Product tags |
First collection (collections) | Category |
selectedOptions (Size, Color…) | Variant options |
Variant photo + product media | Images, when the “Photo” checkbox is on |
| Product and variant IDs | Keys that link the card to the store |
Variants and attributes
If a product has several variants (sizes, colors, configurations), each arrives as a separate card named “Product name — Variant”, and they're all linked into one variant family by the parent product's name. Price, stock, SKU and barcode belong to the variant, so each card gets its own figures.
Attributes are filled from variant options (Size, Color and so on), not from arbitrary product properties: Shopify has no separate attribute directory.
Elbuz remembers the product, variant and inventory item IDs: price and stock updates sent back to the store use them.
Price and old price
Shopify writes the price to the card directly, from the variant. The old price is filled from compareAtPrice, and only when it's higher than the current price. If the store has no old price, the run leaves the card field alone: if you removed the old price in Shopify, clear it in the Elbuz card yourself.
Shopify doesn't send a purchase price. Markup rules calculate from the purchase price, so they don't touch a card filled only from Shopify: its price is always the store price.
- The card has a purchase price (for example, from a supplier's price list): at the end of the import, Elbuz recalculates the price by markup rules, but only for cards just created by this run. Existing cards keep the price Shopify has just written.
- Two sources compete for the price: the run that finished last wins. You can separate them with the “Fixed Price” or “Do not update” flags (repeat run).
Category and manufacturer
The category comes from the product's first collection: in full mode, the program reads up to three collections and takes the first, so a product in several collections lands in one category. Quick mode can't see collections and uses the product type instead. The program first looks for your category with that name, then creates a new one.
Products without a collection go into the service category “Products - shopify”, which is disabled and excluded from exports. Feel free to move them into your own categories: a repeat run doesn't change a product's place in the tree. How service categories and brands behave: import overview.
The manufacturer is the vendor field. A new brand is added to the manufacturer directory automatically. Change a brand's name on the Shopify side: if you rename a brand in Elbuz, the next run creates it again under the old name and reattaches the products to it.
What a repeat run does with your edits
A run overwrites from the store: name, full description, price, old price, quantity, availability, SKU, barcode, tags, variant family name and the card's active status. If you change any of these in Elbuz, the next update brings back the Shopify value without warning.
- Empty values don't overwrite yours. If a field is empty in Shopify, or the price or old price is zero, a barcode or tags you filled in by hand stay. Quantity and active status are written as they are, even zero and “disabled”.
- Left untouched on an existing card: photos (they're added only to new cards), variant options, the place in the category tree, the page URL. An empty
vendordoesn't unlink the manufacturer.
You can lock a card in the product itself: the “Statuses and flags” section, the “Import protection” block. “Do not update”: the Shopify run skips the card entirely, including its active status. “Fixed Price” protects only the price and old price. More: how to lock your own value.
1
Do not update2
Fixed Price- Do not update — import skips this product entirely.
- Fixed Price — import does not change the price of this product.
- Start or end
- Action or result
- Decision: the path depends on the answer
A product is recognized by the name stored when its card was created. Renamed in Elbuz: the run finds the card and restores the store name, no duplicate. Renamed in Shopify: the run creates a second card; the old one keeps old prices, and you delete it by hand. SKU plays no part: Shopify doesn't send the manufacturer's part number.
A product disappeared from Shopify or became a draft
Shopify sends not only the product but also its status, so the outcomes differ:
| What happened in Shopify | What happens to the card in Elbuz |
|---|---|
| The product was deleted | The card stays as it was: with the last price and stock, active, with no line in the log. Remove it by hand, or it goes into exports |
| The product was moved to draft or archived (full mode) | It arrives disabled; price and stock update as usual. A card stays enabled only in the Active status |
| The product was unpublished (quick mode) | For Elbuz, it disappeared: the card stays active with the old figures. Quick mode never disables cards |
The Shopify template has no “delete what's missing from the source” checkbox, and no Shopify import deletes products. The general rule: a product disappeared from the source.
Disable a card or delete it
A disabled card isn't shown in the storefront and doesn't go into exports (a new export template takes only active products), and in an export back to Shopify it arrives as a draft. Its price, stock, photos and links are kept.
Disabling a Shopify product by hand makes little sense: active status comes from the store on every run, and the next update re-enables a product that's Active. The only way to keep a card disabled against the store is the “Do not update” flag. In quick mode, removing active status won't survive a single run.
The next run recreates a deleted card from scratch, without your edits.
How to receive Shopify orders
The same connection also pulls orders, only in full mode with a token. Two ways: scheduled polling or a , with which Shopify notifies Elbuz of a new order instantly.
Webhook
The “Order intake (Webhook)” card holds the “Use webhooks” checkbox and the webhook . The “Subscribe to Shopify webhooks” button creates the subscription on the Shopify side; nothing to paste by hand. A webhook is accepted if:
- the template has the “Use webhooks” checkbox on;
- the template is “Active”: if you switch off the badge in the card header, Elbuz silently rejects the messages;
- if Client secret is filled in, the message signature matches; otherwise the order isn't accepted.
A store connected with a link code through the Elbuz app doesn't need subscribing: the subscription was set up during installation.
- Start or end
- Action or result
- Decision: the path depends on the answer
What document an order becomes
Each order becomes an unposted “Customer order” document: stock and reservations don't change until you post the document.
- Number: as in Shopify (
#1001); the order is recognized by the store's internal ID, so importing it again doesn't create a duplicate. - Customer: looked up among your contacts by email and phone; if not found, a new one is created.
- Statuses arrive in two fields: fulfillment status (UNFULFILLED, FULFILLED) and payment status (PAID, PENDING, REFUNDED). Your statuses are set by mapping with the “Order statuses”, “Delivery statuses” and “Payment statuses” buttons in the “Related settings” section. An unmapped status gets the first status in the directory. The mapping is shared by the webhook and the schedule.
If an order changes after import, the program no longer touches a posted document. In an unposted one, the next update overwrites payment, delivery and methods, and changes your working status only when the status changed in Shopify itself. The general mechanics: two statuses of one order.
- Start or end
- Action or result
- Decision: the path depends on the answer
The first import pulls the whole order history the store returns. After that, the program fetches only changes since the last order date, kept in the “Advanced” block, field “Import orders from date (YYYY-MM-DD)”. Clear the field, and the next run reads the whole history. Shopify returns orders older than 60 days only to an app with the read_all_orders scope.
1
Order statuses2
Payment statuses3
Import orders from date (YYYY-MM-DD)- Order statuses — maps Shopify order statuses to the app statuses.
- Payment statuses — maps Shopify payment statuses to the app statuses.
- Import orders from date — the start date for downloading orders; the field next to it sets the start ID.
Scheduled updates
Once the connection is checked, put the template on a schedule with the “Schedule setup” button in the form: prices and stock will update, and new products will be added. Exporting back to Shopify is a separate template in the “Data export” window with its own schedule (export templates).
The run log shows the numbers for each page:
- “Shopify: catalog page 3, products received: 75”;
- the total “Shopify: catalog imported, products (including variants): 240”;
- orders separately: “Shopify: orders page 1, total loaded: 50”;
- a store error, as a red line.
New products show up in the “Products” grid by the “Source: name” column, updated ones by “Date updated”. More on the log: how to check that the import went through.
How much one run pulls
There's no cap on the number of products. Each variant counts as a separate item: a product in five sizes is five cards.
| What | Page | Also |
|---|---|---|
| Full mode | 25 products, 1 s pause | up to 100 variants, 20 photos and 3 collections per product; response within 120 s |
| Quick mode | 250 products, 1 s pause | no more than 2,000 pages (up to 500,000 items); response within 60 s |
| Orders | 50 orders | up to 100 lines in each |
You can see how long your catalog takes in the “Time spent” column and in “Run history”.
Scenarios
Look at the catalog in Elbuz without creating a Shopify app
What to turn on. In the “Connection” card, fill in only “Store domain”, leave “Admin API access token” empty, and don't connect the Elbuz app: with it, the run goes in full mode. In “Select data to import”, choose “Products” and, if you need images, “Photo”.
What you get. Published products go into the catalog, all active, with stock 1 or 0, and the product type becomes the category. There are no drafts, barcodes or orders (difference between modes).
Keep the catalog and stock in Elbuz in step with Shopify
What to turn on. “Store domain” and “Admin API access token” (or a link code in the “Marketplace app” card), the “Products” and “Photo” checkboxes, then a schedule with the “Schedule setup” button.
What you get. Each run reads all the store's products: drafts and archived products arrive disabled, the rest active, with exact quantity, barcode and the category from the first collection. Products deleted in Shopify stay in Elbuz as they were (a product disappeared), and photos of existing cards aren't updated.
Receive orders by webhook
What to turn on. Admin API access token, the “Orders” checkbox in the “Select data to import” card and “Use webhooks” in the “Order intake (Webhook)” card, the template set to “Active”, then the “Subscribe to Shopify webhooks” button. For signature verification, “Client secret”. Map your statuses with the “Order statuses”, “Payment statuses” and “Delivery statuses” buttons.
What you get. A new order immediately becomes an unposted “Customer order” document; a change in Shopify updates its payment and delivery. Stock and reservations move when you post the document.
Keep your own price on some products and update the rest from the store
What to turn on. In the product card: the “Statuses and flags” section, the “Import protection” block, the “Fixed Price” toggle.
What you get. The price and old price stay yours: neither the Shopify run nor markup rules overwrite them. The other fields, including active status, still come from the store; to keep the card from changing at all, turn on “Do not update”.
What to do when Shopify won't import
| What you see | Why | What to do |
|---|---|---|
| “Shopify: enter the store domain and access token” | The store domain is empty | Fill in the domain field; for orders and the full catalog, also the Admin API access token (what you need from Shopify) |
| “Shopify: API error —” followed by text from the store | Shopify rejected the request: the token is invalid, the app isn't installed on the store, permissions are missing, or the store is temporarily unavailable | Click “Check connection”: the response names the cause without a full run (where to get the token) |
| The token is entered and products arrive, but orders don't | The app lacks the read_orders scope; for orders older than 60 days, read_all_orders |
Add the scope in the Shopify app and check the connection (where to get the token) |
| “Shopify: order import is unavailable without an API key” | “Orders” is on, but quick mode without a key is running | Enter an Admin API access token or link the store with a code through the Elbuz app (difference between modes) |
| “invalid JSON (not a Shopify storefront?)” | There's no public product list at that address: wrong domain, the store is password-protected, or it isn't on Shopify | Check the store address; if the storefront is password-protected, connect with a token (two modes) |
| “Shopify: catalog imported”, but there are noticeably fewer products than in the store | Quick mode: the program reads an error on a deep page of the public list as the end of the catalog; before the total, the log has an orange line “Shopify: API error — (page N)” | Switch to full mode with a token and run the import again (interrupted run) |
| After the import, stock became 1 or 0, and disabled products were enabled | Quick mode ran over a catalog imported with a token (for example, the token was removed from the form) | Enter the token and run the import again (imported in the wrong mode) |
| The catalog has two identical products with different names | The product was renamed in Shopify: the run didn't recognize the old card and created a new one | Delete the old card: after the rename, the run no longer updates it, so you can find it by filtering on an old “Date updated” (repeat run) |
| “The store is connected via the Elbuz app — order webhooks were already configured” | You clicked “Subscribe to Shopify webhooks” on a store connected with a link code | Nothing to do: the subscription was created when the app was installed (webhook) |
If a run breaks off
Products are written to the catalog in batches of 500 items, so after a break-off part of the catalog is already updated and the rest has old data. Run it again: there won't be duplicates, and the repeat finishes markup rules and search data for new products. The general mechanics: if a run breaks off.
Full mode handles a “too many requests” response on its own: up to three retries with an increasing pause.
In quick mode, an error on the first page stops the run with a red line. But the program treats an error on any later page as the end of the catalog: an orange line “Shopify: API error — (page N)” and the usual total “Shopify: catalog imported…” with a smaller N.
Shopify responds the same way in both cases, so you can't tell them apart. After quick mode, compare the total with the number of products in the store, and for a large catalog, switch to full mode.
If you imported in the wrong mode
Quick mode over a catalog imported with a token overwrites exact values with poorer ones:
- stock gets rounded to 1 or 0: the public list only says “can buy / can't buy”;
- disabled products get enabled: in quick mode, all products read arrive active;
- barcodes survive: an empty value doesn't overwrite a filled field.
Enter the Admin API access token and run the import again: full mode restores quantity and active status, with no duplicates. The only thing that won't come back is the category of cards that quick mode created for the first time: it took it from the product type, and a full run doesn't change the place in the tree.
Connected the wrong store? Filter the template's products in “Products” by the “Source: name” and “Source: code” columns and delete them in bulk. How to find overwritten cards and what can't be restored: if you imported the wrong thing.
FAQ
Why aren't product attributes imported?
Shopify has no separate attribute directory: everything that describes an item lives in the variant options. Those are what get imported (variants and attributes). Fill in the remaining properties in your Elbuz catalog.
Which is better for orders: a schedule or a webhook?
A webhook is faster: Shopify notifies Elbuz about a new order the moment it's placed, and Elbuz creates the subscription with a button in the form. A schedule works too, but with a delay until the next run (webhook).
Why doesn't quick mode show all products?
Shopify's public list returns only published products: drafts and hidden items aren't in it. To see the whole catalog, connect with a token (difference between modes).
What happens if I rename a product in Shopify?
The next run won't recognize the old card, since products are matched by name, and will create a second one with the new name. Remove the old one by hand. Renaming in Elbuz is safe: the card is found, the name just comes back from the store.
I turned off “Activity” in the card. Will the next run turn it back on?
Yes, if the product is Active in Shopify: active status comes from the store on every update. The only way to keep the card disabled is the “Do not update” toggle (disable or delete).
Will stock change when a Shopify order comes in?
No. The order becomes an unposted “Customer order” document, and an unposted document changes neither stock nor reservations until you post it.
Can I update prices and stock in Shopify from Elbuz?
Yes, but with a separate template in the “Data export” window, with a direct API connection type and its own schedule. The import itself doesn't export anything back (export templates).
Where to find it and who has access
- Menu
- Directories → Operations → Data import
- Template
- new template → type “Shopify”; one template = one store
- Access right
- the “Import” window in “Group permissions”
- Prepare
- the store address; for full mode, an Admin API access token or a link code
1
Store domain2
Admin API access token3
Client secret4
Test connection- Store domain — the address of the Shopify store, for example mystore.myshopify.com.
- Admin API access token — the token of the custom app installed on the store.
- Client secret — optional, used to verify the signature of webhooks.
- Test connection — checks the connection to Shopify (not pressed here).
How import templates work in general: data import overview.
Related topics
- To understand how an import template handles any source: Importing data into the catalog.
- If you're also connecting other marketplaces through the API: Catalog import via API.
- If Shopify orders need to be combined with other channels: Importing orders from marketplaces.
- If prices and stock from Elbuz need to go back to the store: Export templates.
