Shopify

Overview

Use PartLogic as the governed product source of truth, then publish approved catalogue data to Shopify so storefront products stay aligned with your master records.

This guide focuses on a common pattern: when products are raised or updated in PartLogic, create or update the matching items in Shopify automatically—without re-typing titles, SKUs, barcodes, or descriptions by hand.

You can implement that pattern with Zapier (no-code) or with your own middleware calling the PartLogic API and the Shopify Admin API. PartLogic is not a Shopify storefront replacement.

• Create a new Shopify product when the item does not yet exist in the store
• Update an existing Shopify product when title, SKU, barcode, or other mapped fields change in PartLogic
• Optionally keep inventory quantity in step where you choose Shopify as a stock destination

Choose a path

Context for integrations generally: Zapier suits lightweight workflows; the API path suits production integrations. Both use the same find → create or update logic below.

What you need

PartLogic

• An API key from the Integrations portal (see the Portal API key guide)
• Access to the Stock endpoint https://partlogic-api-stock-dwbbcthkhfb0ceca.ukwest-01.azurewebsites.net/api/stock with the X-API-Key header (never as a query parameter)

Shopify

• A Shopify store and Admin API credentials (custom app or Partner app) with scopes such as write_products and, if you sync stock, write_inventory — see Shopify's authentication docs
• For Zapier: a Zapier account connected to Shopify and PartLogic
• Agreement on which PartLogic fields map to Shopify title, variant SKU, barcode (GTIN), description, and stock

How it works

The reliable pattern is find, then create or update—the same approach used in the Zapier + Sage Accounting example:

PartLogic (raised / updated product)
       ↓
GET PartLogic /api/stock (or Zapier List Stock)
       ↓
Find matching product/variant in Shopify (by SKU or barcode)
       ↓
  ┌─────────────────┬──────────────────┐
  │ Not found       │ Found            │
  │ Create product  │ Update product   │
  └─────────────────┴──────────────────┘

Match on a stable identifier—typically your PartLogic SKU mapped to the Shopify variant SKU, or GTIN mapped to barcode—so updates do not create duplicate listings.

API workflow: PartLogic → Shopify

Run a small sync job (serverless function, container, or on-prem worker) on a schedule—or after your own change signal—so raised and updated PartLogic items publish into Shopify.

1. 1Read PartLogic. Call GET https://partlogic-api-stock-dwbbcthkhfb0ceca.ukwest-01.azurewebsites.net/api/stock with X-API-Key. Full field reference: API Reference. Base host: https://partlogic-api-stock-dwbbcthkhfb0ceca.ukwest-01.azurewebsites.net.
2. 2Decide what to publish. Filter to approved / sellable SKUs only. Skip draft or unreviewed ProductMatch suggestions so incomplete lines do not hit the storefront.
3. 3Find in Shopify. Query the Admin API for an existing product/variant by SKU (or barcode). GraphQL: products with a query such as sku:YOUR-SKU.
4. 4Create or update. If none found, create via productCreate (then set variant SKU/barcode as needed). If found, update title/body with productUpdate and variant fields with productVariantsBulkUpdate. See Shopify's add product data guide for the current product model.
5. 5Optional inventory. If Shopify should follow PartLogic Physical, use inventory mutations such as inventorySetQuantities against the correct location—only when Shopify is an intentional quantity destination for those SKUs.
6. 6Idempotency & rate limits. Store Shopify product/variant IDs against PartLogic SKUs after the first create. Respect Shopify's rate limits and PartLogic rate limits; retry with backoff on 429 responses.

Fetch PartLogic stock (example)

curl -X GET "https://partlogic-api-stock-dwbbcthkhfb0ceca.ukwest-01.azurewebsites.net/api/stock" \
  -H "X-API-Key: YOUR_PARTLOGIC_API_KEY"

const response = await fetch("https://partlogic-api-stock-dwbbcthkhfb0ceca.ukwest-01.azurewebsites.net/api/stock", {
  headers: { "X-API-Key": process.env.PARTLOGIC_API_KEY },
});
const stock = await response.json();
// Each row typically includes SKU, Description, Physical, Location, …

Shopify Admin API

Prefer the GraphQL Admin API for new work. Shopify treats the REST Admin API as legacy for product create/update in newer public apps; REST resources such as Product remain documented for existing integrations—pin an API version and follow Shopify's migration guidance if you still use REST.

Authentication

Call https://{shop}.myshopify.com/admin/api/{version}/graphql.json with X-Shopify-Access-Token (custom app Admin API access token) or the OAuth access token for a Partner app. Store tokens as secrets alongside your PartLogic API key—never in client-side code or query strings.

GraphQL: find by SKU

