Example API call function

<?php
	// NOTE: This function requires cURL to be available to PHP.

	function lyyti_apiCall($call_string, $http_method = 'GET', $payload = null)
	{
		// Generate the signature based on the API keys
		$public_key = 'apitesti';
		$private_key = 'asdasdasd123';
		$timestamp = time();
		$signature = hash_hmac(
			'sha256',
			base64_encode($public_key.','.$timestamp.','.$call_string),
			$private_key
		);

		// Set the required HTTP headers
		$http_headers = array(
			'Accept: application/json; charset=utf-8',
			'Authorization: LYYTI-API-V2 public_key='.$public_key.', timestamp='.$timestamp.', signature='.$signature
		);

		// Initialize the cURL connection
		$curl = curl_init('https://api.lyyti.com/v2/'.$call_string);
		curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);

		// Handle HTTP method and payload
		if ($http_method != 'GET' && isset($payload))
		{
			if ($http_method == 'PATCH')
			{
				$http_headers[] = 'Content-Type: application/merge-patch+json';
			}
			else
			{
				$http_headers[] = 'Content-Type: application/json; charset=utf-8';
			}
			if ($http_method == 'POST')
			{
				curl_setopt($curl, CURLOPT_POST, true);
			}
			else
			{
				curl_setopt($curl, CURLOPT_CUSTOMREQUEST, $http_method);
			}
			curl_setopt($curl, CURLOPT_POSTFIELDS, json_encode($payload));
		}

		// Set the HTTP headers and execute the call
		curl_setopt($curl, CURLOPT_HTTPHEADER, $http_headers);
		$result_json = curl_exec($curl);

		// Check for errors
		if ($curl_errno = curl_errno($curl))
		{
			return array('curl_error' => array('errno' => $curl_errno, 'message' => curl_strerror($curl_errno)));
		}
		curl_close($curl);

		// Turn the resulting JSON into a PHP associative array and return it
		$result_array = json_decode($result_json, $assoc = true);
		return $result_array;
	}
?>

// Replace this with whatever you need to do with the results
function resultsHandler(input) {
	// If you use the ?as_array=1 parameter in the API call, the resulting
	// object will have an array named "results" as a property
	input.results.forEach(function(oneResult) {
		console.log(oneResult);
		console.log("\n");
	});
}

function lyyti_apiCall(call_string, callbackFunction) {
  // Store these somewhere safe and smart
	var public_key = 'apitesti';
	var private_key = 'asdasdasd123';

	var CryptoJS = require('crypto-js');    	// npm install crypto-js
	var Base64 = require('js-base64').Base64;   // npm install js-base64
	var HTTPS = require('https');

	var timestamp = Math.floor(new Date()/1000);
	var signature = CryptoJS.HmacSHA256(
		Base64.encode(public_key+','+timestamp+','+call_string),
		private_key
	).toString(CryptoJS.enc.Hex);

	var options = {
		hostname: 'api.lyyti.com',
		path: '/v2/'+call_string,
		method: 'GET',
		headers: {
			'Accept': 'application/json; charset=utf-8',
			'Authorization': 'LYYTI-API-V2 public_key='+public_key+', timestamp='+timestamp+', signature='+signature
		}
	};

	var request = HTTPS.get(options, function (response) {
		var buffer = '';

		response.on('data', function (chunk) {
			buffer += chunk;
		});

		response.on('end', function (err) {
			// This is an example, it's probably better to use promises, async/await, or something similar here
			callbackFunction(JSON.parse(buffer));
		});
	});
}

// Use the as_array=1 parameter to get the results as an array rather than object
lyyti_apiCall('events?as_array=1', resultsHandler);

# .NET version using PowerShell (save as a .ps1 file)
# Credits to: https://github.com/kabtoffe

$script:LyytiPublicKey = "apitesti"
$script:LyytiPrivateKey = "asdasdasd123"
$script:LyytiAPIBaseUrl = "https://api.lyyti.com/v2/"

function Get-UnixTimeStamp{
    param([DateTime]$DateTime)

    $DateTime = $DateTime.ToUniversalTime()
    Get-Date -Date $DateTime -UFormat %s -Millisecond 0
}

function Get-StringFromBytes{
    param([byte[]]$Bytes)

    $sbinary = ""
    for ($i = 0; $i -lt $Bytes.Length; $i++){
        $sbinary += $Bytes[$i].ToString("X2")
    }
    $sbinary
}

function Get-LyytiSignatureHash{

    param(
        [DateTime]$Timestamp,
        [string]$UnixTimeStamp,
        [string]$Callstring
    )

    if ($UnixTimeStamp -eq $null){
        $UnixTimeStamp = Get-UnixTimeStamp -DateTime $Timestamp
    }

    $message = "$LyytiPublicKey,$UnixTimeStamp,$Callstring"
    $secret = $LyytiPrivateKey

    Write-Verbose "Message: $message"

    $hmacsha = New-Object System.Security.Cryptography.HMACSHA256
    $hmacsha.key = [Text.Encoding]::UTF8.GetBytes($secret)
    $MessageBytes = [Text.Encoding]::UTF8.GetBytes($message)
    $MessageBase64 = [Convert]::ToBase64String($MessageBytes)
    $MessageBase64Bytes = [Text.Encoding]::UTF8.GetBytes($MessageBase64)
    $SignatureHash = $hmacsha.ComputeHash($MessageBase64Bytes)
    $Signature = Get-StringFromBytes -Bytes $SignatureHash
    $Signature.ToLower()
}

function Get-LyytiAuthHeader{
    param($CallString)
    $headers = New-Object "System.Collections.Generic.Dictionary[[String],[String]]"
    $UnixTimeStamp = Get-UnixTimeStamp ([DateTime]::Now)
    $SignatureHash = Get-LyytiSignatureHash -UnixTimeStamp $UnixTimeStamp -Callstring $CallString
    $headers.Add("Accept", "application/json; charset=utf-8")
    $AuthHeader = "LYYTI-API-V2 public_key=$LyytiPublicKey, timestamp=$UnixTimeStamp, signature=$SignatureHash"
    Write-Verbose $AuthHeader
    $headers.Add("Authorization", $AuthHeader)
    $headers
}

function Invoke-LyytiApiCall{
    param($CallString, $Body)

    $header = Get-LyytiAuthHeader -CallString $CallString
    
    if ($Body -ne $null){
        Invoke-RestMethod -Method POST -Uri "$LyytiAPIBaseUrl$CallString" -Headers $header -Body $Body
    }
    else{
        Invoke-RestMethod -Method GET -Uri "$LyytiAPIBaseUrl$CallString" -Headers $header
    }
}