Products

Product Endpoint

The Products API allows you to retrieve product information, including pricing, inventory levels, and metadata. You can search and filter products using various parameters.

GET/api/v1/product/

Get products by filter parameters

Name	Type	Required	Description
format	string	❌	Response format: 'json' (default) or 'xml' (BMEcat 2005 format)
product_number	string	❌	Filter by single or comma-separated AXRO product numbers (e.g., 'CANL055BK' or 'CANL055BK,CANL056WH')
fsku	string	❌	Filter by single or comma-separated foreign SKU values (fSKU)
oem	string	❌	Filter by single or comma-separated OEM numbers (e.g., '3016C002' or '3016C002,CF540A')
ean	string	❌	Filter by single or comma-separated EAN numbers (e.g., '4549292124699' or '4549292124699,4549292124706')
brand	string	❌	Filter by single or comma-separated brand names (e.g., 'HP,Canon,Epson')
category	string	❌	Filter by single or comma-separated category IDs (e.g., '50593,50638')
page	string	❌	Page number for pagination (default: 1)
limit	string	❌	Number of items per page (default: 100)

Example Request

cURL

curl -X GET https://api.axro.com/api/v1/product/ \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN"

JavaScript

// Using Fetch API
fetch('https://api.axro.com/api/v1/product/', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_ACCESS_TOKEN'
  }
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));

PHP

// Using cURL
$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, 'https://api.axro.com/api/v1/product/');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, array(
    'Authorization: Bearer YOUR_ACCESS_TOKEN'
));

$response = curl_exec($ch);
$error = curl_error($ch);

curl_close($ch);

if ($error) {
    echo "Error: " . $error;
} else {
    $data = json_decode($response, true);
    print_r($data);
}

Python

# Using requests library
import requests

url = 'https://api.axro.com/api/v1/product/'
headers = {'Authorization': 'Bearer YOUR_ACCESS_TOKEN'}

response = requests.get(url, headers=headers)

print(response.status_code)
print(response.json())

Go

package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
)

func main() {
    url := "https://api.axro.com/api/v1/product/"
    
    req, err := http.NewRequest("GET", url, nil)
    if err != nil {
        fmt.Println("Error creating request:", err)
        return
    }
    
    req.Header.Add("Authorization", "Bearer YOUR_ACCESS_TOKEN")
    
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        fmt.Println("Error sending request:", err)
        return
    }
    defer resp.Body.Close()
    
    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        fmt.Println("Error reading response:", err)
        return
    }
    
    fmt.Println("Response Status:", resp.Status)
    fmt.Println("Response Body:", string(body))
}

C#

// Using HttpClient (modern approach)
using System;
using System.Net.Http;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        using (HttpClient client = new HttpClient())
        {
            // Set authorization header
            client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_ACCESS_TOKEN");
    
            // Make the GET request
            HttpResponseMessage response = await client.GetAsync("https://api.axro.com/api/v1/product/");
                
            // Read the response
            string responseBody = await response.Content.ReadAsStringAsync();
                
            // Check if request was successful
            if (response.IsSuccessStatusCode)
            {
                Console.WriteLine("Response: " + responseBody);
            }
            else
            {
                Console.WriteLine("Error: " + response.StatusCode);
                Console.WriteLine("Response: " + responseBody);
            }
        }
    }
}

Example Response

{
  "products": [
    {
      "product_number": "CANL055BK",
      "ean": "4549292124699",
      "oem_number": "3016C002",
      "brand": "Canon",
      "stock": 42,
      "price": [
        {
          "from_quantity": 1,
          "to_quantity": 5,
          "price": 8599
        },
        {
          "from_quantity": 6,
          "to_quantity": 999999,
          "price": 8299
        }
      ],
      "title": {
        "en_GB": "Canon 055 Toner Cartridge - Black",
        "de_DE": "Canon 055 Tonerkartusche - Schwarz"
      },
      "category": {
        "id": 50593,
        "de": "Tonerkartuschen",
        "en": "Toner cartridges"
      },
      "modified_at": "2024-02-15T14:30:00Z"
    }
  ],
  "total_pages": 5
}

Hint

Depending on how you set the limit, you will most likely have to paginate.

Use the key total_pages as the maximum and create a recursive function that calls the API endpoint with the next page as the page parameter until the corresponding page is reached.

Check "Example Requests for pagination" below.

Example Request for pagination

cURL

#!/bin/bash

URL="https://api.axro.com/api/v1/product/"
TOKEN="YOUR_TOKEN"
CURRENT_PAGE=1
HAS_MORE_PAGES=true

