SellerLegend API Documentation

<?php
use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://app.sellerlegend.com/api/',
    'headers' => [
        'Authorization' => 'Bearer YOUR_ACCESS_TOKEN'
    ]
]);

$response = $client->request('GET', 'user/me');
$userData = json_decode($response->getBody(), true);

echo "User: " . $userData['user']['name'] . "\n";
echo "Email: " . $userData['user']['email'] . "\n";

const getUser = async () => {
    const response = await fetch('https://app.sellerlegend.com/api/user/me', {
        method: 'GET',
        headers: {
            'Authorization': 'Bearer YOUR_ACCESS_TOKEN',
            'Content-Type': 'application/json'
        }
    });

    const userData = await response.json();
    console.log('User:', userData.user.name);
    console.log('Email:', userData.user.email);
    return userData;
};

getUser();

curl -X GET "https://app.sellerlegend.com/api/user/me" \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN"

<?php
use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://app.sellerlegend.com/api/',
    'headers' => [
        'Authorization' => 'Bearer YOUR_ACCESS_TOKEN'
    ]
]);

$response = $client->request('GET', 'user/accounts');
$accountsData = json_decode($response->getBody(), true);

// Process all accounts
foreach ($accountsData['accounts'] as $account) {
    echo "Account: " . $account['account_title'] . "\n";
    echo "  - Seller ID: " . $account['seller_id'] . "\n";
    echo "  - Marketplace: " . $account['marketplace'] . "\n";
    echo "  - Country: " . $account['country_code'] . "\n";
}

// Store first account for future use
if (!empty($accountsData['accounts'])) {
    $firstAccount = $accountsData['accounts'][0];
    $accountTitle = $firstAccount['account_title'];
}

const getAccounts = async () => {
    const response = await fetch('https://app.sellerlegend.com/api/user/accounts', {
        method: 'GET',
        headers: {
            'Authorization': 'Bearer YOUR_ACCESS_TOKEN',
            'Content-Type': 'application/json'
        }
    });

    const data = await response.json();

    // Process all accounts
    data.accounts.forEach(account => {
        console.log(`Account: ${account.account_title}`);
        console.log(`  - Seller ID: ${account.seller_id}`);
        console.log(`  - Marketplace: ${account.marketplace}`);
        console.log(`  - Country: ${account.country_code}`);
    });

    // Store first account for future API calls
    if (data.accounts.length > 0) {
        const firstAccount = data.accounts[0];
        localStorage.setItem('account_title', firstAccount.account_title);
    }

    return data;
};

getAccounts();

curl -X GET "https://app.sellerlegend.com/api/user/accounts" \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN"

<?php
use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://app.sellerlegend.com/api/',
    'headers' => [
        'Authorization' => 'Bearer YOUR_ACCESS_TOKEN'
    ]
]);

$response = $client->request('GET', 'sales/orders', [
    'query' => [
        'account_title' => 'My Store US',  // Account selection as parameter
        'per_page' => 250,
        'start_date' => '2024-01-01',
        'end_date' => '2024-01-31',
        'sales_channel' => 'amazon'  // Optional
    ]
]);

$ordersData = json_decode($response->getBody(), true);

// Process orders
foreach ($ordersData['data'] as $order) {
    echo "Order ID: " . $order['amazon_order_id'] . "\n";
    echo "Date: " . $order['purchase_date'] . "\n";
    echo "Total: " . $order['order_total'] . " " . $order['currency_code'] . "\n";
    echo "Items: " . $order['quantity_ordered'] . "\n\n";
}

echo "Total orders: " . $ordersData['total'] . "\n";
echo "Page " . $ordersData['current_page'] . " of " . $ordersData['last_page'];

const getOrders = async () => {
    const params = new URLSearchParams({
        account_title: 'My Store US',  // Account selection as parameter
        per_page: 250,
        start_date: '2024-01-01',
        end_date: '2024-01-31',
        sales_channel: 'amazon'  // Optional
    });

    const response = await fetch(`https://app.sellerlegend.com/api/sales/orders?${params}`, {
        method: 'GET',
        headers: {
            'Authorization': 'Bearer YOUR_ACCESS_TOKEN',
            'Content-Type': 'application/json'
        }
    });

    const ordersData = await response.json();

    // Process orders
    ordersData.data.forEach(order => {
        console.log(`Order ID: ${order.amazon_order_id}`);
        console.log(`Date: ${order.purchase_date}`);
        console.log(`Total: ${order.order_total} ${order.currency_code}`);
        console.log(`Items: ${order.quantity_ordered}`);
    });

    console.log(`Total orders: ${ordersData.total}`);
    console.log(`Page ${ordersData.current_page} of ${ordersData.last_page}`);

    return ordersData;
};

