Skip to main content

Quick Reference

Overview​

Copy-paste examples for common Q01 Core API operations. All examples use curl and JavaScript.

Base URL: https://api.example.com

Authentication​

Login​

curl -X POST https://api.example.com/auth/login \
  -H "Content-Type: application/json" \
  -d '{
    "username": "user@example.com",
    "password": "secure_password"
  }'
const response = await fetch('https://api.example.com/auth/login', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    username: 'user@example.com',
    password: 'secure_password'
  })
});

const { access_token, refresh_token } = await response.json();

Refresh Token​

curl -X POST https://api.example.com/auth/refresh \
  -H "Content-Type: application/json" \
  -d '{"refresh_token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."}'
const response = await fetch('https://api.example.com/auth/refresh', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({ refresh_token })
});

const { access_token } = await response.json();

CRUD Operations​

Create (POST)​

curl -X POST https://api.example.com/api/v4/core/PRD \
  -H "Authorization: Bearer ${TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{
    "data": {
      "XPRD01": "New Product",
      "XPRD02": 99.99,
      "XPRD05": "cat_electronics"
    }
  }'
const response = await fetch('https://api.example.com/api/v4/core/PRD', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${token}`,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    data: {
      XPRD01: 'New Product',
      XPRD02: 99.99,
      XPRD05: 'cat_electronics'
    }
  })
});

const result = await response.json();
console.log('Created:', result.data.PRD_ID);

Read (GET)​

Get Single Record:

curl -X GET https://api.example.com/api/v4/core/PRD/123 \
  -H "Authorization: Bearer ${TOKEN}"
const response = await fetch('https://api.example.com/api/v4/core/PRD/123', {
  headers: { 'Authorization': `Bearer ${token}` }
});

const product = await response.json();
console.log(product.data);

Get List:

curl -X GET "https://api.example.com/api/v4/core/PRD?$num_rows=10" \
  -H "Authorization: Bearer ${TOKEN}"
const response = await fetch('https://api.example.com/api/v4/core/PRD?$num_rows=10', {
  headers: { 'Authorization': `Bearer ${token}` }
});

const { data, meta } = await response.json();
console.log(`Showing ${data.length} of ${meta.total} products`);

Update (PATCH - Partial)​

curl -X PATCH https://api.example.com/api/v4/core/PRD/123 \
  -H "Authorization: Bearer ${TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{
    "data": {
      "XPRD02": 89.99
    }
  }'
const response = await fetch('https://api.example.com/api/v4/core/PRD/123', {
  method: 'PATCH',
  headers: {
    'Authorization': `Bearer ${token}`,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    data: { XPRD02: 89.99 }
  })
});

const updated = await response.json();
console.log('Updated:', updated.data);

Update (PUT - Full)​

curl -X PUT https://api.example.com/api/v4/core/PRD/123 \
  -H "Authorization: Bearer ${TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{
    "data": {
      "XPRD01": "Updated Product",
      "XPRD02": 109.99,
      "XPRD05": "cat_electronics",
      "XPRD06": true
    }
  }'
const response = await fetch('https://api.example.com/api/v4/core/PRD/123', {
  method: 'PUT',
  headers: {
    'Authorization': `Bearer ${token}`,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    data: {
      XPRD01: 'Updated Product',
      XPRD02: 109.99,
      XPRD05: 'cat_electronics',
      XPRD06: true
    }
  })
});

Delete (Soft)​

curl -X DELETE https://api.example.com/api/v4/core/PRD/123 \
  -H "Authorization: Bearer ${TOKEN}"
const response = await fetch('https://api.example.com/api/v4/core/PRD/123', {
  method: 'DELETE',
  headers: { 'Authorization': `Bearer ${token}` }
});

console.log('Soft deleted (TREC=C)');

Delete (Force)​

curl -X DELETE "https://api.example.com/api/v4/core/PRD/123?force=true" \
  -H "Authorization: Bearer ${TOKEN}"
const response = await fetch('https://api.example.com/api/v4/core/PRD/123?force=true', {
  method: 'DELETE',
  headers: { 'Authorization': `Bearer ${token}` }
});

console.log('Permanently deleted');

Filtering​

Simple Filter (Equals)​

curl -X GET "https://api.example.com/api/v4/core/PRD?filter[XPRD05]=electronics" \
  -H "Authorization: Bearer ${TOKEN}"
const response = await fetch(
  'https://api.example.com/api/v4/core/PRD?filter[XPRD05]=electronics',
  { headers: { 'Authorization': `Bearer ${token}` } }
);

Filter Operators​

Greater Than:

curl -X GET "https://api.example.com/api/v4/core/PRD?filter[XPRD02][\$gt]=100" \
  -H "Authorization: Bearer ${TOKEN}"
const params = new URLSearchParams({
  'filter[XPRD02][$gt]': '100'
});

const response = await fetch(
  `https://api.example.com/api/v4/core/PRD?${params}`,
  { headers: { 'Authorization': `Bearer ${token}` } }
);