while [ "$HAS_MORE_PAGES" = true ]
do
  echo "Fetching page $CURRENT_PAGE..."
  RESPONSE=$(curl -s -X GET "$URL?page=$CURRENT_PAGE" \
    -H "Authorization: Bearer $TOKEN" \
    -H "Content-Type: application/json")

  echo $RESPONSE | jq .

  # Extract total_pages
  TOTAL_PAGES=$(echo $RESPONSE | jq '.total_pages')

  if [ -z "$TOTAL_PAGES" ] || [ "$TOTAL_PAGES" = "null" ]; then
    echo "Could not determine total pages, stopping"
    HAS_MORE_PAGES=false
  elif [ $CURRENT_PAGE -ge $TOTAL_PAGES ]; then
    echo "Reached last page ($TOTAL_PAGES)"
    HAS_MORE_PAGES=false
  else
    CURRENT_PAGE=$((CURRENT_PAGE + 1))
  fi
done

JavaScript

async function fetchAllPages() {
  const url = 'https://api.axro.com/api/v1/product/';
  const headers = {
    'Authorization': 'Bearer YOUR_TOKEN',
    'Content-Type': 'application/json'
  };

  let currentPage = 1;
  let hasMorePages = true;

  while (hasMorePages) {
    try {
      const response = await fetch(`${url}?page=${currentPage}`, {
      method: 'GET',
      headers: headers
    });

      const data = await response.json();
      console.log(`Page ${currentPage} data:`, data);
      
      // Check if we need to continue
      if (currentPage >= data.total_pages) {
        hasMorePages = false;
      } else {
        currentPage++;
      }
    } catch (error) {
      console.error(`Error fetching page ${currentPage}:`, error);
      hasMorePages = false; // Stop on error
    }
  }
}
fetchAllPages();

PHP

$url = 'https://api.axro.com/api/v1/product/';
$token = 'YOUR_TOKEN';

$headers = [
    'Authorization: Bearer ' . $token,
    'Content-Type: application/json'
];

$currentPage = 1;
$hasMorePages = true;

while ($hasMorePages) {
    echo "Fetching page {$currentPage}...\n";
    
        // Initialize cURL session
        $ch = curl_init();
        
        // Set cURL options
        curl_setopt($ch, CURLOPT_URL, $url . '?page=' . $currentPage);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
        
        // Execute the request
        $response = curl_exec($ch);
        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
        
        if (curl_errno($ch)) {
            echo 'Error: ' . curl_error($ch) . "\n";
            $hasMorePages = false;
        } elseif ($httpCode != 200) {
            echo "Error: HTTP status code {$httpCode}\n";
            $hasMorePages = false;
        } else {
            // Convert JSON to associative array and print
            $data = json_decode($response, true);
            echo "Page {$currentPage} data:\n";
            print_r($data);
            
            // Check if we need to continue
            $totalPages = isset($data['total_pages']) ? $data['total_pages'] : 0;
            
            if ($currentPage >= $totalPages) {
                echo "Reached last page ({$totalPages})\n";
                $hasMorePages = false;
            } else {
                $currentPage++;
            }
        }
        
        // Close cURL session
        curl_close($ch);
    }

Python

# Using requests library
import requests

url = 'https://api.axro.com/api/v1/product/'
headers = {
    'Authorization': 'Bearer YOUR_TOKEN',
    'Content-Type': 'application/json'
}

current_page = 1
has_more_pages = True

while has_more_pages:
print(f"Fetching page {current_page}...")

response = requests.get(url, headers=headers, params={'page': current_page})

if response.status_code != 200:
    print(f"Error: HTTP status code {response.status_code}")
    break
    
data = response.json()
print(f"Page {current_page} data:")
print(data)

# Check if we need to continue
total_pages = data.get('total_pages', 0)

if current_page >= total_pages:
    print(f"Reached last page ({total_pages})")
    has_more_pages = False
else:
    current_page += 1

Go

package main

import (
    "encoding/json"
    "fmt"
    "io/ioutil"
    "net/http"
)

// Define a struct to hold the response structure
type ApiResponse struct {
Products   []interface{} `json:"products"`
TotalPages int           `json:"total_pages"`
}