getOrders();

curl -X GET "https://app.sellerlegend.com/api/sales/orders?account_title=My%20Store%20US&per_page=250&start_date=2024-01-01&end_date=2024-01-31&sales_channel=amazon" \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN"

<?php
use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://app.sellerlegend.com/api/',
    'headers' => [
        'Authorization' => 'Bearer YOUR_ACCESS_TOKEN'
    ]
]);

$response = $client->request('GET', 'sales/statistics-dashboard', [
    'query' => [
        'account_title' => 'My Store US',
        'view_by' => 'product',
        'group_by' => 'sku',  // Group by SKU, ASIN, or parent ASIN
        'per_page' => 500,
        'start_date' => '2024-01-01',
        'end_date' => '2024-01-31',
        'currency' => 'USD'
    ]
]);

$statsData = json_decode($response->getBody(), true);

// Process statistics
foreach ($statsData['data'] as $item) {
    echo "SKU: " . $item['sku'] . "\n";
    echo "Product: " . $item['product_name'] . "\n";
    echo "Units Sold: " . $item['units_ordered'] . "\n";
    echo "Revenue: $" . $item['product_sales'] . "\n";
    echo "Profit: $" . $item['profit'] . "\n";
    echo "ROI: " . $item['roi'] . "%\n";
    echo "---\n";
}

const getSalesStatistics = async () => {
    const params = new URLSearchParams({
        account_title: 'My Store US',
        view_by: 'product',
        group_by: 'sku',  // Group by SKU, ASIN, or parent ASIN
        per_page: 500,
        start_date: '2024-01-01',
        end_date: '2024-01-31',
        currency: 'USD'
    });

    const response = await fetch(`https://app.sellerlegend.com/api/sales/statistics-dashboard?${params}`, {
        method: 'GET',
        headers: {
            'Authorization': 'Bearer YOUR_ACCESS_TOKEN',
            'Content-Type': 'application/json'
        }
    });

    const statsData = await response.json();

    // Process statistics
    statsData.data.forEach(item => {
        console.log(`SKU: ${item.sku}`);
        console.log(`Product: ${item.product_name}`);
        console.log(`Units Sold: ${item.units_ordered}`);
        console.log(`Revenue: $${item.product_sales}`);
        console.log(`Profit: $${item.profit}`);
        console.log(`ROI: ${item.roi}%`);
        console.log('---');
    });

    return statsData;
};

getSalesStatistics();

curl -X GET "https://app.sellerlegend.com/api/sales/statistics-dashboard?account_title=My%20Store%20US&view_by=product&group_by=sku&per_page=500&start_date=2024-01-01&end_date=2024-01-31¤cy=USD" \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN"

<?php
use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://app.sellerlegend.com/api/',
    'headers' => [
        'Authorization' => 'Bearer YOUR_ACCESS_TOKEN'
    ]
]);

$response = $client->request('GET', 'sales/per-day-per-product', [
    'query' => [
        'account_title' => 'My Store US',
        'per_page' => 500,
        'start_date' => '2024-01-01',
        'end_date' => '2024-01-31',
        'sales_channel' => 'amazon',
        'currency' => 'USD'
    ]
]);

$dailySales = json_decode($response->getBody(), true);

// Process daily sales data
foreach ($dailySales['data'] as $item) {
    echo "Date: {$item['date']}\n";
    echo "SKU: {$item['sku']}\n";
    echo "Product: {$item['product_name']}\n";
    echo "Units Sold: {$item['units_ordered']}\n";
    echo "Revenue: \${$item['product_sales']}\n";
    echo "---\n";
}

