Products API

curl "{{host}}/api/v1/products?country_id=1&category=Gaming&page=1&limit=25" \
  -H "Authorization: Bearer <token>"

package main

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

type Denomination struct {
    MinValue *float64 `json:"min_value"`
    MaxValue *float64 `json:"max_value"`
    Discount *float64 `json:"discount"`
}

type Product struct {
    ID                     int             `json:"id"`
    Name                   string          `json:"name"`
    Category               string          `json:"category"`
    SubCategory            *string         `json:"sub_category"`
    CountryCode            string          `json:"country_code"`
    CurrencyCode           string          `json:"currency_code"`
    ImageURL               *string         `json:"image_url"`
    DeliveryMode           *string         `json:"delivery_mode"`
    DeliveryTime           *string         `json:"delivery_time"`
    Validity               *string         `json:"validity"`
    AvailableDenominations []Denomination  `json:"available_denominations"`
}

func main() {
    req, _ := http.NewRequest("GET", "{{host}}/api/v1/products?country_id=1&limit=25", nil)
    req.Header.Set("Authorization", "Bearer <token>")

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    fmt.Println("Total:", resp.Header.Get("X-Total-Count"))

    var products []Product
    json.NewDecoder(resp.Body).Decode(&products)

    for _, p := range products {
        fmt.Printf("%s (%s) — %s\n", p.Name, p.CurrencyCode, p.Category)
    }
}

{
  "error": {
    "name": "BadRequestError",
    "code": "BAD_REQUEST",
    "message": "Invalid query parameters"
  }
}

{
  "error": {
    "name": "UnauthorizedError",
    "code": "UNAUTHORIZED",
    "message": "Authorization header required"
  }
}

{
  "error": {
    "name": "ForbiddenError",
    "code": "FORBIDDEN",
    "message": "IP address not authorized"
  }
}

{
  "error": {
    "name": "BadRequestError",
    "code": "INVALID_FEATURE",
    "message": "The requested feature is not enabled for this client"
  }
}

{
  "error": {
    "name": "InternalServerError",
    "code": "INTERNAL_SERVER_ERROR",
    "message": "Failed to retrieve products"
  }
}

curl "{{host}}/api/v1/products/123" \
  -H "Authorization: Bearer <token>"

req, _ := http.NewRequest("GET", "{{host}}/api/v1/products/123", nil)
req.Header.Set("Authorization", "Bearer <token>")

resp, err := http.DefaultClient.Do(req)
if err != nil {
    panic(err)
}
defer resp.Body.Close()

var product Product
json.NewDecoder(resp.Body).Decode(&product)

fmt.Printf("%s — %s %s\n", product.Name, product.CurrencyCode, product.DeliveryTime)
for _, d := range product.AvailableDenominations {
    fmt.Printf("  $%.2f–$%.2f (%.1f%% off)\n", *d.MinValue, *d.MaxValue, *d.Discount)
}

{
  "error": {
    "name": "BadRequestError",
    "code": "BAD_REQUEST",
    "message": "Invalid product ID"
  }
}

{
  "error": {
    "name": "NotFoundError",
    "code": "NOT_FOUND",
    "message": "Product not found"
  }
}

{
  "error": {
    "name": "UnauthorizedError",
    "code": "UNAUTHORIZED",
    "message": "Authorization header required"
  }
}

{
  "error": {
    "name": "ForbiddenError",
    "code": "FORBIDDEN",
    "message": "IP address not authorized"
  }
}