Checking Product Details - OneClickDz Flexy API

Overview

Before placing orders, check product details to get real-time pricing, available denominations (types), and stock levels. This endpoint returns wholesale prices personalized to your account.

Never show wholesale prices to customers. Apply your markup before displaying.

API Reference

GET /v3/gift-cards/checkProduct/{productId}

Complete endpoint documentation

Basic Product Check

async function checkProduct(productId) {
  const response = await fetch(
    `https://api.oneclickdz.com/v3/gift-cards/checkProduct/${productId}`,
    {
      headers: {
        "X-Access-Token": process.env.API_KEY,
      },
    }
  );

  if (!response.ok) {
    throw new Error(`Failed to check product: ${response.status}`);
  }

  const result = await response.json();
  return result.data;
}

// Usage
const productId = "507f1f77bcf86cd799439011";
const product = await checkProduct(productId);

console.log(`Product: ${product.productTitle}`);
console.log(`Available types: ${product.types.length}`);
product.types.forEach((type) => {
  console.log(`  - ${type.name}: ${type.price} DA (stock: ${type.quantity})`);
});

import requests
import os

def check_product(product_id):
    response = requests.get(
        f'https://api.oneclickdz.com/v3/gift-cards/checkProduct/{product_id}',
        headers={'X-Access-Token': os.getenv('API_KEY')}
    )

    response.raise_for_status()
    return response.json()['data']

# Usage
product_id = '507f1f77bcf86cd799439011'
product = check_product(product_id)

print(f"Product: {product['productTitle']}")
print(f"Available types: {len(product['types'])}")
for ptype in product['types']:
    print(f"  - {ptype['name']}: {ptype['price']} DA (stock: {ptype['quantity']})")

<?php

function checkProduct($productId, $apiKey) {
    $url = "https://api.oneclickdz.com/v3/gift-cards/checkProduct/{$productId}";

    $ch = curl_init($url);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_HTTPHEADER, [
        'X-Access-Token: ' . $apiKey
    ]);

    $response = curl_exec($ch);
    $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);

    if ($httpCode !== 200) {
        throw new Exception("Failed to check product: " . $httpCode);
    }

    $result = json_decode($response, true);
    return $result['data'];
}

// Usage
$productId = '507f1f77bcf86cd799439011';
$product = checkProduct($productId, getenv('API_KEY'));

echo "Product: " . $product['productTitle'] . "\n";
echo "Available types: " . count($product['types']) . "\n";
foreach ($product['types'] as $type) {
    echo "  - {$type['name']}: {$type['price']} DA (stock: {$type['quantity']})\n";
}
?>

curl https://api.oneclickdz.com/v3/gift-cards/checkProduct/507f1f77bcf86cd799439011 \
  -H "X-Access-Token: YOUR_API_KEY"

Response Structure

{
  "success": true,
  "data": {
    "productId": "507f1f77bcf86cd799439011",
    "productTitle": "PlayStation Network",
    "types": [
      {
        "id": "type_001",
        "name": "PSN 500 DA",
        "price": 490,
        "quantity": 150
      },
      {
        "id": "type_002",
        "name": "PSN 1000 DA",
        "price": 980,
        "quantity": 87
      },
      {
        "id": "type_003",
        "name": "PSN 2000 DA",
        "price": 1960,
        "quantity": 0
      }
    ]
  }
}

Filtering Available Stock

Only show types that are in stock:

function getAvailableTypes(product) {
  return product.types.filter((type) => type.quantity > 0);
}

// Usage
const product = await checkProduct(productId);
const available = getAvailableTypes(product);

if (available.length === 0) {
  console.log("Product currently out of stock");
} else {
  console.log(`${available.length} denominations available`);
}

def get_available_types(product):
    return [t for t in product['types'] if t['quantity'] > 0]

# Usage
product = check_product(product_id)
available = get_available_types(product)

if not available:
    print('Product currently out of stock')
else:
    print(f"{len(available)} denominations available")

<?php

function getAvailableTypes($product) {
    return array_filter($product['types'], function($type) {
        return $type['quantity'] > 0;
    });
}

// Usage
$product = checkProduct($productId, $apiKey);
$available = array_values(getAvailableTypes($product));

if (empty($available)) {
    echo "Product currently out of stock\n";
} else {
    echo count($available) . " denominations available\n";
}
?>

Applying Customer Markup

Add your profit margin to wholesale prices:

function applyMarkup(types, markupPercent = 5) {
  return types
    .filter((type) => type.quantity > 0)
    .map((type) => ({
      id: type.id,
      name: type.name,
      wholesalePrice: type.price, // Store but don't show
      customerPrice: Math.ceil(type.price * (1 + markupPercent / 100)),
      available: true,
    }));
}

// Usage
const product = await checkProduct(productId);
const customerPrices = applyMarkup(product.types, 5); // 5% markup

customerPrices.forEach((type) => {
  console.log(`${type.name}: ${type.customerPrice} DA`);
  // Don't log wholesalePrice in production!
});

import math

def apply_markup(types, markup_percent=5):
    available = [t for t in types if t['quantity'] > 0]

    return [
        {
            'id': t['id'],
            'name': t['name'],
            'wholesalePrice': t['price'],  # Store but don't show
            'customerPrice': math.ceil(t['price'] * (1 + markup_percent / 100)),
            'available': True
        }
        for t in available
    ]