Between:

curl -X GET "https://api.example.com/api/v4/core/PRD?filter[XPRD02][\$between]=50,150" \
  -H "Authorization: Bearer ${TOKEN}"
const params = new URLSearchParams({
  'filter[XPRD02][$between]': '50,150'
});

In List:

curl -X GET "https://api.example.com/api/v4/core/PRD?filter[XPRD05][\$in]=electronics,books" \
  -H "Authorization: Bearer ${TOKEN}"
const params = new URLSearchParams({
  'filter[XPRD05][$in]': 'electronics,books'
});

Like (Pattern):

curl -X GET "https://api.example.com/api/v4/core/PRD?filter[XPRD01][\$like]=Widget%" \
  -H "Authorization: Bearer ${TOKEN}"
const params = new URLSearchParams({
  'filter[XPRD01][$like]': 'Widget%'
});

Not Equals:

curl -X GET "https://api.example.com/api/v4/core/PRD?filter[TREC][\$ne]=C" \
  -H "Authorization: Bearer ${TOKEN}"
const params = new URLSearchParams({
  'filter[TREC][$ne]': 'C'
});

Multiple Filters (AND)​

curl -X GET "https://api.example.com/api/v4/core/PRD?filter[XPRD05]=electronics&filter[XPRD02][\$gt]=100&filter[XPRD06]=true" \
  -H "Authorization: Bearer ${TOKEN}"
const params = new URLSearchParams({
  'filter[XPRD05]': 'electronics',
  'filter[XPRD02][$gt]': '100',
  'filter[XPRD06]': 'true'
});

const response = await fetch(
  `https://api.example.com/api/v4/core/PRD?${params}`,
  { headers: { 'Authorization': `Bearer ${token}` } }
);

Sorting​

Single Field (Ascending)​

curl -X GET "https://api.example.com/api/v4/core/PRD?sort=XPRD01" \
  -H "Authorization: Bearer ${TOKEN}"
const response = await fetch(
  'https://api.example.com/api/v4/core/PRD?sort=XPRD01',
  { headers: { 'Authorization': `Bearer ${token}` } }
);

Single Field (Descending)​

curl -X GET "https://api.example.com/api/v4/core/PRD?sort=-CREATED_AT" \
  -H "Authorization: Bearer ${TOKEN}"
const response = await fetch(
  'https://api.example.com/api/v4/core/PRD?sort=-CREATED_AT',
  { headers: { 'Authorization': `Bearer ${token}` } }
);

Multiple Fields​

curl -X GET "https://api.example.com/api/v4/core/PRD?sort=XPRD05,-XPRD02" \
  -H "Authorization: Bearer ${TOKEN}"
const response = await fetch(
  'https://api.example.com/api/v4/core/PRD?sort=XPRD05,-XPRD02',
  { headers: { 'Authorization': `Bearer ${token}` } }
);

Pagination​

Offset-Based​

# Page 1
curl -X GET "https://api.example.com/api/v4/core/PRD?\$num_rows=100&\$offset=0" \
  -H "Authorization: Bearer ${TOKEN}"

# Page 2
curl -X GET "https://api.example.com/api/v4/core/PRD?\$num_rows=100&\$offset=100" \
  -H "Authorization: Bearer ${TOKEN}"
async function fetchPage(page, pageSize = 100) {
  const offset = (page - 1) * pageSize;
  const params = new URLSearchParams({
    $num_rows: pageSize,
    $offset: offset
  });

  const response = await fetch(
    `https://api.example.com/api/v4/core/PRD?${params}`,
    { headers: { 'Authorization': `Bearer ${token}` } }
  );

  return response.json();
}

