POST https://entapi.amplifi.io/v2.1/oauth/authorize
Authorization: Basic Base64(client_id:client_secret)
Content-Type: application/json
{
  "grant_type": "client_credentials"
}

const clientId     = process.env.PXM_CLIENT_ID;
const clientSecret = process.env.PXM_CLIENT_SECRET;
const credentials  = Buffer.from(`${clientId}:${clientSecret}`).toString('base64');
const response = await fetch('https://entapi.amplifi.io/v2.1/oauth/authorize', {
  method: 'POST',
  headers: {
    'Authorization': `Basic ${credentials}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({ grant_type: 'client_credentials' }),
});
const { access_token } = await response.json();
// Reuse this token — store it in memory or a short-lived cache
// Authorization header for all subsequent calls:
// 'Authorization': `Bearer ${access_token}`

import os, base64, requests
client_id     = os.environ['PXM_CLIENT_ID']
client_secret = os.environ['PXM_CLIENT_SECRET']
credentials   = base64.b64encode(f"{client_id}:{client_secret}".encode()).decode()
response = requests.post(
    'https://entapi.amplifi.io/v2.1/oauth/authorize',
    headers={
        'Authorization': f'Basic {credentials}',
        'Content-Type': 'application/json',
    },
    json={'grant_type': 'client_credentials'}
)
access_token = response.json()['access_token']
HEADERS = {'Authorization': f'Bearer {access_token}'}
# Reuse HEADERS in all subsequent requests

{
  "access_token": "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9...",
  "token_type": "Bearer",
  "expires_in": "31536000",
  "user": {
    "email": "api-user@yourcompany.com",
    "hostname": "yourcompany.pxm.pattern.com"
  }
}

// Fetch all products in a category, 50 at a time
async function fetchAllProductsInCategory(categoryId, token) {
  const products = [];
  let offset = 0;
  const limit = 50;
  while (true) {
    const url = new URL('https://entapi.amplifi.io/v2.1/collection');
    url.searchParams.set('parent_id', categoryId);
    url.searchParams.set('limit', limit);
    url.searchParams.set('offset', offset);
    const res = await fetch(url, {
      headers: { 'Authorization': `Bearer ${token}` }
    });
    const data  = await res.json();
    // List responses may be a plain array or { collections, pagination }
    const items = Array.isArray(data) ? data : (data.collections ?? []);
    if (!items.length) break;   // No more results
    products.push(...items);
    offset += limit;
  }
  return products;
}

{
  "id": "a1b2c3d4-1234-5678-abcd-ef1234567890",
  "name": "Heavy Duty 5/8\" Garden Hose - 50ft",
  "additional_title": "Model HG-5058",
  "parent_id": "cat-uuid-garden-category",
  "collection_type": "variant",
  "published": true,
  "attributes": [
    { "id": "attr-uuid-001", "label": "Color",    "value": "Green", "value_type": "Text" },
    { "id": "attr-uuid-002", "label": "Length",   "value": "50ft",  "value_type": "Text" },
    { "id": "attr-uuid-004", "label": "Max PSI",  "value": 150,     "value_type": "Number" },
    { "id": "attr-uuid-005", "label": "In Stock", "value": true,    "value_type": "Boolean" }
  ],
  "created_date": "2024-01-15T10:23:00Z",
  "update_date": "2024-11-02T08:45:00Z"
}

async function getProduct(collectionId, token) {
  const res = await fetch(
    `https://entapi.amplifi.io/v2.1/collection/${collectionId}`,
    { headers: { 'Authorization': `Bearer ${token}` } }
  );
  const product = await res.json();
  // Convert attributes array to a convenient key-value map
  const attrs = Object.fromEntries(
    product.attributes.map(a => [a.label, a.value])
  );
  return {
    id:          product.id,
    name:        product.name,
    description: attrs['Description'] ?? '',
    color:       attrs['Color'] ?? '',
    inStock:     attrs['In Stock'] ?? false,
  };
}

async function getProductImages(collectionId, token) {
  const res = await fetch(
    `https://entapi.amplifi.io/v2.1/collection/${collectionId}/files`,
    { headers: { 'Authorization': `Bearer ${token}` } }
  );
  if (!res.ok) throw new Error(`Could not load files: HTTP ${res.status}`);
  const files = await res.json();
  // Variants are keyed by size, then format: variants.thumb.webp.link
  // Size names depend on your account's image settings (e.g. 'thumbnail' vs 'thumb')
  const variantLink = (f, size) =>
    f.variants?.[size]?.webp?.link ?? f.variants?.[size]?.jpg?.link ?? f.variants?.[size]?.png?.link;
  const images    = files.filter(f => f.type === 'image');
  const documents = files.filter(f => f.type === 'document');
  return {
    gallery: images.map(img => ({
      id:       img.id,
      thumb:    variantLink(img, 'thumb'),
      medium:   variantLink(img, 'medium'),
      full:     variantLink(img, 'large') ?? img.master_link,
      altText:  img.caption || img.file_name,
    })),
    downloads: documents.map(doc => ({
      id:   doc.id,
      name: doc.file_name,
      url:  doc.master_link,   // master_link serves the original file (e.g. the PDF)
    })),
  };
}

async function getProductGallery(collectionId, token) {
  const url = new URL(
    `https://entapi.amplifi.io/v2.1/collection/${collectionId}/image-stacks`
  );
  url.searchParams.set('size', 'medium');
  url.searchParams.set('file_type', 'webp');
  const res    = await fetch(url, { headers: { 'Authorization': `Bearer ${token}` } });
  const stacks = await res.json();
  return stacks.map(stack => ({
    name:   stack.name,
    images: stack.files ?? [],
  }));
}

async function getUpdatedFiles(lastSyncDate, token) {
  const url = new URL('https://entapi.amplifi.io/v2.1/file');
  url.searchParams.set('updated_start_date', lastSyncDate); // "2025-01-01"
  url.searchParams.set('limit', 100);
  const res = await fetch(url, { headers: { 'Authorization': `Bearer ${token}` } });
  return res.json();
}

{
  "id": "f1a2b3c4-0000-1111-aaaa-bbbbccccdddd",
  "file_name": "garden-hose-50ft-hero.jpg",
  "type": "image",
  "format": "jpg",
  "file_size": 2048576,
  "published": true,
  "master_link": "https://{cdn-host}/p/f1a2b3c4-0000-1111-aaaa-bbbbccccdddd",
  "variants_links": [
    "https://{cdn-host}/p/f1a2b3c4-0000-1111-aaaa-bbbbccccdddd?..."
  ]
}

// Fetch once and cache — attribute definitions rarely change
async function buildAttributeMap(token) {
  const res   = await fetch('https://entapi.amplifi.io/v2.1/attribute', {
    headers: { 'Authorization': `Bearer ${token}` }
  });
  const attrs = await res.json();
  return Object.fromEntries(
    attrs.map(a => [a.id, { label: a.label, type: a.value_type }])
  );
}
function renderAttributeValue(value, type) {
  switch (type) {
    case 'Boolean': return value ? 'Yes' : 'No';
    case 'Number':  return Number(value).toLocaleString();
    case 'Date':    return new Date(value).toLocaleDateString();
    default:        return String(value ?? '');
  }
}

async function searchFileByName(filename, token) {
  const encoded = encodeURIComponent(filename);
  const res = await fetch(
    `https://entapi.amplifi.io/v2.1/file/search/${encoded}`,
    { headers: { 'Authorization': `Bearer ${token}` } }
  );
  return res.json();
}

async function searchProducts(keyword, token, page = 0, pageSize = 20) {
  const url = new URL('https://entapi.amplifi.io/v2/folder/search');
  url.searchParams.set('keyword', keyword);
  url.searchParams.set('from', page * pageSize);
  url.searchParams.set('size', pageSize);
  const res  = await fetch(url, { headers: { 'Authorization': `Bearer ${token}` } });
  const hits = await res.json();
  return hits;
}

async function searchProductsV3(keyword, token, page = 0, pageSize = 20) {
  const url = new URL('https://entapi.amplifi.io/v3/folder/search');
  url.searchParams.set('keyword', keyword);
  url.searchParams.set('from', page * pageSize);
  url.searchParams.set('size', pageSize);
  const res            = await fetch(url, { headers: { 'Authorization': `Bearer ${token}` } });
  const { hits, total } = await res.json();
  return {
    results:     hits,
    total:       total,
    totalPages:  Math.ceil(total / pageSize),
    currentPage: page,
  };
}

async function apiFetch(url, token, refreshToken) {
  let res = await fetch(url, {
    headers: { 'Authorization': `Bearer ${token}` }
  });
  // Handle rate limiting — respect the Retry-After header
  if (res.status === 429) {
    const retryAfter = parseInt(res.headers.get('Retry-After') ?? '60', 10);
    await new Promise(r => setTimeout(r, retryAfter * 1000));
    res = await fetch(url, { headers: { 'Authorization': `Bearer ${token}` } });
  }
  // Re-authenticate on 401 and retry once
  if (res.status === 401) {
    const newToken = await refreshToken();
    res = await fetch(url, { headers: { 'Authorization': `Bearer ${newToken}` } });
  }
  // Retry 500s with simple backoff
  if (res.status === 500) {
    await new Promise(r => setTimeout(r, 1000));
    res = await fetch(url, { headers: { 'Authorization': `Bearer ${token}` } });
  }
  if (!res.ok) {
    const err = await res.json().catch(() => ({}));
    throw new Error(`API error ${res.status}: ${err.message ?? 'Unknown error'}`);
  }
  return res.json();
}

import { Buffer } from 'buffer'; // Node.js — not needed in browsers
const BASE_URL = 'https://entapi.amplifi.io';
// 1. Authenticate
async function authenticate() {
  const creds = Buffer.from(
    `${process.env.PXM_CLIENT_ID}:${process.env.PXM_CLIENT_SECRET}`
  ).toString('base64');
  const res = await fetch(`${BASE_URL}/v2.1/oauth/authorize`, {
    method: 'POST',
    headers: { 'Authorization': `Basic ${creds}`, 'Content-Type': 'application/json' },
    body: JSON.stringify({ grant_type: 'client_credentials' }),
  });
  const { access_token } = await res.json();
  return access_token;
}
// 2. Fetch product + images
async function getProductPageData(collectionId, token) {
  const headers = { 'Authorization': `Bearer ${token}` };
  // Fetch product details and images in parallel
  const [product, images] = await Promise.all([
    fetch(`${BASE_URL}/v2.1/collection/${collectionId}`, { headers }).then(r => r.json()),
    fetch(`${BASE_URL}/v2.1/collection/${collectionId}/image-stacks?size=medium&file_type=webp`, { headers }).then(r => r.json()),
  ]);
  const attrs = Object.fromEntries(
    product.attributes.map(a => [a.label, a.value])
  );
  return {
    id:          product.id,
    name:        product.name,
    description: attrs['Description'] ?? '',
    specs:       product.attributes,
    gallery:     images.flatMap(stack => stack.files ?? []),
  };
}
// 3. Use it
const token    = await authenticate();
const pageData = await getProductPageData('YOUR-COLLECTION-ID-HERE', token);
console.log(pageData.name);       // "Heavy Duty 5/8\" Garden Hose - 50ft"
console.log(pageData.gallery[0]); // First gallery image with CDN URL