Products

import requests

resp = requests.get(
    "https://yourshop.zeroshop.io/admin/api/products",
    params={"page": 1, "per_page": 20, "search": "tee", "sort": "-price"},
    headers={"Authorization": "Bearer zspat_..."}
)
products = resp.json()

const params = new URLSearchParams({ page: 1, per_page: 20, search: "tee", sort: "-price" });
const resp = await fetch(
  `https://yourshop.zeroshop.io/admin/api/products?${params}`,
  { headers: { "Authorization": "Bearer zspat_..." } }
);
const data = await resp.json();

require "net/http"
require "json"

uri = URI("https://yourshop.zeroshop.io/admin/api/products?page=1&per_page=20&search=tee")
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer zspat_..."
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
data = JSON.parse(resp.body)

import requests

resp = requests.post(
    "https://yourshop.zeroshop.io/admin/api/products",
    headers={"Authorization": "Bearer zspat_..."},
    json={
        "name": "Classic Cotton Tee",
        "description": "A comfortable 100% cotton t-shirt.",
        "price": "29.99",
        "compare_at_price": "39.99",
        "sku": "CCT-001",
        "stock": 150,
        "visible": True,
        "product_type": "physical"
    }
)
product = resp.json()

const resp = await fetch("https://yourshop.zeroshop.io/admin/api/products", {
  method: "POST",
  headers: {
    "Authorization": "Bearer zspat_...",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    name: "Classic Cotton Tee",
    description: "A comfortable 100% cotton t-shirt.",
    price: "29.99",
    compare_at_price: "39.99",
    sku: "CCT-001",
    stock: 150,
    visible: true,
    product_type: "physical"
  })
});
const product = await resp.json();

require "net/http"
require "json"

uri = URI("https://yourshop.zeroshop.io/admin/api/products")
req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer zspat_..."
req["Content-Type"] = "application/json"
req.body = {
  name: "Classic Cotton Tee",
  description: "A comfortable 100% cotton t-shirt.",
  price: "29.99",
  stock: 150,
  visible: true,
  product_type: "physical"
}.to_json
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
product = JSON.parse(resp.body)

import requests

resp = requests.get(
    "https://yourshop.zeroshop.io/admin/api/products/1",
    headers={"Authorization": "Bearer zspat_..."}
)
product = resp.json()

const resp = await fetch("https://yourshop.zeroshop.io/admin/api/products/1", {
  headers: { "Authorization": "Bearer zspat_..." }
});
const product = await resp.json();

require "net/http"
require "json"

uri = URI("https://yourshop.zeroshop.io/admin/api/products/1")
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer zspat_..."
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
product = JSON.parse(resp.body)

import requests

resp = requests.put(
    "https://yourshop.zeroshop.io/admin/api/products/1",
    headers={"Authorization": "Bearer zspat_..."},
    json={
        "name": "Classic Cotton Tee",
        "description": "Updated description.",
        "price": "24.99",
        "stock": 200,
        "visible": True,
        "product_type": "physical",
        "track_stock": True
    }
)
# 204 No Content on success

const resp = await fetch("https://yourshop.zeroshop.io/admin/api/products/1", {
  method: "PUT",
  headers: {
    "Authorization": "Bearer zspat_...",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    name: "Classic Cotton Tee",
    description: "Updated description.",
    price: "24.99",
    stock: 200,
    visible: true,
    product_type: "physical",
    track_stock: true
  })
});
// 204 No Content on success

require "net/http"
require "json"

uri = URI("https://yourshop.zeroshop.io/admin/api/products/1")
req = Net::HTTP::Put.new(uri)
req["Authorization"] = "Bearer zspat_..."
req["Content-Type"] = "application/json"
req.body = {
  name: "Classic Cotton Tee",
  description: "Updated description.",
  price: "24.99",
  stock: 200,
  visible: true,
  product_type: "physical",
  track_stock: true
}.to_json
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }

import requests

resp = requests.delete(
    "https://yourshop.zeroshop.io/admin/api/products/1",
    headers={"Authorization": "Bearer zspat_..."}
)
# 204 No Content on success

const resp = await fetch("https://yourshop.zeroshop.io/admin/api/products/1", {
  method: "DELETE",
  headers: { "Authorization": "Bearer zspat_..." }
});
// 204 No Content on success