const getDailySales = async () => {
    const params = new URLSearchParams({
        account_title: 'My Store US',
        per_page: 500,
        start_date: '2024-01-01',
        end_date: '2024-01-31',
        sales_channel: 'amazon',
        currency: 'USD'
    });

    const response = await fetch(`https://app.sellerlegend.com/api/sales/per-day-per-product?${params}`, {
        method: 'GET',
        headers: {
            'Authorization': 'Bearer YOUR_ACCESS_TOKEN',
            'Content-Type': 'application/json'
        }
    });

    const dailySales = await response.json();

    // Process daily sales data
    dailySales.data.forEach(item => {
        console.log(`Date: ${item.date}`);
        console.log(`SKU: ${item.sku}`);
        console.log(`Product: ${item.product_name}`);
        console.log(`Units Sold: ${item.units_ordered}`);
        console.log(`Revenue: $${item.product_sales}`);
        console.log('---');
    });

    return dailySales;
};

getDailySales();

curl -X GET "https://app.sellerlegend.com/api/sales/per-day-per-product?account_title=My%20Store%20US&per_page=500&start_date=2024-01-01&end_date=2024-01-31&sales_channel=amazon¤cy=USD" \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN"

<?php
use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://app.sellerlegend.com/api/',
    'headers' => [
        'Authorization' => 'Bearer YOUR_ACCESS_TOKEN'
    ]
]);

$response = $client->request('GET', 'sales/transactions', [
    'query' => [
        'account_title' => 'My Store US',
        'per_page' => 500,
        'start_date' => '2024-01-01',
        'end_date' => '2024-01-31'
    ]
]);

$transactions = json_decode($response->getBody(), true);

// Process transactions
foreach ($transactions['data'] as $transaction) {
    echo "Date: {$transaction['posted_date']}\n";
    echo "Type: {$transaction['transaction_type']}\n";
    echo "Order ID: {$transaction['amazon_order_id']}\n";
    echo "SKU: {$transaction['sku']}\n";
    echo "Amount: \${$transaction['amount']}\n";
    echo "Currency: {$transaction['currency']}\n";
    echo "---\n";
}

const getTransactions = async () => {
    const params = new URLSearchParams({
        account_title: 'My Store US',
        per_page: 500,
        start_date: '2024-01-01',
        end_date: '2024-01-31'
    });

    const response = await fetch(`https://app.sellerlegend.com/api/sales/transactions?${params}`, {
        method: 'GET',
        headers: {
            'Authorization': 'Bearer YOUR_ACCESS_TOKEN',
            'Content-Type': 'application/json'
        }
    });

    const transactions = await response.json();

    // Process transactions
    transactions.data.forEach(transaction => {
        console.log(`Date: ${transaction.posted_date}`);
        console.log(`Type: ${transaction.transaction_type}`);
        console.log(`Order ID: ${transaction.amazon_order_id}`);
        console.log(`SKU: ${transaction.sku}`);
        console.log(`Amount: $${transaction.amount}`);
        console.log(`Currency: ${transaction.currency}`);
        console.log('---');
    });

    return transactions;
};

getTransactions();

curl -X GET "https://app.sellerlegend.com/api/sales/transactions?account_title=My%20Store%20US&per_page=500&start_date=2024-01-01&end_date=2024-01-31" \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN"

<?php
use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://app.sellerlegend.com/api/',
    'headers' => [
        'Authorization' => 'Bearer YOUR_ACCESS_TOKEN'
    ]
]);

$response = $client->request('GET', 'inventory/list', [
    'query' => [
        'account_title' => 'My Store US',
        'per_page' => 500,
        'velocity_start_date' => '2024-01-01',
        'velocity_end_date' => '2024-01-31'
    ]
]);

$inventory = json_decode($response->getBody(), true);

// Process inventory data
foreach ($inventory['data'] as $item) {
    echo "SKU: {$item['sku']}\n";
    echo "Product: {$item['product_name']}\n";
    echo "ASIN: {$item['asin']}\n";
    echo "FBA Available: {$item['afn_fulfillable_quantity']}\n";
    echo "FBA Reserved: {$item['afn_reserved_quantity']}\n";
    echo "FBA Inbound: {$item['afn_inbound_quantity']}\n";
    echo "Velocity (30d): {$item['velocity_30_days']} units/day\n";
    echo "Days of Stock: {$item['days_of_stock']}\n";
    echo "---\n";
}