const page1 = await fetchPage(1);
const page2 = await fetchPage(2);
# Page 1
curl -X GET "https://api.example.com/api/v4/core/PRD?sort=PRD_ID&\$num_rows=100" \
  -H "Authorization: Bearer ${TOKEN}"

# Page 2 (lastId from page 1 = 1100)
curl -X GET "https://api.example.com/api/v4/core/PRD?filter[PRD_ID][\$gt]=1100&sort=PRD_ID&\$num_rows=100" \
  -H "Authorization: Bearer ${TOKEN}"
async function fetchNextPage(lastId = null, pageSize = 100) {
  const params = new URLSearchParams({
    sort: 'PRD_ID',
    $num_rows: pageSize
  });

  if (lastId) {
    params.set('filter[PRD_ID][$gt]', lastId);
  }

  const response = await fetch(
    `https://api.example.com/api/v4/core/PRD?${params}`,
    { headers: { 'Authorization': `Bearer ${token}` } }
  );

  const data = await response.json();
  const lastRecord = data.data[data.data.length - 1];

  return {
    data: data.data,
    nextPageId: lastRecord ? lastRecord.PRD_ID : null,
    hasMore: data.data.length === pageSize
  };
}

const page1 = await fetchNextPage();
const page2 = await fetchNextPage(page1.nextPageId);

Field Selection​

Select Specific Fields​

curl -X GET "https://api.example.com/api/v4/core/PRD?\$fields=XPRD01,XPRD02,XPRD05" \
  -H "Authorization: Bearer ${TOKEN}"
const params = new URLSearchParams({
  $fields: 'XPRD01,XPRD02,XPRD05'
});

const response = await fetch(
  `https://api.example.com/api/v4/core/PRD?${params}`,
  { headers: { 'Authorization': `Bearer ${token}` } }
);

Relational Queries (Expand)​

Single Relation​

curl -X GET "https://api.example.com/api/v4/core/PRD?\$expand=category" \
  -H "Authorization: Bearer ${TOKEN}"
const response = await fetch(
  'https://api.example.com/api/v4/core/PRD?$expand=category',
  { headers: { 'Authorization': `Bearer ${token}` } }
);

const products = await response.json();
products.data.forEach(product => {
  console.log(product.XPRD01, '->', product.category.XCAT01);
});

Multiple Relations​

curl -X GET "https://api.example.com/api/v4/core/ORD?\$expand=customer,items" \
  -H "Authorization: Bearer ${TOKEN}"
const response = await fetch(
  'https://api.example.com/api/v4/core/ORD?$expand=customer,items',
  { headers: { 'Authorization': `Bearer ${token}` } }
);

const orders = await response.json();
orders.data.forEach(order => {
  console.log('Customer:', order.customer.XCUST01);
  console.log('Items:', order.items.length);
});

Metadata Queries​

Get Dimension Metadata​

curl -X GET "https://api.example.com/api/v4/core/DIM/PRD" \
  -H "Authorization: Bearer ${TOKEN}"
const response = await fetch(
  'https://api.example.com/api/v4/core/DIM/PRD',
  { headers: { 'Authorization': `Bearer ${token}` } }
);

const dimConfig = await response.json();
console.log('Cascades:', dimConfig.data.CASCADE_DELETE);

Get Field Definitions​

curl -X GET "https://api.example.com/api/v4/core/PRD/fields" \
  -H "Authorization: Bearer ${TOKEN}"
const response = await fetch(
  'https://api.example.com/api/v4/core/PRD/fields',
  { headers: { 'Authorization': `Bearer ${token}` } }
);

const fields = await response.json();

// Filter by COD_ON_OFF
const createFields = fields.data.filter(f => f.COD_ON_OFF.includes('N'));
const updateFields = fields.data.filter(f => f.COD_ON_OFF.includes('M'));
const searchFields = fields.data.filter(f => f.COD_ON_OFF.includes('R'));

Count Records​

curl -X GET "https://api.example.com/api/v4/core/PRD/count?filter[XPRD05]=electronics" \
  -H "Authorization: Bearer ${TOKEN}"