require "net/http"

uri = URI("https://yourshop.zeroshop.io/admin/api/products/1")
req = Net::HTTP::Delete.new(uri)
req["Authorization"] = "Bearer zspat_..."
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }

import requests

resp = requests.get(
    "https://yourshop.zeroshop.io/admin/api/products/export.csv",
    params={"include_options": "true"},
    headers={"Authorization": "Bearer zspat_..."},
)
with open("products-export.csv", "wb") as f:
    f.write(resp.content)

const resp = await fetch(
  "https://yourshop.zeroshop.io/admin/api/products/export.csv?include_options=true",
  { headers: { "Authorization": "Bearer zspat_..." } }
);
const blob = await resp.blob();
// e.g. trigger a download in the browser
const url = URL.createObjectURL(blob);

require "net/http"

uri = URI("https://yourshop.zeroshop.io/admin/api/products/export.csv?include_options=true")
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer zspat_..."
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
File.binwrite("products-export.csv", resp.body)

import requests

with open("products-edited.csv", "rb") as f:
    resp = requests.post(
        "https://yourshop.zeroshop.io/admin/api/products/import/preview",
        headers={"Authorization": "Bearer zspat_..."},
        files={"file": ("products-edited.csv", f, "text/csv")},
    )
preview = resp.json()
print(preview["summary"], "can_confirm:", preview["can_confirm"])

const formData = new FormData();
formData.append("file", fileInput.files[0]);

const resp = await fetch(
  "https://yourshop.zeroshop.io/admin/api/products/import/preview",
  {
    method: "POST",
    headers: { "Authorization": "Bearer zspat_..." },
    body: formData,
  }
);
const preview = await resp.json();

require "net/http"
require "json"
require "securerandom"

uri = URI("https://yourshop.zeroshop.io/admin/api/products/import/preview")
boundary = "----FormBoundary#{SecureRandom.hex(8)}"
csv_data = File.binread("products-edited.csv")
body = "--#{boundary}\r\nContent-Disposition: form-data; name=\"file\"; filename=\"products-edited.csv\"\r\nContent-Type: text/csv\r\n\r\n#{csv_data}\r\n--#{boundary}--\r\n"
req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer zspat_..."
req["Content-Type"] = "multipart/form-data; boundary=#{boundary}"
req.body = body
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
preview = JSON.parse(resp.body)

import requests

with open("products-edited.csv", "rb") as f:
    resp = requests.post(
        "https://yourshop.zeroshop.io/admin/api/products/import/confirm",
        params={"skip_invalid_rows": "false"},
        headers={"Authorization": "Bearer zspat_..."},
        files={"file": ("products-edited.csv", f, "text/csv")},
    )
result = resp.json()
print(f"Applied {result['applied']} rows ({result['products_touched']} products, {result['variants_touched']} variants)")

const formData = new FormData();
formData.append("file", fileInput.files[0]);

const resp = await fetch(
  "https://yourshop.zeroshop.io/admin/api/products/import/confirm",
  {
    method: "POST",
    headers: { "Authorization": "Bearer zspat_..." },
    body: formData,
  }
);
const result = await resp.json();

require "net/http"
require "json"
require "securerandom"

uri = URI("https://yourshop.zeroshop.io/admin/api/products/import/confirm")
boundary = "----FormBoundary#{SecureRandom.hex(8)}"
csv_data = File.binread("products-edited.csv")
body = "--#{boundary}\r\nContent-Disposition: form-data; name=\"file\"; filename=\"products-edited.csv\"\r\nContent-Type: text/csv\r\n\r\n#{csv_data}\r\n--#{boundary}--\r\n"
req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer zspat_..."
req["Content-Type"] = "multipart/form-data; boundary=#{boundary}"
req.body = body
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
result = JSON.parse(resp.body)

import requests

resp = requests.get(
    "https://yourshop.zeroshop.io/admin/api/products/1/variants",
    headers={"Authorization": "Bearer zspat_..."}
)
data = resp.json()
print(f"Options: {len(data['options'])}, Variants: {len(data['variants'])}")

const resp = await fetch("https://yourshop.zeroshop.io/admin/api/products/1/variants", {
  headers: { "Authorization": "Bearer zspat_..." }
});
const { options, variants } = await resp.json();