const getInventory = async () => {
    const params = new URLSearchParams({
        account_title: 'My Store US',
        per_page: 500,
        velocity_start_date: '2024-01-01',
        velocity_end_date: '2024-01-31'
    });

    const response = await fetch(`https://app.sellerlegend.com/api/inventory/list?${params}`, {
        method: 'GET',
        headers: {
            'Authorization': 'Bearer YOUR_ACCESS_TOKEN',
            'Content-Type': 'application/json'
        }
    });

    const inventory = await response.json();

    // Process inventory data
    inventory.data.forEach(item => {
        console.log(`SKU: ${item.sku}`);
        console.log(`Product: ${item.product_name}`);
        console.log(`ASIN: ${item.asin}`);
        console.log(`FBA Available: ${item.afn_fulfillable_quantity}`);
        console.log(`FBA Reserved: ${item.afn_reserved_quantity}`);
        console.log(`FBA Inbound: ${item.afn_inbound_quantity}`);
        console.log(`Velocity (30d): ${item.velocity_30_days} units/day`);
        console.log(`Days of Stock: ${item.days_of_stock}`);
        console.log('---');
    });

    return inventory;
};

getInventory();

curl -X GET "https://app.sellerlegend.com/api/inventory/list?account_title=My%20Store%20US&per_page=500&velocity_start_date=2024-01-01&velocity_end_date=2024-01-31" \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN"

<?php
use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://app.sellerlegend.com/api/',
    'headers' => [
        'Authorization' => 'Bearer YOUR_ACCESS_TOKEN'
    ]
]);

$response = $client->request('GET', 'cogs/cost-periods', [
    'query' => [
        'account_title' => 'My Store US',
        'sku' => 'PROD-SKU-001'
    ]
]);

$costPeriods = json_decode($response->getBody(), true);

// Process cost periods
foreach ($costPeriods['data'] as $period) {
    echo "Period: {$period['from_date']} to {$period['to_date']}\n";
    foreach ($period['cost_elements'] as $element) {
        echo "  {$element['cost_element']}: \${$element['amount']} {$element['currency']}\n";
        echo "  Provider: {$element['provider']}\n";
        echo "  Notes: {$element['notes']}\n";
    }
}

const getCostPeriods = async () => {
    const params = new URLSearchParams({
        account_title: 'My Store US',
        sku: 'PROD-SKU-001'
    });

    const response = await fetch(`https://app.sellerlegend.com/api/cogs/cost-periods?${params}`, {
        method: 'GET',
        headers: {
            'Authorization': 'Bearer YOUR_ACCESS_TOKEN',
            'Content-Type': 'application/json'
        }
    });

    const costPeriods = await response.json();

    // Process cost periods
    costPeriods.data.forEach(period => {
        console.log(`Period: ${period.from_date} to ${period.to_date}`);
        period.cost_elements.forEach(element => {
            console.log(`  ${element.cost_element}: $${element.amount} ${element.currency}`);
            console.log(`  Provider: ${element.provider}`);
            console.log(`  Notes: ${element.notes}`);
        });
    });

    return costPeriods;
};

getCostPeriods();

curl -X GET "https://app.sellerlegend.com/api/cogs/cost-periods?account_title=My%20Store%20US&sku=PROD-SKU-001" \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN"

<?php
use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://app.sellerlegend.com/api/',
    'headers' => [
        'Authorization' => 'Bearer YOUR_ACCESS_TOKEN',
        'Content-Type' => 'application/json'
    ]
]);

$costData = [
    'sku' => 'PROD-SKU-001',
    'data' => [
        [
            'dates' => [
                'from_date' => '2024-01-01',
                'to_date' => '2024-12-31'
            ],
            'cost_elements' => [
                [
                    'cost_element' => 'Product Cost',
                    'provider' => 'Supplier Name',
                    'notes' => '2024 pricing',
                    'total_amount' => 25.00,
                    'currency' => 'USD',
                    'conversion_rate' => '1.00',
                    'units' => 1,
                    'amount' => 25.00
                ],
                [
                    'cost_element' => 'Shipping Cost',
                    'provider' => 'DHL',
                    'notes' => 'Sea freight',
                    'total_amount' => 3.50,
                    'currency' => 'USD',
                    'conversion_rate' => '1.00',
                    'units' => 1,
                    'amount' => 3.50
                ]
            ]
        ]
    ]
];