func main() {
url := "https://api.axro.com/api/v1/product/"
token := "YOUR_TOKEN"

    client := &http.Client{}
    currentPage := 1
    hasMorePages := true

    for hasMorePages {
        fmt.Printf("Fetching page %d...\n", currentPage)

        // Create a new request
        req, err := http.NewRequest("GET", fmt.Sprintf("%s?page=%d", url, currentPage), nil)
        if err != nil {
            fmt.Printf("Error creating request: %v\n", err)
            break
        }

        // Add headers
        req.Header.Add("Authorization", "Bearer "+token)
        req.Header.Add("Content-Type", "application/json")

        // Send the request
        resp, err := client.Do(req)
        if err != nil {
            fmt.Printf("Error sending request: %v\n", err)
            break
        }

        // Check status code
        if resp.StatusCode != http.StatusOK {
            fmt.Printf("Server returned status code %d\n", resp.StatusCode)
            resp.Body.Close()
            break
        }

        // Read response body
        body, err := ioutil.ReadAll(resp.Body)
        resp.Body.Close()
        if err != nil {
            fmt.Printf("Error reading response: %v\n", err)
            break
        }

        // Parse and print JSON
        var apiResponse ApiResponse
        err = json.Unmarshal(body, &apiResponse)
        if err != nil {
            fmt.Printf("Error parsing JSON: %v\n", err)
            // Print the raw response anyway
            fmt.Println(string(body))
            break
        }

        // Pretty print the JSON
        prettyJSON, _ := json.MarshalIndent(apiResponse, "", "  ")
        fmt.Println(string(prettyJSON))

        // Check if we need to continue
        if currentPage >= apiResponse.TotalPages {
            fmt.Printf("Reached last page (%d)\n", apiResponse.TotalPages)
            hasMorePages = false
        } else {
            currentPage++
        }
    }
}

C#

// Using HttpClient (modern approach)
using System;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text.Json;
using System.Threading.Tasks;

class Program
{
// Define a class to deserialize the API response
    class ApiResponse
    {
        public object[] Products { get; set; }
        public int TotalPages { get; set; }
    }
    
    static async Task Main()
    {
        string url = "https://api.axro.com/api/v1/product/";
        string token = "YOUR_TOKEN";
        
        using (HttpClient client = new HttpClient())
        {
            // Set up headers
            client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);
            client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
            
            int currentPage = 1;
            bool hasMorePages = true;
            
            while (hasMorePages)
            {
                try
                {
                    Console.WriteLine($"Fetching page {currentPage}...");
                    
                    // Send the request
                    HttpResponseMessage response = await client.GetAsync($"{url}?page={currentPage}");
                    response.EnsureSuccessStatusCode();
                    
                    // Read and parse the response
                    string responseBody = await response.Content.ReadAsStringAsync();
                    
                    // Print the formatted response
                    Console.WriteLine($"Page {currentPage} data:");
                    var jsonDoc = JsonDocument.Parse(responseBody);
                    string formatted = JsonSerializer.Serialize(jsonDoc.RootElement, new JsonSerializerOptions { WriteIndented = true });
                    Console.WriteLine(formatted);
                    
                    // Deserialize to access total_pages
                    ApiResponse data = JsonSerializer.Deserialize(
                        responseBody,
                        new JsonSerializerOptions { PropertyNameCaseInsensitive = true }
                    );
                    
                    // Check if we need to continue
                    if (currentPage >= data.TotalPages)
                    {
                        Console.WriteLine($"Reached last page ({data.TotalPages})");
                        hasMorePages = false;
                    }
                    else
                    {
                        currentPage++;
                    }
                }
                catch (Exception e)
                {
                    Console.WriteLine($"Error: {e.Message}");
                    hasMorePages = false;
                }
            }
        }
    }
}

---

Product Stocks Endpoint

Bulk lookup for inventory/stock levels for many products at once.

• Request is a JSON array.
• Each array element must contain exactly one identifier: product_number, ean, oem, or fsku.
• You can mix identifier types in the same request.
• Max 5000 items per request.
• Response is returned in the same order as the request.
• Per-row errors are returned via the error field (other rows still succeed).

POST/api/v1/product/stocks/

Request Body

Array of objects, each with exactly one of:

• product_number (AXRO product number)
• ean (EAN)
• oem (OEM number)
• fsku (customer-specific foreign SKU)

Example Request

cURL

curl -X POST https://api.axro.com/api/v1/product/stocks/ \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
  -H "Content-Type: application/json" \
  -d '[
    {"product_number": "CANL055BK"},
    {"ean": "4549292124699"},
    {"oem": "3016C002"},
    {"fsku": "FSKU-999"}
  ]'

JavaScript

const url = 'https://api.axro.com/api/v1/product/stocks/';

const response = await fetch(url, {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer YOUR_ACCESS_TOKEN',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify([
    { product_number: 'CANL055BK' },
    { ean: '4549292124699' },
    { oem: '3016C002' },
    { fsku: 'FSKU-999' },
  ]),
});