require "net/http"
require "json"

uri = URI("https://yourshop.zeroshop.io/admin/api/products/1/variants")
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer zspat_..."
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
data = JSON.parse(resp.body)

import requests

resp = requests.put(
    "https://yourshop.zeroshop.io/admin/api/products/1/variants",
    headers={"Authorization": "Bearer zspat_..."},
    json={
        "option_ids": [1, 2],
        "variants": [
            {
                "sku": "CCT-S-RED",
                "price": "29.99",
                "stock": 25,
                "visible": True,
                "option_value_ids": [10, 20],
                "weight_grams": 200
            }
        ]
    }
)
# 204 No Content on success

const resp = await fetch("https://yourshop.zeroshop.io/admin/api/products/1/variants", {
  method: "PUT",
  headers: {
    "Authorization": "Bearer zspat_...",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    option_ids: [1, 2],
    variants: [
      {
        sku: "CCT-S-RED",
        price: "29.99",
        stock: 25,
        visible: true,
        option_value_ids: [10, 20],
        weight_grams: 200
      }
    ]
  })
});

require "net/http"
require "json"

uri = URI("https://yourshop.zeroshop.io/admin/api/products/1/variants")
req = Net::HTTP::Put.new(uri)
req["Authorization"] = "Bearer zspat_..."
req["Content-Type"] = "application/json"
req.body = {
  option_ids: [1, 2],
  variants: [
    { sku: "CCT-S-RED", price: "29.99", stock: 25, visible: true, option_value_ids: [10, 20] }
  ]
}.to_json
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }

import requests

resp = requests.get(
    "https://yourshop.zeroshop.io/admin/api/products/1/attributes",
    headers={"Authorization": "Bearer zspat_..."}
)
attributes = resp.json()

const resp = await fetch("https://yourshop.zeroshop.io/admin/api/products/1/attributes", {
  headers: { "Authorization": "Bearer zspat_..." }
});
const attributes = await resp.json();

require "net/http"
require "json"

uri = URI("https://yourshop.zeroshop.io/admin/api/products/1/attributes")
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer zspat_..."
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
attributes = JSON.parse(resp.body)

import requests

resp = requests.put(
    "https://yourshop.zeroshop.io/admin/api/products/1/attributes",
    headers={"Authorization": "Bearer zspat_..."},
    json={
        "attributes": [
            {"option_id": 5, "option_value_ids": [50, 51]},
            {"option_id": 6, "option_value_ids": [60]}
        ]
    }
)
# 204 No Content on success

const resp = await fetch("https://yourshop.zeroshop.io/admin/api/products/1/attributes", {
  method: "PUT",
  headers: {
    "Authorization": "Bearer zspat_...",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    attributes: [
      { option_id: 5, option_value_ids: [50, 51] },
      { option_id: 6, option_value_ids: [60] }
    ]
  })
});

require "net/http"
require "json"

uri = URI("https://yourshop.zeroshop.io/admin/api/products/1/attributes")
req = Net::HTTP::Put.new(uri)
req["Authorization"] = "Bearer zspat_..."
req["Content-Type"] = "application/json"
req.body = {
  attributes: [
    { option_id: 5, option_value_ids: [50, 51] },
    { option_id: 6, option_value_ids: [60] }
  ]
}.to_json
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }

import requests

resp = requests.get(
    "https://yourshop.zeroshop.io/admin/api/products/1/images",
    headers={"Authorization": "Bearer zspat_..."}
)
images = resp.json()["images"]

const resp = await fetch("https://yourshop.zeroshop.io/admin/api/products/1/images", {
  headers: { "Authorization": "Bearer zspat_..." }
});
const { images } = await resp.json();

require "net/http"
require "json"

uri = URI("https://yourshop.zeroshop.io/admin/api/products/1/images")
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer zspat_..."
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
images = JSON.parse(resp.body)["images"]

import requests

with open("product-photo.jpg", "rb") as f:
    resp = requests.post(
        "https://yourshop.zeroshop.io/admin/api/products/1/images",
        headers={"Authorization": "Bearer zspat_..."},
        files={"file": ("product-photo.jpg", f, "image/jpeg")}
    )
image = resp.json()

const formData = new FormData();
formData.append("file", fileInput.files[0]);