$response = $client->request('POST', 'cogs/cost-periods', [
    'query' => ['account_title' => 'My Store US'],
    'json' => $costData
]);

$result = json_decode($response->getBody(), true);
echo "Cost update status: {$result['status']}\n";

const updateCostPeriods = async () => {
    const costData = {
        sku: 'PROD-SKU-001',
        data: [
            {
                dates: {
                    from_date: '2024-01-01',
                    to_date: '2024-12-31'
                },
                cost_elements: [
                    {
                        cost_element: 'Product Cost',
                        provider: 'Supplier Name',
                        notes: '2024 pricing',
                        total_amount: 25.00,
                        currency: 'USD',
                        conversion_rate: '1.00',
                        units: 1,
                        amount: 25.00
                    },
                    {
                        cost_element: 'Shipping Cost',
                        provider: 'DHL',
                        notes: 'Sea freight',
                        total_amount: 3.50,
                        currency: 'USD',
                        conversion_rate: '1.00',
                        units: 1,
                        amount: 3.50
                    }
                ]
            }
        ]
    };

    const params = new URLSearchParams({ account_title: 'My Store US' });

    const response = await fetch(`https://app.sellerlegend.com/api/cogs/cost-periods?${params}`, {
        method: 'POST',
        headers: {
            'Authorization': 'Bearer YOUR_ACCESS_TOKEN',
            'Content-Type': 'application/json'
        },
        body: JSON.stringify(costData)
    });

    const result = await response.json();
    console.log(`Cost update status: ${result.status}`);

    return result;
};

updateCostPeriods();

curl -X POST "https://app.sellerlegend.com/api/cogs/cost-periods?account_title=My%20Store%20US" \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "sku": "PROD-SKU-001",
    "data": [
      {
        "dates": {
          "from_date": "2024-01-01",
          "to_date": "2024-12-31"
        },
        "cost_elements": [
          {
            "cost_element": "Product Cost",
            "provider": "Supplier Name",
            "notes": "2024 pricing",
            "total_amount": 25.00,
            "currency": "USD",
            "conversion_rate": "1.00",
            "units": 1,
            "amount": 25.00
          }
        ]
      }
    ]
  }'

<?php
use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://app.sellerlegend.com/api/',
    'headers' => [
        'Authorization' => 'Bearer YOUR_ACCESS_TOKEN',
        'Content-Type' => 'application/json'
    ]
]);

// Request report for specific SKU
$response = $client->request('POST', 'reports/request', [
    'query' => ['account_title' => 'My Store US'],
    'json' => [
        'product_sku' => 'PROD-SKU-001'
    ]
]);

$report = json_decode($response->getBody(), true);
echo "Report ID: {$report['report_id']}\n";
echo "Status: {$report['status']}\n";

const requestReport = async () => {
    const params = new URLSearchParams({ account_title: 'My Store US' });

    const response = await fetch(`https://app.sellerlegend.com/api/reports/request?${params}`, {
        method: 'POST',
        headers: {
            'Authorization': 'Bearer YOUR_ACCESS_TOKEN',
            'Content-Type': 'application/json'
        },
        body: JSON.stringify({
            product_sku: 'PROD-SKU-001'
        })
    });

    const report = await response.json();
    console.log(`Report ID: ${report.report_id}`);
    console.log(`Status: ${report.status}`);

    return report;
};

requestReport();

curl -X POST "https://app.sellerlegend.com/api/reports/request?account_title=My%20Store%20US" \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"product_sku": "PROD-SKU-001"}'

<?php
use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://app.sellerlegend.com/api/',
    'headers' => [
        'Authorization' => 'Bearer YOUR_ACCESS_TOKEN'
    ]
]);

$response = $client->request('GET', 'reports/status', [
    'query' => [
        'account_title' => 'My Store US',
        'report_id' => 12345
    ]
]);

$status = json_decode($response->getBody(), true);
echo "Report Status: {$status['status']}\n";
echo "Progress: " . ($status['progress'] ?? 0) . "%\n";