console.log(response.status);
console.log(await response.json());

Python

import requests

url = 'https://api.axro.com/api/v1/product/stocks/'
headers = {
    'Authorization': 'Bearer YOUR_ACCESS_TOKEN',
    'Content-Type': 'application/json',
}

payload = [
    {"product_number": "CANL055BK"},
    {"ean": "4549292124699"},
    {"oem": "3016C002"},
    {"fsku": "FSKU-999"},
]

r = requests.post(url, headers=headers, json=payload)
print(r.status_code)
print(r.json())

Example Response

[
  {"product": "CANL055BK", "stock": 42, "error": null},
  {"product": "4549292124699", "stock": 10, "error": null},
  {"product": "3016C002", "stock": 7, "error": null},
  {"product": "FSKU-999", "stock": 0, "error": "fsku_not_found"}
]

Error codes

• not_found: product not found / not visible for the current customer
• fsku_not_found: no fSKU mapping exists for the current customer

---

Categories Endpoint

GET/api/v1/product/categories/

Get all available product categories

Example Request

cURL

curl -X GET https://api.axro.com/api/v1/product/categories/ \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN"

JavaScript

// Using Fetch API
fetch('https://api.axro.com/api/v1/product/categories/', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_ACCESS_TOKEN'
  }
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));

PHP

// Using cURL
$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, 'https://api.axro.com/api/v1/product/categories/');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, array(
    'Authorization: Bearer YOUR_ACCESS_TOKEN'
));

$response = curl_exec($ch);
$error = curl_error($ch);

curl_close($ch);

if ($error) {
    echo "Error: " . $error;
} else {
    $data = json_decode($response, true);
    print_r($data);
}

Python

# Using requests library
import requests

url = 'https://api.axro.com/api/v1/product/categories/'
headers = {'Authorization': 'Bearer YOUR_ACCESS_TOKEN'}

response = requests.get(url, headers=headers)

print(response.status_code)
print(response.json())

Go

package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
)

func main() {
    url := "https://api.axro.com/api/v1/product/categories/"
    
    req, err := http.NewRequest("GET", url, nil)
    if err != nil {
        fmt.Println("Error creating request:", err)
        return
    }
    
    req.Header.Add("Authorization", "Bearer YOUR_ACCESS_TOKEN")
    
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        fmt.Println("Error sending request:", err)
        return
    }
    defer resp.Body.Close()
    
    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        fmt.Println("Error reading response:", err)
        return
    }
    
    fmt.Println("Response Status:", resp.Status)
    fmt.Println("Response Body:", string(body))
}

C#

// Using HttpClient (modern approach)
using System;
using System.Net.Http;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        using (HttpClient client = new HttpClient())
        {
            // Set authorization header
            client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_ACCESS_TOKEN");
            
            // Make the GET request
            HttpResponseMessage response = await client.GetAsync("https://api.axro.com/api/v1/product/categories/");
                    
            // Read the response
            string responseBody = await response.Content.ReadAsStringAsync();
                    
            // Check if request was successful
            if (response.IsSuccessStatusCode)
            {
                Console.WriteLine("Response: " + responseBody);
            }
            else
            {
                Console.WriteLine("Error: " + response.StatusCode);
                Console.WriteLine("Response: " + responseBody);
            }
        }
    }
}

Example Response

[
  {
    "id": 50593,
    "de": "Tonerkartuschen",
    "en": "Toner cartridges"
  },
  {
    "id": 50638,
    "de": "Tintenpatronen",
    "en": "Ink cartridges"
  },
  {
    "id": 51522,
    "de": "Drucker",
    "en": "Printers"
  }
]

---

Brands Endpoint

GET/api/v1/product/brands/

Get all available product brands

Example Request

cURL

curl -X GET https://api.axro.com/api/v1/product/brands/ \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN"

JavaScript

// Using Fetch API
fetch('https://api.axro.com/api/v1/product/brands/', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_ACCESS_TOKEN'
  }
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));

PHP

// Using cURL
$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, 'https://api.axro.com/api/v1/product/brands/');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, array(
    'Authorization: Bearer YOUR_ACCESS_TOKEN'
));

$response = curl_exec($ch);
$error = curl_error($ch);

curl_close($ch);

if ($error) {
    echo "Error: " . $error;
} else {
    $data = json_decode($response, true);
    print_r($data);
}

Python

# Using requests library
import requests

url = 'https://api.axro.com/api/v1/product/brands/'
headers = {'Authorization': 'Bearer YOUR_ACCESS_TOKEN'}