const params = new URLSearchParams({
  'filter[XPRD05]': 'electronics'
});

const response = await fetch(
  `https://api.example.com/api/v4/core/PRD/count?${params}`,
  { headers: { 'Authorization': `Bearer ${token}` } }
);

const { count } = await response.json();
console.log(`Found ${count} electronics products`);

Combined Example (Complex Query)​

curl -X GET "https://api.example.com/api/v4/core/PRD?\
filter[XPRD05]=electronics&\
filter[XPRD02][\$between]=50,150&\
filter[XPRD06]=true&\
filter[CREATED_AT][\$gte]=20251201000000&\
sort=-XPRD02&\
\$num_rows=50&\
\$offset=0&\
\$fields=XPRD01,XPRD02,XPRD05&\
\$expand=category" \
  -H "Authorization: Bearer ${TOKEN}"
const params = new URLSearchParams({
  'filter[XPRD05]': 'electronics',
  'filter[XPRD02][$between]': '50,150',
  'filter[XPRD06]': 'true',
  'filter[CREATED_AT][$gte]': '20251201000000',
  'sort': '-XPRD02',
  '$num_rows': '50',
  '$offset': '0',
  '$fields': 'XPRD01,XPRD02,XPRD05',
  '$expand': 'category'
});

const response = await fetch(
  `https://api.example.com/api/v4/core/PRD?${params}`,
  { headers: { 'Authorization': `Bearer ${token}` } }
);

const { data, meta } = await response.json();
console.log(`Found ${meta.total} products, showing ${data.length}`);

Error Handling​

Basic Error Handling​

async function apiRequest(url, options = {}) {
  const response = await fetch(url, {
    ...options,
    headers: {
      'Authorization': `Bearer ${token}`,
      'Content-Type': 'application/json',
      ...options.headers
    }
  });

  if (!response.ok) {
    const error = await response.json();
    throw new Error(`API Error: ${error.message} (${error.code})`);
  }

  return response.json();
}

try {
  const product = await apiRequest('https://api.example.com/api/v4/core/PRD/123');
} catch (error) {
  console.error('Failed to fetch product:', error.message);
}

Token Refresh on 401​

async function apiRequestWithRefresh(url, options = {}) {
  let response = await fetch(url, {
    ...options,
    headers: {
      'Authorization': `Bearer ${accessToken}`,
      ...options.headers
    }
  });

  if (response.status === 401) {
    // Token expired - refresh
    const refreshResponse = await fetch('https://api.example.com/auth/refresh', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ refresh_token: refreshToken })
    });

    const { access_token } = await refreshResponse.json();
    accessToken = access_token;

    // Retry original request with new token
    response = await fetch(url, {
      ...options,
      headers: {
        'Authorization': `Bearer ${accessToken}`,
        ...options.headers
      }
    });
  }

  return response.json();
}

Retry with Exponential Backoff (429)​

async function retryWithBackoff(fn, maxRetries = 3) {
  for (let i = 0; i < maxRetries; i++) {
    try {
      return await fn();
    } catch (error) {
      if (error.status === 429 && i < maxRetries - 1) {
        const retryAfter = error.retry_after || Math.pow(2, i) * 1000;
        await new Promise(resolve => setTimeout(resolve, retryAfter));
      } else {
        throw error;
      }
    }
  }
}

const products = await retryWithBackoff(() =>
  apiRequest('https://api.example.com/api/v4/core/PRD')
);

Summary​

Common Operations:

  • ✅ Authentication (login, refresh)
  • ✅ CRUD (create, read, update, delete)
  • ✅ Filtering (equals, operators, multiple)
  • ✅ Sorting (single, multiple, ascending/descending)
  • ✅ Pagination (offset, keyset)
  • ✅ Field selection ($fields)
  • ✅ Relations ($expand)
  • ✅ Metadata queries (fields, count)
  • ✅ Error handling (retry, refresh)

Quick Tips:

  • Always include Authorization header
  • Use PATCH for partial updates
  • Default to soft delete (no ?force=true)
  • Use keyset pagination for large datasets
  • Select only needed fields with $fields
  • Prevent N+1 with $expand
  • Check COD_ON_OFF before operations
  • Implement token refresh for 401 errors
  • Use exponential backoff for 429 errors