const checkReportStatus = async (reportId) => {
    const params = new URLSearchParams({
        account_title: 'My Store US',
        report_id: reportId
    });

    const response = await fetch(`https://app.sellerlegend.com/api/reports/status?${params}`, {
        method: 'GET',
        headers: {
            'Authorization': 'Bearer YOUR_ACCESS_TOKEN',
            'Content-Type': 'application/json'
        }
    });

    const status = await response.json();
    console.log(`Report Status: ${status.status}`);
    console.log(`Progress: ${status.progress || 0}%`);

    return status;
};

checkReportStatus(12345);

curl -X GET "https://app.sellerlegend.com/api/reports/status?account_title=My%20Store%20US&report_id=12345" \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN"

<?php
use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://app.sellerlegend.com/api/',
    'headers' => [
        'Authorization' => 'Bearer YOUR_ACCESS_TOKEN'
    ]
]);

// Download report as CSV
$response = $client->request('GET', 'reports/download', [
    'query' => [
        'account_title' => 'My Store US',
        'report_id' => 12345,
        'format' => 'csv'
    ]
]);

$csvData = $response->getBody()->getContents();
file_put_contents('report.csv', $csvData);
echo "Report saved to report.csv\n";

const downloadReport = async () => {
    const params = new URLSearchParams({
        account_title: 'My Store US',
        report_id: 12345,
        format: 'csv'
    });

    const response = await fetch(`https://app.sellerlegend.com/api/reports/download?${params}`, {
        method: 'GET',
        headers: {
            'Authorization': 'Bearer YOUR_ACCESS_TOKEN'
        }
    });

    // Handle CSV download
    const csvData = await response.text();

    // Create download link
    const blob = new Blob([csvData], { type: 'text/csv' });
    const url = window.URL.createObjectURL(blob);
    const a = document.createElement('a');
    a.href = url;
    a.download = 'report.csv';
    a.click();
};

downloadReport();

# Download as CSV
curl -X GET "https://app.sellerlegend.com/api/reports/download?account_title=My%20Store%20US&report_id=12345&format=csv" \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
  -o report.csv

# Download as JSON
curl -X GET "https://app.sellerlegend.com/api/reports/download?account_title=My%20Store%20US&report_id=12345&format=json" \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
  | jq '.data'

<?php
use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://app.sellerlegend.com/api/',
    'headers' => [
        'Authorization' => 'Bearer YOUR_ACCESS_TOKEN'
    ]
]);

$response = $client->request('GET', 'service-status');
$status = json_decode($response->getBody(), true);

if ($status['status'] == 'Success') {
    echo "API Service is {$status['message']}\n";
    echo "Response code: {$status['code']}\n";
} else {
    echo "Service may be experiencing issues\n";
}

const checkServiceStatus = async () => {
    const response = await fetch('https://app.sellerlegend.com/api/service-status', {
        method: 'GET',
        headers: {
            'Authorization': 'Bearer YOUR_ACCESS_TOKEN',
            'Content-Type': 'application/json'
        }
    });

    const status = await response.json();

    if (status.status === 'Success') {
        console.log(`API Service is ${status.message}`);
        console.log(`Response code: ${status.code}`);
    } else {
        console.log('Service may be experiencing issues');
    }

    return status;
};

checkServiceStatus();

curl -X GET "https://app.sellerlegend.com/api/service-status" \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN"

<?php
use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://app.sellerlegend.com/api/',
    'headers' => [
        'Authorization' => 'Bearer YOUR_ACCESS_TOKEN'
    ]
]);

$response = $client->request('GET', 'connections/list', [
    'query' => [
        'account_title' => 'My Store US'
    ]
]);

$connections = json_decode($response->getBody(), true);

// Process connections
foreach ($connections['data'] as $connection) {
    echo "Connection Type: {$connection['type']}\n";
    echo "Marketplace: {$connection['marketplace']}\n";
    echo "Status: {$connection['status']}\n";
    echo "Last Sync: {$connection['last_sync']}\n";
    echo "---\n";
}