response = requests.get(url, headers=headers)

print(response.status_code)
print(response.json())

Go

package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
)

func main() {
    url := "https://api.axro.com/api/v1/product/brands/"
    
    req, err := http.NewRequest("GET", url, nil)
    if err != nil {
        fmt.Println("Error creating request:", err)
        return
    }
    
    req.Header.Add("Authorization", "Bearer YOUR_ACCESS_TOKEN")
    
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        fmt.Println("Error sending request:", err)
        return
    }
    defer resp.Body.Close()
    
    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        fmt.Println("Error reading response:", err)
        return
    }
    
    fmt.Println("Response Status:", resp.Status)
    fmt.Println("Response Body:", string(body))
}

C#

// Using HttpClient (modern approach)
using System;
using System.Net.Http;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        using (HttpClient client = new HttpClient())
        {
            // Set authorization header
            client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_ACCESS_TOKEN");
            
            // Make the GET request
            HttpResponseMessage response = await client.GetAsync("https://api.axro.com/api/v1/product/brands/");
                    
            // Read the response
            string responseBody = await response.Content.ReadAsStringAsync();
                    
            // Check if request was successful
            if (response.IsSuccessStatusCode)
            {
                Console.WriteLine("Response: " + responseBody);
            }
            else
            {
                Console.WriteLine("Error: " + response.StatusCode);
                Console.WriteLine("Response: " + responseBody);
            }
        }
    }
}

Example Response

{
  "brands": [
    "Canon",
    "HP",
    "Epson",
    "Brother",
    "Samsung"
  ]
}

---

fSKU Mappings Endpoint

Return the customer-specific foreign SKU mappings (fSKU → AXRO product_number).

Sync frequency

New and updated fSKU mappings are synchronized approximately every hour.

GET/api/v1/product/fsku/

Name	Type	Required	Description
page	number	❌	Page number for pagination (default: 1)
limit	number	❌	Number of items per page (default: 10000, max: 50000)
q	string	❌	Optional substring filter applied to fsku or product_number

Example Request

cURL

curl -X GET "https://api.axro.com/api/v1/product/fsku/?page=1&limit=100" \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN"

JavaScript

fetch('https://api.axro.com/api/v1/product/fsku/?page=1&limit=100', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_ACCESS_TOKEN'
  }
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));

PHP

// Using cURL
$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, 'https://api.axro.com/api/v1/product/fsku/?page=1&limit=100');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, array(
    'Authorization: Bearer YOUR_ACCESS_TOKEN'
));

$response = curl_exec($ch);
$error = curl_error($ch);

curl_close($ch);

if ($error) {
    echo "Error: " . $error;
} else {
    $data = json_decode($response, true);
    print_r($data);
}

Python

# Using requests library
import requests

url = 'https://api.axro.com/api/v1/product/fsku/'
headers = {'Authorization': 'Bearer YOUR_ACCESS_TOKEN'}
params = {'page': 1, 'limit': 100}

response = requests.get(url, headers=headers, params=params)

print(response.status_code)
print(response.json())

Go

package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
)

func main() {
    url := "https://api.axro.com/api/v1/product/fsku/?page=1&limit=100"

    req, err := http.NewRequest("GET", url, nil)
    if err != nil {
        fmt.Println("Error creating request:", err)
        return
    }

    req.Header.Add("Authorization", "Bearer YOUR_ACCESS_TOKEN")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        fmt.Println("Error sending request:", err)
        return
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        fmt.Println("Error reading response:", err)
        return
    }

    fmt.Println("Response Status:", resp.Status)
    fmt.Println("Response Body:", string(body))
}

C#

// Using HttpClient (modern approach)
using System;
using System.Net.Http;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        using (HttpClient client = new HttpClient())
        {
            client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_ACCESS_TOKEN");

            HttpResponseMessage response = await client.GetAsync(
                "https://api.axro.com/api/v1/product/fsku/?page=1&limit=100"
            );

            string responseBody = await response.Content.ReadAsStringAsync();

            if (response.IsSuccessStatusCode)
            {
                Console.WriteLine("Response: " + responseBody);
            }
            else
            {
                Console.WriteLine("Error: " + response.StatusCode);
                Console.WriteLine("Response: " + responseBody);
            }
        }
    }
}

Example Response

{
  "mappings": [
    { "fsku": "FSKU-999", "product_number": "AXRO123" },
    { "fsku": "FSKU-1000", "product_number": "AXRO124" }
  ],
  "page": 1,
  "limit": 100,
  "total": 2,
  "total_pages": 1
}