Get eSIM Packages

async function getPackages(regionCode) {
  const response = await fetch(
    `https://api.vellosim.com/api/esim/packages?regionCode=${regionCode}&type=BASE`,
    {
      method: 'GET',
      headers: {
        'X-API-Key': `API_KEY}`,
        'Content-Type': 'application/json'
      }
    }
  );
  
  const packages = await response.json();  // Direct array response
  return packages;
}

// Helper function to convert bytes to GB
function bytesToGB(bytes) {
  return (bytes / 1073741824).toFixed(2);
}

// Usage
const packages = await getPackages('US');
console.log(`Found ${packages.length} packages for United States`);
packages.forEach(pkg => {
  console.log(`${pkg.name}: ${bytesToGB(pkg.volume)}GB for ${pkg.duration} days`);
});

import requests

def get_packages(region_code, package_type='BASE'):
    """Get available packages for a region"""
    headers = {
        'X-API-Key': f' {API_KEY}',
        'Content-Type': 'application/json'
    }
    
    params = {
        'regionCode': region_code,
        'type': package_type
    }
    
    response = requests.get(
        'https://api.vellosim.com/api/esim/packages',
        headers=headers,
        params=params
    )
    
    packages = response.json()  # Direct array response
    return packages

def bytes_to_gb(bytes_value):
    """Convert bytes to GB"""
    return round(bytes_value / 1073741824, 2)

# Usage
packages = get_packages('US')
print(f"Found {len(packages)} packages for United States")
for pkg in packages:
    data_gb = bytes_to_gb(pkg['volume'])
    print(f"{pkg['name']}: {data_gb}GB for {pkg['duration']} days")

<?php
function getPackages($regionCode, $type = 'BASE') {
    $apiKey = 'YOUR_API_KEY';
    
    $url = 'https://api.vellosim.com/api/esim/packages?' . http_build_query([
        'regionCode' => $regionCode,
        'type' => $type
    ]);
    
    $ch = curl_init($url);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_HTTPHEADER, [
        'X-API-Key: ' . $apiKey,
        'Content-Type: application/json'
    ]);
    
    $response = curl_exec($ch);
    $packages = json_decode($response, true);  // Direct array response
    curl_close($ch);
    
    return $packages;
}

function bytesToGB($bytes) {
    return round($bytes / 1073741824, 2);
}

// Usage
$packages = getPackages('US');
echo "Found " . count($packages) . " packages for United States\n";
foreach ($packages as $pkg) {
    $dataGB = bytesToGB($pkg['volume']);
    echo "{$pkg['name']}: {$dataGB}GB for {$pkg['duration']} days\n";
}
?>

package main

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

type Operator struct {
    OperatorName string `json:"operatorName"`
    NetworkType  string `json:"networkType"`
}

type LocationNetwork struct {
    LocationName string     `json:"locationName"`
    LocationLogo string     `json:"locationLogo"`
    LocationCode string     `json:"locationCode"`
    OperatorList []Operator `json:"operatorList"`
}

type Package struct {
    PackageCode         string            `json:"packageCode"`
    Name                string            `json:"name"`
    Price               int               `json:"price"`
    CurrencyCode        string            `json:"currencyCode"`
    Duration            int               `json:"duration"`
    Volume              int64             `json:"volume"`
    Description         string            `json:"description"`
    UnusedValidTime     int               `json:"unusedValidTime"`
    DurationUnit        string            `json:"durationUnit"`
    Location            string            `json:"location"`
    LocationCode        string            `json:"locationCode"`
    Speed               string            `json:"speed"`
    LocationNetworkList []LocationNetwork `json:"locationNetworkList"`
}

func bytesToGB(bytes int64) float64 {
    return float64(bytes) / 1073741824
}

func getPackages(apiKey, regionCode, packageType string) ([]Package, error) {
    url := fmt.Sprintf("https://api.vellosim.com/api/esim/packages?regionCode=%s&type=%s", 
        regionCode, packageType)
    
    client := &http.Client{}
    req, _ := http.NewRequest("GET", url, nil)
    req.Header.Set("X-API-Key", apiKey)
    req.Header.Set("Content-Type", "application/json")
    
    resp, err := client.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()
    
    body, _ := io.ReadAll(resp.Body)
    
    var packages []Package  // Direct array response
    json.Unmarshal(body, &packages)
    
    return packages, nil
}

func main() {
    packages, _ := getPackages("YOUR_API_KEY", "US", "BASE")
    fmt.Printf("Found %d packages for United States\n", len(packages))
    
    for _, pkg := range packages {
        dataGB := bytesToGB(pkg.Volume)
        fmt.Printf("%s: %.2fGB for %d days\n", pkg.Name, dataGB, pkg.Duration)
    }
}