const getConnections = async () => {
    const params = new URLSearchParams({
        account_title: 'My Store US'
    });

    const response = await fetch(`https://app.sellerlegend.com/api/connections/list?${params}`, {
        method: 'GET',
        headers: {
            'Authorization': 'Bearer YOUR_ACCESS_TOKEN',
            'Content-Type': 'application/json'
        }
    });

    const connections = await response.json();

    // Process connections
    connections.data.forEach(connection => {
        console.log(`Connection Type: ${connection.type}`);
        console.log(`Marketplace: ${connection.marketplace}`);
        console.log(`Status: ${connection.status}`);
        console.log(`Last Sync: ${connection.last_sync}`);
        console.log('---');
    });

    return connections;
};

getConnections();

curl -X GET "https://app.sellerlegend.com/api/connections/list?account_title=My%20Store%20US" \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN"

<?php
use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://app.sellerlegend.com/api/',
    'headers' => [
        'Authorization' => 'Bearer YOUR_ACCESS_TOKEN'
    ]
]);

$response = $client->request('GET', 'warehouse/list', [
    'query' => [
        'account_title' => 'My Store US',
        'per_page' => 500
    ]
]);

$warehouseInventory = json_decode($response->getBody(), true);

// Process warehouse inventory
foreach ($warehouseInventory['data'] as $item) {
    echo "SKU: {$item['sku']}\n";
    echo "Warehouse: {$item['warehouse_name']}\n";
    echo "Quantity: {$item['quantity']}\n";
    echo "Location: {$item['location']}\n";
    echo "Status: {$item['status']}\n";
    echo "---\n";
}

const getWarehouseInventory = async () => {
    const params = new URLSearchParams({
        account_title: 'My Store US',
        per_page: 500
    });

    const response = await fetch(`https://app.sellerlegend.com/api/warehouse/list?${params}`, {
        method: 'GET',
        headers: {
            'Authorization': 'Bearer YOUR_ACCESS_TOKEN',
            'Content-Type': 'application/json'
        }
    });

    const warehouseInventory = await response.json();

    // Process warehouse inventory
    warehouseInventory.data.forEach(item => {
        console.log(`SKU: ${item.sku}`);
        console.log(`Warehouse: ${item.warehouse_name}`);
        console.log(`Quantity: ${item.quantity}`);
        console.log(`Location: ${item.location}`);
        console.log(`Status: ${item.status}`);
        console.log('---');
    });

    return warehouseInventory;
};

getWarehouseInventory();

curl -X GET "https://app.sellerlegend.com/api/warehouse/list?account_title=My%20Store%20US&per_page=500" \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN"

<?php
use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://app.sellerlegend.com/api/',
    'headers' => [
        'Authorization' => 'Bearer YOUR_ACCESS_TOKEN'
    ]
]);

$response = $client->request('GET', 'warehouse/inbound-shipments', [
    'query' => [
        'account_title' => 'My Store US',
        'per_page' => 500
    ]
]);

$shipments = json_decode($response->getBody(), true);

// Process inbound shipments
foreach ($shipments['data'] as $shipment) {
    echo "Shipment ID: {$shipment['shipment_id']}\n";
    echo "Status: {$shipment['status']}\n";
    echo "Destination: {$shipment['destination_fulfillment_center']}\n";
    echo "Items: {$shipment['total_items']}\n";
    echo "ETA: {$shipment['estimated_arrival_date']}\n";
    echo "---\n";
}

const getInboundShipments = async () => {
    const params = new URLSearchParams({
        account_title: 'My Store US',
        per_page: 500
    });

    const response = await fetch(`https://app.sellerlegend.com/api/warehouse/inbound-shipments?${params}`, {
        method: 'GET',
        headers: {
            'Authorization': 'Bearer YOUR_ACCESS_TOKEN',
            'Content-Type': 'application/json'
        }
    });

    const shipments = await response.json();

    // Process inbound shipments
    shipments.data.forEach(shipment => {
        console.log(`Shipment ID: ${shipment.shipment_id}`);
        console.log(`Status: ${shipment.status}`);
        console.log(`Destination: ${shipment.destination_fulfillment_center}`);
        console.log(`Items: ${shipment.total_items}`);
        console.log(`ETA: ${shipment.estimated_arrival_date}`);
        console.log('---');
    });

    return shipments;
};

getInboundShipments();