# Usage
product = check_product(product_id)
customer_prices = apply_markup(product['types'], markup_percent=5)

for ptype in customer_prices:
    print(f"{ptype['name']}: {ptype['customerPrice']} DA")

<?php

function applyMarkup($types, $markupPercent = 5) {
    $available = array_filter($types, function($type) {
        return $type['quantity'] > 0;
    });

    return array_map(function($type) use ($markupPercent) {
        return [
            'id' => $type['id'],
            'name' => $type['name'],
            'wholesalePrice' => $type['price'], // Store but don't show
            'customerPrice' => ceil($type['price'] * (1 + $markupPercent / 100)),
            'available' => true
        ];
    }, $available);
}

// Usage
$product = checkProduct($productId, $apiKey);
$customerPrices = applyMarkup($product['types'], 5); // 5% markup

foreach ($customerPrices as $type) {
    echo "{$type['name']}: {$type['customerPrice']} DA\n";
}
?>

Stock Validation Before Ordering

Always verify stock before allowing orders:

async function validateStock(productId, typeId, quantity) {
  const product = await checkProduct(productId);
  const type = product.types.find((t) => t.id === typeId);

  if (!type) {
    throw new Error("Invalid type ID");
  }

  if (type.quantity === 0) {
    throw new Error("Product out of stock");
  }

  if (type.quantity < quantity) {
    throw new Error(
      `Insufficient stock. Available: ${type.quantity}, Requested: ${quantity}`
    );
  }

  return {
    valid: true,
    type,
    totalCost: type.price * quantity,
  };
}

// Usage
try {
  const validation = await validateStock(productId, "type_001", 5);
  console.log(`Order valid. Total cost: ${validation.totalCost} DA`);
} catch (error) {
  console.error("Validation failed:", error.message);
}

def validate_stock(product_id, type_id, quantity):
    product = check_product(product_id)
    ptype = next((t for t in product['types'] if t['id'] == type_id), None)

    if not ptype:
        raise ValueError('Invalid type ID')

    if ptype['quantity'] == 0:
        raise ValueError('Product out of stock')

    if ptype['quantity'] < quantity:
        raise ValueError(
            f"Insufficient stock. Available: {ptype['quantity']}, Requested: {quantity}"
        )

    return {
        'valid': True,
        'type': ptype,
        'totalCost': ptype['price'] * quantity
    }

# Usage
try:
    validation = validate_stock(product_id, 'type_001', 5)
    print(f"Order valid. Total cost: {validation['totalCost']} DA")
except ValueError as e:
    print(f"Validation failed: {e}")

<?php

function validateStock($productId, $typeId, $quantity, $apiKey) {
    $product = checkProduct($productId, $apiKey);

    $type = null;
    foreach ($product['types'] as $t) {
        if ($t['id'] === $typeId) {
            $type = $t;
            break;
        }
    }

    if ($type === null) {
        throw new Exception('Invalid type ID');
    }

    if ($type['quantity'] === 0) {
        throw new Exception('Product out of stock');
    }

    if ($type['quantity'] < $quantity) {
        throw new Exception(
            "Insufficient stock. Available: {$type['quantity']}, Requested: {$quantity}"
        );
    }

    return [
        'valid' => true,
        'type' => $type,
        'totalCost' => $type['price'] * $quantity
    ];
}

// Usage
try {
    $validation = validateStock($productId, 'type_001', 5, $apiKey);
    echo "Order valid. Total cost: {$validation['totalCost']} DA\n";
} catch (Exception $e) {
    echo "Validation failed: " . $e->getMessage() . "\n";
}
?>

Best Practices

Check Before Order

Always verify stock before placing orders

Hide Wholesale Prices

Never display raw price values to customers

Cache Briefly

Cache for 1-2 minutes during checkout flow

Handle Out of Stock

Gracefully handle zero quantity scenarios

Error Handling

async function checkProductSafely(productId) {
  try {
    return await checkProduct(productId);
  } catch (error) {
    if (error.message.includes("404")) {
      throw new Error("Product not found or disabled");
    }

    if (error.message.includes("401")) {
      throw new Error("Invalid API key");
    }

    console.error("Failed to check product:", error);
    throw new Error("Unable to load product details. Please try again.");
  }
}

Next Steps

Place Orders

Submit validated orders

Track Status

Monitor order fulfillment

API Reference

Complete endpoint documentation

Load Catalog

Fetch available products

Overview

Back to integration overview

Secure Delivery

Encrypt and deliver cards

​Overview

​API Reference

GET /v3/gift-cards/checkProduct/{productId}

​Basic Product Check

​Response Structure

​Filtering Available Stock

​Applying Customer Markup

​Stock Validation Before Ordering

​Best Practices

Check Before Order

Hide Wholesale Prices

Cache Briefly

Handle Out of Stock

​Error Handling

​Next Steps

Place Orders

Track Status

API Reference

Load Catalog

Overview

Secure Delivery

Overview

API Reference

Basic Product Check

Response Structure

Filtering Available Stock

Applying Customer Markup

Stock Validation Before Ordering

Best Practices

Error Handling

Next Steps