Quickstart

export TOKEN_URL="your_token_url"
export CLIENT_ID="your_client_id"
export CLIENT_SECRET="your_client_secret"

$env:TOKEN_URL="your_token_url"
$env:CLIENT_ID="your_client_id"
$env:CLIENT_SECRET="your_client_secret"

export BASE64_KEY=$(printf '%s' "${CLIENT_ID}:${CLIENT_SECRET}" | base64)

$env:BASE64_KEY=[Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes("${env:CLIENT_ID}:${env:CLIENT_SECRET}"))

curl --request POST \
  --url "${TOKEN_URL}" \
  --header "Authorization: Basic ${BASE64_KEY}" \
  --header "Content-Type: application/x-www-form-urlencoded" \
  --header "Accept: application/json" \
  --data "grant_type=client_credentials"

$CLIENT_ID = "your_client_id"
$CLIENT_SECRET = "your_client_secret"
$TOKEN_URL = "your_token_url"

# Generate BASE64_KEY
$BASE64_KEY = [Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes("${CLIENT_ID}:${CLIENT_SECRET}"))

# Get access token
$response = Invoke-RestMethod -Uri $TOKEN_URL `
    -Method Post `
    -Headers @{
        "Authorization" = "Basic $BASE64_KEY"
        "Content-Type" = "application/x-www-form-urlencoded"
        "Accept" = "application/json"
    } `
    -Body "grant_type=client_credentials"

$accessToken = $response.access_token
Write-Host "Access token: $accessToken"

import base64
import requests

token_url = "your_token_url"
client_id = "your_client_id"
client_secret = "your_client_secret"

# Generate BASE64_KEY
credentials = f"{client_id}:{client_secret}"
base64_key = base64.b64encode(credentials.encode()).decode()

response = requests.post(
    token_url,
    headers={
        'Authorization': f'Basic {base64_key}',
        'Content-Type': 'application/x-www-form-urlencoded',
        'Accept': 'application/json'
    },
    data={'grant_type': 'client_credentials'}
)

token_data = response.json()
access_token = token_data['access_token']
print(f"Access token: {access_token}")

const axios = require('axios');

const tokenUrl = "your_token_url";
const clientId = "your_client_id";
const clientSecret = "your_client_secret";

// Generate BASE64_KEY
const base64Key = Buffer.from(`${clientId}:${clientSecret}`).toString('base64');

async function getAccessToken() {
  const response = await axios.post(
    tokenUrl,
    'grant_type=client_credentials',
    {
      headers: {
        'Authorization': `Basic ${base64Key}`,
        'Content-Type': 'application/x-www-form-urlencoded',
        'Accept': 'application/json'
      }
    }
  );
  
  return response.data.access_token;
}

(async () => {
  const token = await getAccessToken();
  console.log('Access token:', token);
})();

import java.net.http.*;
import java.net.URI;
import java.util.Base64;

public class IceyeAuth {
    public static void main(String[] args) throws Exception {
        String tokenUrl = "your_token_url";
        String clientId = "your_client_id";
        String clientSecret = "your_client_secret";
        
        // Generate BASE64_KEY
        String credentials = clientId + ":" + clientSecret;
        String base64Key = Base64.getEncoder().encodeToString(credentials.getBytes());
        
        // Build request
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(tokenUrl))
            .header("Authorization", "Basic " + base64Key)
            .header("Content-Type", "application/x-www-form-urlencoded")
            .header("Accept", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString("grant_type=client_credentials"))
            .build();
        
        // Send request
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        
        // Parse access_token from response
        String json = response.body();
        int start = json.indexOf("\"access_token\":\"") + 16;
        int end = json.indexOf("\"", start);
        String accessToken = json.substring(start, end);
        
        System.out.println("Access token: " + accessToken);
    }
}

export ACCESS_TOKEN="your_access_token_from_step_1"

curl --request GET \
  --url "https://platform.iceye.com/api/company/v1/contracts" \
  --header "Authorization: Bearer ${ACCESS_TOKEN}" \
  --header "Accept: application/json"

$ACCESS_TOKEN = "your_access_token_from_step_1"

$response = Invoke-RestMethod -Uri "https://platform.iceye.com/api/company/v1/contracts" `
    -Method Get `
    -Headers @{
        "Authorization" = "Bearer $ACCESS_TOKEN"
        "Accept" = "application/json"
    }

$contracts = $response.data
Write-Host "Found $($contracts.Count) contracts"
foreach ($contract in $contracts) {
    Write-Host "- $($contract.name) (ID: $($contract.id))"
}

response = requests.get(
    'https://platform.iceye.com/api/company/v1/contracts',
    headers={
        'Authorization': f'Bearer {access_token}',
        'Accept': 'application/json'
    }
)

contracts = response.json()
print(f"Found {len(contracts['data'])} contracts")
for contract in contracts['data']:
    print(f"- {contract['name']} (ID: {contract['id']})")

const response = await axios.get(
  'https://platform.iceye.com/api/company/v1/contracts',
  {
    headers: {
      'Authorization': `Bearer ${accessToken}`,
      'Accept': 'application/json'
    }
  }
);

const contracts = response.data;
console.log(`Found ${contracts.data.length} contracts`);
contracts.data.forEach(contract => {
  console.log(`- ${contract.name} (ID: ${contract.id})`);
});

HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://platform.iceye.com/api/company/v1/contracts"))
    .header("Authorization", "Bearer " + accessToken)
    .header("Accept", "application/json")
    .GET()
    .build();

HttpResponse<String> response = client.send(request,
    HttpResponse.BodyHandlers.ofString());

System.out.println(response.body());