curl -X GET "https://app.sellerlegend.com/api/warehouse/inbound-shipments?account_title=My%20Store%20US&per_page=500" \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN"

<?php
use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://app.sellerlegend.com/api/',
    'headers' => [
        'Authorization' => 'Bearer YOUR_ACCESS_TOKEN'
    ]
]);

$response = $client->request('GET', 'supply-chain/restock-suggestions', [
    'query' => [
        'account_title' => 'My Store US',
        'per_page' => 500,
        'currency' => 'USD'
    ]
]);

$suggestions = json_decode($response->getBody(), true);

// Process restock suggestions
foreach ($suggestions['data'] as $item) {
    echo "SKU: {$item['sku']}\n";
    echo "Product: {$item['product_name']}\n";
    echo "Current Stock: {$item['current_stock']} units\n";
    echo "Days of Stock: {$item['days_of_stock']}\n";
    echo "Restock Quantity: {$item['suggested_quantity']} units\n";
    echo "Restock By: {$item['restock_by_date']}\n";
    echo "Lead Time: {$item['lead_time_days']} days\n";
    echo "---\n";
}

const getRestockSuggestions = async () => {
    const params = new URLSearchParams({
        account_title: 'My Store US',
        per_page: 500,
        currency: 'USD'
    });

    const response = await fetch(`https://app.sellerlegend.com/api/supply-chain/restock-suggestions?${params}`, {
        method: 'GET',
        headers: {
            'Authorization': 'Bearer YOUR_ACCESS_TOKEN',
            'Content-Type': 'application/json'
        }
    });

    const suggestions = await response.json();

    // Process restock suggestions
    suggestions.data.forEach(item => {
        console.log(`SKU: ${item.sku}`);
        console.log(`Product: ${item.product_name}`);
        console.log(`Current Stock: ${item.current_stock} units`);
        console.log(`Days of Stock: ${item.days_of_stock}`);
        console.log(`Restock Quantity: ${item.suggested_quantity} units`);
        console.log(`Restock By: ${item.restock_by_date}`);
        console.log(`Lead Time: ${item.lead_time_days} days`);
        console.log('---');
    });

    return suggestions;
};

getRestockSuggestions();

curl -X GET "https://app.sellerlegend.com/api/supply-chain/restock-suggestions?account_title=My%20Store%20US&per_page=500¤cy=USD" \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN"

<?php
use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://app.sellerlegend.com/api/',
    'headers' => [
        'Authorization' => 'Bearer YOUR_ACCESS_TOKEN'
    ]
]);

$response = $client->request('GET', 'notifications/list', [
    'query' => [
        'account_title' => 'My Store US',
        'notification_type' => 'inventory_alerts'
    ]
]);

$notifications = json_decode($response->getBody(), true);

// Process notifications
foreach ($notifications['data'] as $notification) {
    echo "Type: {$notification['type']}\n";
    echo "Title: {$notification['title']}\n";
    echo "Message: {$notification['message']}\n";
    echo "Severity: {$notification['severity']}\n";
    echo "Created: {$notification['created_at']}\n";
    echo "Status: " . ($notification['read'] ? 'Read' : 'Unread') . "\n";
    echo "---\n";
}

const getNotifications = async () => {
    const params = new URLSearchParams({
        account_title: 'My Store US',
        notification_type: 'inventory_alerts'  // or "price_alerts", "restock_alerts", etc.
    });

    const response = await fetch(`https://app.sellerlegend.com/api/notifications/list?${params}`, {
        method: 'GET',
        headers: {
            'Authorization': 'Bearer YOUR_ACCESS_TOKEN',
            'Content-Type': 'application/json'
        }
    });

    const notifications = await response.json();

    // Process notifications
    notifications.data.forEach(notification => {
        console.log(`Type: ${notification.type}`);
        console.log(`Title: ${notification.title}`);
        console.log(`Message: ${notification.message}`);
        console.log(`Severity: ${notification.severity}`);
        console.log(`Created: ${notification.created_at}`);
        console.log(`Status: ${notification.read ? 'Read' : 'Unread'}`);
        console.log('---');
    });

    return notifications;
};

getNotifications();

curl -X GET "https://app.sellerlegend.com/api/notifications/list?account_title=My%20Store%20US¬ification_type=inventory_alerts" \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN"