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.AMPLIFI_CLIENT_ID;
const clientSecret = process.env.AMPLIFI_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, requestsclient_id     = os.environ['AMPLIFI_CLIENT_ID']
client_secret = os.environ['AMPLIFI_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();    if (!data.length) break;   // No more results
    products.push(...data);
    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}` } }
  );
  const files = await res.json();  const images    = files.filter(f => f.metadata?.mime_type?.startsWith('image/'));
  const documents = files.filter(f => f.metadata?.mime_type === 'application/pdf');  return {
    gallery: images.map(img => ({
      id:       img.id,
      thumb:    img.variants?.thumb,
      medium:   img.variants?.medium,
      full:     img.variants?.large,
      altText:  img.metadata?.caption ?? img.metadata?.file_name,
    })),
    downloads: documents.map(doc => ({
      id:   doc.id,
      name: doc.metadata?.file_name,
      url:  doc.variants?.preview ?? doc.metadata?.cdn_url,
    })),
  };
}

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",
  "metadata": {
    "file_name": "garden-hose-50ft-hero.jpg",
    "caption":   "Green 50ft garden hose coiled on white background",
    "mime_type": "image/jpeg"
  },
  "file_dimension": "3000px x 3000px",
  "file_size": 2048576,
  "variants": {
    "thumb":   "https://cdn.amplifi.io/.../thumb/garden-hose-50ft-hero.jpg",
    "small":   "https://cdn.amplifi.io/.../small/garden-hose-50ft-hero.jpg",
    "medium":  "https://cdn.amplifi.io/.../medium/garden-hose-50ft-hero.jpg",
    "large":   "https://cdn.amplifi.io/.../large/garden-hose-50ft-hero.jpg"
  },
  "auto_label": ["garden", "hose", "outdoor", "green"]
}

// 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 browsersconst BASE_URL = 'https://entapi.amplifi.io';// 1. Authenticate
async function authenticate() {
  const creds = Buffer.from(
    `${process.env.AMPLIFI_CLIENT_ID}:${process.env.AMPLIFI_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