query FindVariantBySku($q: String!) {
  productVariants(first: 1, query: $q) {
    edges {
      node {
        id
        sku
        barcode
        product { id title }
      }
    }
  }
}
# variables: { "q": "sku:YOUR-PARTLOGIC-SKU" }

GraphQL: create product (illustration)

Exact input shapes evolve with Shopify's product model. Treat the following as a structural illustration—confirm fields against Shopify's current productCreate docs before shipping.

mutation CreateFromPartLogic($product: ProductCreateInput!) {
  productCreate(product: $product) {
    product { id title }
    userErrors { field message }
  }
}
# Map PartLogic Description → title (and/or descriptionHtml),
# then set variant SKU / barcode (GTIN) on the created variant.

GraphQL: update product and variant (illustration)

mutation UpdateProduct($input: ProductInput!) {
  productUpdate(input: $input) {
    product { id title }
    userErrors { field message }
  }
}

mutation UpdateVariantSkuBarcode(
  $productId: ID!
  $variants: [ProductVariantsBulkInput!]!
) {
  productVariantsBulkUpdate(productId: $productId, variants: $variants) {
    productVariants { id sku barcode }
    userErrors { field message }
  }
}

REST Admin API (legacy / existing apps)

If you already use REST, the classic create/update paths were POST /admin/api/{version}/products.json and PUT /admin/api/{version}/products/{product_id}.json, with variant sku and barcode on the product payload. New public apps should plan on GraphQL; check Shopify's deprecation notices for your API version.

# Example shape only — prefer GraphQL for new builds
curl -X POST "https://YOUR-SHOP.myshopify.com/admin/api/2025-01/products.json" \
  -H "X-Shopify-Access-Token: YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "product": {
      "title": "PartLogic description…",
      "variants": [{ "sku": "YOUR-SKU", "barcode": "YOUR-GTIN" }]
    }
  }'

Example sync loop (pseudocode)

for (const row of await partlogic.getStock()) {
  if (!shouldPublish(row)) continue;

  const existing = await shopify.findVariantBySku(row.SKU);

  if (!existing) {
    await shopify.createProduct({
      title: row.Description,
      sku: row.SKU,
      barcode: row.GTIN, // when present
    });
  } else {
    await shopify.updateProductAndVariant(existing, {
      title: row.Description,
      sku: row.SKU,
      barcode: row.GTIN,
    });
  }

  // Optional: await shopify.setInventory(existingOrCreated, row.Physical);
}

Need a bespoke PartLogic payload (extra attributes for metafields, collections, or images)? The Stock API page notes that custom endpoints can be scoped— contact us.

Zapier workflow: PartLogic → Shopify

Exact Zapier Shopify action names can change as Shopify and Zapier evolve. Use the structure below; pick the Create / Update / Find Product (or Product Variant) actions available in your Zapier Shopify app. Under the hood those steps call Shopify's Admin APIs for you.

1. 1Create a new Zap in Zapier. For first-time setup, connect PartLogic with your API key from the Integrations portal.
2. 2Add a PartLogic step. Use the trigger or action that lists stock / product rows (for example List Stock) so Zapier receives the fields that changed in the PartLogic Parts module. For scheduled polling, a Schedule trigger plus List Stock also works when you do not need event-by-event timing.
3. 3Add a Shopify step to find an existing product or variant by SKU (or barcode). Run a test so Zapier can show sample data for mapping.
4. 4Split into two Paths: Path A — not found → Create Product; Path B — found → Update Product. Map PartLogic Description to Shopify title (or body HTML, depending on your store style), SKU to variant SKU, and GTIN to barcode where you use barcodes.
5. 5Optional: add inventory update steps if Shopify should reflect PartLogic physical stock for those SKUs. Only do this when Shopify is an intentional stock destination for those items—avoid competing quantity masters.
6. 6Test with a known new SKU (should create) and a known existing SKU (should update). Then turn the Zap on.

Suggested field mapping

Start from PartLogic stock / product fields (same family as the Stock API). Zapier action names and GraphQL input fields differ; the logical mapping is the same.

Need extra attributes (images, collections, metafields)? Contact us to scope which PartLogic fields to expose for your Zap, middleware, or bespoke API.

Governance and scope

• Not instant to every channel by default. Sync timing depends on your poll interval, Zap schedule, webhooks (where configured), and Shopify rate limits—scope the integration for the fields and cadence you need.
• One quantity master per SKU. Decide whether PartLogic or Shopify owns inventory for each channel SKU before enabling stock updates both ways.
• Human-approved data first. Clean or match incomplete lines in ProductMatch (with review) before they create new Shopify products.
• Pin Shopify API versions. GraphQL and REST shapes change; pin a version in your app and retest create/update after Shopify upgrades.