const resp = await fetch("https://yourshop.zeroshop.io/admin/api/products/1/images", {
  method: "POST",
  headers: { "Authorization": "Bearer zspat_..." },
  body: formData
});
const image = await resp.json();

require "net/http"
require "json"

uri = URI("https://yourshop.zeroshop.io/admin/api/products/1/images")
boundary = "----FormBoundary#{SecureRandom.hex(8)}"
body = "--#{boundary}\r\nContent-Disposition: form-data; name=\"file\"; filename=\"photo.jpg\"\r\nContent-Type: image/jpeg\r\n\r\n#{File.binread("photo.jpg")}\r\n--#{boundary}--\r\n"
req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer zspat_..."
req["Content-Type"] = "multipart/form-data; boundary=#{boundary}"
req.body = body
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
image = JSON.parse(resp.body)

import requests

resp = requests.put(
    "https://yourshop.zeroshop.io/admin/api/products/1/images/reorder",
    headers={"Authorization": "Bearer zspat_..."},
    json={"ordered_ids": [2, 1, 3]}
)
# 204 No Content on success

const resp = await fetch("https://yourshop.zeroshop.io/admin/api/products/1/images/reorder", {
  method: "PUT",
  headers: {
    "Authorization": "Bearer zspat_...",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({ ordered_ids: [2, 1, 3] })
});

require "net/http"
require "json"

uri = URI("https://yourshop.zeroshop.io/admin/api/products/1/images/reorder")
req = Net::HTTP::Put.new(uri)
req["Authorization"] = "Bearer zspat_..."
req["Content-Type"] = "application/json"
req.body = { ordered_ids: [2, 1, 3] }.to_json
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }

import requests

resp = requests.delete(
    "https://yourshop.zeroshop.io/admin/api/products/1/images/3",
    headers={"Authorization": "Bearer zspat_..."}
)
# 204 No Content on success

const resp = await fetch("https://yourshop.zeroshop.io/admin/api/products/1/images/3", {
  method: "DELETE",
  headers: { "Authorization": "Bearer zspat_..." }
});

require "net/http"

uri = URI("https://yourshop.zeroshop.io/admin/api/products/1/images/3")
req = Net::HTTP::Delete.new(uri)
req["Authorization"] = "Bearer zspat_..."
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }

import requests

resp = requests.get(
    "https://yourshop.zeroshop.io/admin/api/files",
    headers={"Authorization": "Bearer zspat_..."}
)
files = resp.json()["files"]

const resp = await fetch("https://yourshop.zeroshop.io/admin/api/files", {
  headers: { "Authorization": "Bearer zspat_..." }
});
const { files } = await resp.json();

require "net/http"
require "json"

uri = URI("https://yourshop.zeroshop.io/admin/api/files")
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer zspat_..."
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
files = JSON.parse(resp.body)["files"]

import requests

with open("photography-guide.pdf", "rb") as f:
    resp = requests.post(
        "https://yourshop.zeroshop.io/admin/api/files",
        headers={"Authorization": "Bearer zspat_..."},
        files={"file": ("photography-guide.pdf", f, "application/pdf")}
    )
digital_file = resp.json()

const formData = new FormData();
formData.append("file", fileInput.files[0]);

const resp = await fetch("https://yourshop.zeroshop.io/admin/api/files", {
  method: "POST",
  headers: { "Authorization": "Bearer zspat_..." },
  body: formData
});
const digitalFile = await resp.json();

require "net/http"
require "json"
require "securerandom"

uri = URI("https://yourshop.zeroshop.io/admin/api/files")
boundary = "----FormBoundary#{SecureRandom.hex(8)}"
file_data = File.binread("guide.pdf")
body = "--#{boundary}\r\nContent-Disposition: form-data; name=\"file\"; filename=\"guide.pdf\"\r\nContent-Type: application/pdf\r\n\r\n#{file_data}\r\n--#{boundary}--\r\n"
req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer zspat_..."
req["Content-Type"] = "multipart/form-data; boundary=#{boundary}"
req.body = body
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }

import requests

resp = requests.delete(
    "https://yourshop.zeroshop.io/admin/api/files/3",
    headers={"Authorization": "Bearer zspat_..."}
)
# 204 No Content on success

const resp = await fetch("https://yourshop.zeroshop.io/admin/api/files/3", {
  method: "DELETE",
  headers: { "Authorization": "Bearer zspat_..." }
});

require "net/http"

uri = URI("https://yourshop.zeroshop.io/admin/api/files/3")
req = Net::HTTP::Delete.new(uri)
req["Authorization"] = "Bearer zspat_..."
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }

import requests

resp = requests.get(
    "https://yourshop.zeroshop.io/admin/api/products/1/recommendations",
    headers={"Authorization": "Bearer zspat_..."}
)
recommendations = resp.json()

const resp = await fetch("https://yourshop.zeroshop.io/admin/api/products/1/recommendations", {
  headers: { "Authorization": "Bearer zspat_..." }
});
const recommendations = await resp.json();

require "net/http"
require "json"

uri = URI("https://yourshop.zeroshop.io/admin/api/products/1/recommendations")
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer zspat_..."
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
recommendations = JSON.parse(resp.body)

import requests

resp = requests.put(
    "https://yourshop.zeroshop.io/admin/api/products/1/recommendations",
    headers={"Authorization": "Bearer zspat_..."},
    json={
        "recommendation_type": "cross_sell",
        "target_product_ids": [5, 8, 15]
    }
)
# 204 No Content on success

const resp = await fetch("https://yourshop.zeroshop.io/admin/api/products/1/recommendations", {
  method: "PUT",
  headers: {
    "Authorization": "Bearer zspat_...",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    recommendation_type: "cross_sell",
    target_product_ids: [5, 8, 15]
  })
});

require "net/http"
require "json"

uri = URI("https://yourshop.zeroshop.io/admin/api/products/1/recommendations")
req = Net::HTTP::Put.new(uri)
req["Authorization"] = "Bearer zspat_..."
req["Content-Type"] = "application/json"
req.body = {
  recommendation_type: "cross_sell",
  target_product_ids: [5, 8, 15]
}.to_json
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }

import requests

resp = requests.delete(
    "https://yourshop.zeroshop.io/admin/api/products/1/recommendations/3",
    headers={"Authorization": "Bearer zspat_..."}
)
# 204 No Content on success

const resp = await fetch("https://yourshop.zeroshop.io/admin/api/products/1/recommendations/3", {
  method: "DELETE",
  headers: { "Authorization": "Bearer zspat_..." }
});

require "net/http"

uri = URI("https://yourshop.zeroshop.io/admin/api/products/1/recommendations/3")
req = Net::HTTP::Delete.new(uri)
req["Authorization"] = "Bearer zspat_..."
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }

import requests

resp = requests.get(
    "https://yourshop.zeroshop.io/admin/api/products/10/bundle-items",
    headers={"Authorization": "Bearer zspat_..."}
)
bundle_items = resp.json()

const resp = await fetch("https://yourshop.zeroshop.io/admin/api/products/10/bundle-items", {
  headers: { "Authorization": "Bearer zspat_..." }
});
const bundleItems = await resp.json();

require "net/http"
require "json"

uri = URI("https://yourshop.zeroshop.io/admin/api/products/10/bundle-items")
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer zspat_..."
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
bundle_items = JSON.parse(resp.body)

import requests

resp = requests.put(
    "https://yourshop.zeroshop.io/admin/api/products/10/bundle-items",
    headers={"Authorization": "Bearer zspat_..."},
    json={
        "items": [
            {"product_id": 1, "variant_id": 100, "quantity": 1},
            {"product_id": 3, "variant_id": 300, "quantity": 2}
        ]
    }
)
# 204 No Content on success

const resp = await fetch("https://yourshop.zeroshop.io/admin/api/products/10/bundle-items", {
  method: "PUT",
  headers: {
    "Authorization": "Bearer zspat_...",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    items: [
      { product_id: 1, variant_id: 100, quantity: 1 },
      { product_id: 3, variant_id: 300, quantity: 2 }
    ]
  })
});

require "net/http"
require "json"

uri = URI("https://yourshop.zeroshop.io/admin/api/products/10/bundle-items")
req = Net::HTTP::Put.new(uri)
req["Authorization"] = "Bearer zspat_..."
req["Content-Type"] = "application/json"
req.body = {
  items: [
    { product_id: 1, variant_id: 100, quantity: 1 },
    { product_id: 3, variant_id: 300, quantity: 2 }
  ]
}.to_json
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }

import requests

resp = requests.get(
    "https://yourshop.zeroshop.io/admin/api/products/1/custom-fields",
    headers={"Authorization": "Bearer zspat_..."}
)
custom_fields = resp.json()

const resp = await fetch("https://yourshop.zeroshop.io/admin/api/products/1/custom-fields", {
  headers: { "Authorization": "Bearer zspat_..." }
});
const customFields = await resp.json();

require "net/http"
require "json"

uri = URI("https://yourshop.zeroshop.io/admin/api/products/1/custom-fields")
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer zspat_..."
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
custom_fields = JSON.parse(resp.body)

import requests

resp = requests.put(
    "https://yourshop.zeroshop.io/admin/api/products/1/custom-fields",
    headers={"Authorization": "Bearer zspat_..."},
    json={"custom_field_ids": [1, 2, 5]}
)
# 204 No Content on success

const resp = await fetch("https://yourshop.zeroshop.io/admin/api/products/1/custom-fields", {
  method: "PUT",
  headers: {
    "Authorization": "Bearer zspat_...",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({ custom_field_ids: [1, 2, 5] })
});

require "net/http"
require "json"

uri = URI("https://yourshop.zeroshop.io/admin/api/products/1/custom-fields")
req = Net::HTTP::Put.new(uri)
req["Authorization"] = "Bearer zspat_..."
req["Content-Type"] = "application/json"
req.body = { custom_field_ids: [1, 2, 5] }.to_json
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }

import requests

resp = requests.get(
    "https://yourshop.zeroshop.io/admin/api/products/1/categories",
    headers={"Authorization": "Bearer zspat_..."}
)
category_ids = resp.json()["category_ids"]

const resp = await fetch("https://yourshop.zeroshop.io/admin/api/products/1/categories", {
  headers: { "Authorization": "Bearer zspat_..." }
});
const { category_ids } = await resp.json();

require "net/http"
require "json"

uri = URI("https://yourshop.zeroshop.io/admin/api/products/1/categories")
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer zspat_..."
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
category_ids = JSON.parse(resp.body)["category_ids"]

import requests

resp = requests.put(
    "https://yourshop.zeroshop.io/admin/api/products/1/categories",
    headers={"Authorization": "Bearer zspat_..."},
    json={"category_ids": [3, 7, 12]}
)
# 204 No Content on success

const resp = await fetch("https://yourshop.zeroshop.io/admin/api/products/1/categories", {
  method: "PUT",
  headers: {
    "Authorization": "Bearer zspat_...",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({ category_ids: [3, 7, 12] })
});

require "net/http"
require "json"

uri = URI("https://yourshop.zeroshop.io/admin/api/products/1/categories")
req = Net::HTTP::Put.new(uri)
req["Authorization"] = "Bearer zspat_..."
req["Content-Type"] = "application/json"
req.body = { category_ids: [3, 7, 12] }.to_json
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }

import requests

resp = requests.patch(
    "https://yourshop.zeroshop.io/admin/api/products/bulk",
    headers={"Authorization": "Bearer zspat_..."},
    json={
        "ids": [1, 2, 3],
        "changes": {"visible": True, "quick_order_enabled": True}
    }
)
result = resp.json()
print(f"Updated {result['updated']} products")

const resp = await fetch("https://yourshop.zeroshop.io/admin/api/products/bulk", {
  method: "PATCH",
  headers: {
    "Authorization": "Bearer zspat_...",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    ids: [1, 2, 3],
    changes: { visible: true, quick_order_enabled: true }
  })
});
const result = await resp.json();

require "net/http"
require "json"

uri = URI("https://yourshop.zeroshop.io/admin/api/products/bulk")
req = Net::HTTP::Patch.new(uri)
req["Authorization"] = "Bearer zspat_..."
req["Content-Type"] = "application/json"
req.body = {
  ids: [1, 2, 3],
  changes: { visible: true, quick_order_enabled: true }
}.to_json
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
result = JSON.parse(resp.body)

import requests

resp = requests.post(
    "https://yourshop.zeroshop.io/admin/api/products/1/clone",
    headers={"Authorization": "Bearer zspat_..."}
)
clone = resp.json()

const resp = await fetch("https://yourshop.zeroshop.io/admin/api/products/1/clone", {
  method: "POST",
  headers: { "Authorization": "Bearer zspat_..." }
});
const clone = await resp.json();

require "net/http"
require "json"

uri = URI("https://yourshop.zeroshop.io/admin/api/products/1/clone")
req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer zspat_..."
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
clone = JSON.parse(resp.body)

import requests

resp = requests.get(
    "https://yourshop.zeroshop.io/admin/api/products/create-import/example.csv",
    headers={"Authorization": "Bearer zspat_..."},
)
with open("product-create-example.csv", "wb") as f:
    f.write(resp.content)

const resp = await fetch(
  "https://yourshop.zeroshop.io/admin/api/products/create-import/example.csv",
  { headers: { "Authorization": "Bearer zspat_..." } }
);
const blob = await resp.blob();
const url = URL.createObjectURL(blob);

require "net/http"

uri = URI("https://yourshop.zeroshop.io/admin/api/products/create-import/example.csv")
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer zspat_..."
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
File.binwrite("product-create-example.csv", resp.body)

import requests

with open("products-to-create.csv", "rb") as f:
    resp = requests.post(
        "https://yourshop.zeroshop.io/admin/api/products/create-import/preview",
        headers={"Authorization": "Bearer zspat_..."},
        files={"file": ("products-to-create.csv", f, "text/csv")},
        data={"duplicate_mode": "skip"},
    )
preview = resp.json()
print(preview["summary"], "can_confirm:", preview["can_confirm"])

const formData = new FormData();
formData.append("file", fileInput.files[0]);
formData.append("duplicate_mode", "skip");

const resp = await fetch(
  "https://yourshop.zeroshop.io/admin/api/products/create-import/preview",
  {
    method: "POST",
    headers: { "Authorization": "Bearer zspat_..." },
    body: formData,
  }
);
const preview = await resp.json();

require "net/http"
require "json"
require "securerandom"

uri = URI("https://yourshop.zeroshop.io/admin/api/products/create-import/preview")
boundary = "----FormBoundary#{SecureRandom.hex(8)}"
csv_data = File.binread("products-to-create.csv")
body = "--#{boundary}\r\nContent-Disposition: form-data; name=\"file\"; filename=\"products-to-create.csv\"\r\nContent-Type: text/csv\r\n\r\n#{csv_data}\r\n--#{boundary}\r\nContent-Disposition: form-data; name=\"duplicate_mode\"\r\n\r\nskip\r\n--#{boundary}--\r\n"
req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer zspat_..."
req["Content-Type"] = "multipart/form-data; boundary=#{boundary}"
req.body = body
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
preview = JSON.parse(resp.body)

import requests

with open("products-to-create.csv", "rb") as f:
    resp = requests.post(
        "https://yourshop.zeroshop.io/admin/api/products/create-import/confirm",
        headers={"Authorization": "Bearer zspat_..."},
        files={"file": ("products-to-create.csv", f, "text/csv")},
        data={"duplicate_mode": "skip"},
    )
result = resp.json()
print(f"Created {len(result['created'])} products, {len(result['failed_images'])} image failures")

const formData = new FormData();
formData.append("file", fileInput.files[0]);
formData.append("duplicate_mode", "skip");

const resp = await fetch(
  "https://yourshop.zeroshop.io/admin/api/products/create-import/confirm",
  {
    method: "POST",
    headers: { "Authorization": "Bearer zspat_..." },
    body: formData,
  }
);
const result = await resp.json();

require "net/http"
require "json"
require "securerandom"

uri = URI("https://yourshop.zeroshop.io/admin/api/products/create-import/confirm")
boundary = "----FormBoundary#{SecureRandom.hex(8)}"
csv_data = File.binread("products-to-create.csv")
body = "--#{boundary}\r\nContent-Disposition: form-data; name=\"file\"; filename=\"products-to-create.csv\"\r\nContent-Type: text/csv\r\n\r\n#{csv_data}\r\n--#{boundary}\r\nContent-Disposition: form-data; name=\"duplicate_mode\"\r\n\r\nskip\r\n--#{boundary}--\r\n"
req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer zspat_..."
req["Content-Type"] = "multipart/form-data; boundary=#{boundary}"
req.body = body
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
result = JSON.parse(resp.body)