Skip to main content

Other Languages

The Corellium API can be used with any modern programming language.

You can either generate your own API client or use HTTP requests directly with language-specifc HTTP libraries.

Option 1 - Generate Your Own API Client​

The Corellium REST API is documented using the OpenAPI Specification 3.0.3.

OpenAPI is used to define and document RESTful APIs. Since it's language-agnostic, you can use OpenAPI Generator or Swagger Codegen to generate an API client in your preferred language.

Where to Find the OpenAPI Specification​

On-Premises customers can find the specification at https://<your_hostname>/api/openapi.json, where <your_hostname> is either the hostname or IP address of your Corellium appliance.

Business customers can find the specification at https://<your_domain>.enterprise.corellium.com/api/openapi.json, where <your_domain> is taken from the URL you use to access the Corellium web interface.

Option 2 - Use HTTP Requests Directly​

You can also interact with the Corellium API using HTTP requests directly in your preferred programming language.

Below are some examples of how to interact with the the GET /v1/projects endpoint using popular programming languages.

Pre-Requisites​

In order to run the examples below, you will need to configure your environment with the following:

  1. Set environmental variables for your API token. To generate a new API token, please see the API Token documentation.

    export CORELLIUM_API_TOKEN='your_api_token'

  2. Set another environmental variable CORELLIUM_API_ENDPOINT to the appropriate endpoint for your account type.

    export CORELLIUM_API_ENDPOINT='https://<your_domain>.enterprise.corellium.com/api'

    • For On-Premise customers, the endpoint is https://<your_hostname>/api, where <your_hostname> is either the hostname or IP address of your Corellium appliance.

    • For Business Cloud customers, the endpoint is https://<your_domain>.enterprise.corellium.com/api, where <your_domain> is taken from the URL you use to access the Corellium web interface.

    • For Solo Cloud customers, the endpoint is https://app.corellium.com/api.

  3. Install the runtime dependencies for your chosen language.

    • For example, to run the Rust code, ensure the cargo binary and the reqwest and serde_json crates are installed.

C​

The following is a C example that uses the libcurl library to interact with the Corellium REST API.

To compile the code, you will need to link against the libcurl library. You can do this by passing -lcurl to the compiler. For example, if your code is in main.c, you can compile it with gcc -o main main.c -lcurl.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <curl/curl.h>

struct string {
    char *ptr;
    size_t len;
};

void init_string(struct string *s) {
    s->len = 0;
    s->ptr = malloc(s->len + 1);
    if (s->ptr == NULL) {
        fprintf(stderr, "malloc() failed\n");
        exit(EXIT_FAILURE);
    }
    s->ptr[0] = '\0';
}

size_t writefunc(void *ptr, size_t size, size_t nmemb, struct string *s) {
    size_t new_len = s->len + size * nmemb;
    s->ptr = realloc(s->ptr, new_len + 1);
    if (s->ptr == NULL) {
        fprintf(stderr, "realloc() failed\n");
        exit(EXIT_FAILURE);
    }
    memcpy(s->ptr + s->len, ptr, size * nmemb);
    s->ptr[new_len] = '\0';
    s->len = new_len;

    return size * nmemb;
}

int main(void) {
    CURL *curl;
    CURLcode res;
    struct string s;
    char *api_key = getenv("CORELLIUM_API_TOKEN");
    char *endpoint = getenv("CORELLIUM_API_ENDPOINT");
    char url[256];

    snprintf(url, sizeof(url), "%s/v1/projects", endpoint);

    init_string(&s);
    curl_global_init(CURL_GLOBAL_DEFAULT);
    curl = curl_easy_init();

    if (curl) {
        struct curl_slist *headers = NULL;
        char auth_header[256];

        snprintf(auth_header, sizeof(auth_header), "Authorization: Bearer %s", api_key);
        headers = curl_slist_append(headers, auth_header);
        headers = curl_slist_append(headers, "Content-Type: application/json");

        curl_easy_setopt(curl, CURLOPT_URL, url);
        curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, writefunc);
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &s);

        res = curl_easy_perform(curl);

        if (res != CURLE_OK) {
            fprintf(stderr, "curl_easy_perform() failed: %s\n", curl_easy_strerror(res));
        } else {
            printf("%s\n", s.ptr);
        }

        curl_easy_cleanup(curl);
        curl_slist_free_all(headers);
    }

    free(s.ptr);
    curl_global_cleanup();

    return 0;
}

C++​

The following is a C++ example that uses the libcurl library to interact with the Corellium REST API.

To compile the code, you will need to link against the libcurl library. You can do this by passing -lcurl to the compiler. For example, if your code is in main.cpp, you can compile it with g++ -o main main.cpp -lcurl.

#include <iostream>
#include <cstdlib>
#include <cstring>
#include <curl/curl.h>

struct string {
    char *ptr;
    size_t len;
};

void init_string(struct string *s) {
    s->len = 0;
    s->ptr = (char *)malloc(s->len + 1);
    if (s->ptr == NULL) {
        std::cerr << "malloc() failed" << std::endl;
        exit(EXIT_FAILURE);
    }
    s->ptr[0] = '\0';
}

size_t writefunc(void *ptr, size_t size, size_t nmemb, struct string *s) {
    size_t new_len = s->len + size * nmemb;
    s->ptr = (char *)realloc(s->ptr, new_len + 1);
    if (s->ptr == NULL) {
        std::cerr << "realloc() failed" << std::endl;
        exit(EXIT_FAILURE);
    }
    memcpy(s->ptr + s->len, ptr, size * nmemb);
    s->ptr[new_len] = '\0';
    s->len = new_len;

    return size * nmemb;
}

int main() {
    CURL *curl;
    CURLcode res;
    struct string s;
    char *api_key = getenv("CORELLIUM_API_TOKEN");
    char *endpoint = getenv("CORELLIUM_API_ENDPOINT");
    char url[256];

    snprintf(url, sizeof(url), "%s/v1/projects", endpoint);

    init_string(&s);
    curl_global_init(CURL_GLOBAL_DEFAULT);
    curl = curl_easy_init();

    if (curl) {
        struct curl_slist *headers = NULL;
        char auth_header[256];

        snprintf(auth_header, sizeof(auth_header), "Authorization: Bearer %s", api_key);
        headers = curl_slist_append(headers, auth_header);
        headers = curl_slist_append(headers, "Content-Type: application/json");

        curl_easy_setopt(curl, CURLOPT_URL, url);
        curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, writefunc);
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &s);

        res = curl_easy_perform(curl);

        if (res != CURLE_OK) {
            std::cerr << "curl_easy_perform() failed: " << curl_easy_strerror(res) << std::endl;
        } else {
            std::cout << s.ptr << std::endl;
        }

        curl_easy_cleanup(curl);
        curl_slist_free_all(headers);
    }

    free(s.ptr);
    curl_global_cleanup();

    return 0;
}

C#​

The following is a C# example that uses the System.Net.Http namespace to interact with the Corellium REST API.

using System;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        string apiKey = Environment.GetEnvironmentVariable("CORELLIUM_API_TOKEN") ?? string.Empty;
        string endpoint = Environment.GetEnvironmentVariable("CORELLIUM_API_ENDPOINT") ?? string.Empty;
        string url = $"{endpoint}/v1/projects";

        if (string.IsNullOrEmpty(apiKey) || string.IsNullOrEmpty(endpoint))
        {
            Console.WriteLine("Environment variables CORELLIUM_API_TOKEN and CORELLIUM_API_ENDPOINT must be set.");
            return;
        }

        using (HttpClient client = new HttpClient())
        {
            client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", apiKey);
            client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));

            HttpResponseMessage response = await client.GetAsync(url);
            response.EnsureSuccessStatusCode();

            string responseBody = await response.Content.ReadAsStringAsync();
            Console.WriteLine(responseBody);
        }
    }
}

Go​

The following is a Go example that uses the net/http package to interact with the Corellium REST API.

package main

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

func main() {
    apiKey := os.Getenv("CORELLIUM_API_TOKEN")
    endpoint := os.Getenv("CORELLIUM_API_ENDPOINT")
    url := fmt.Sprintf("%s/v1/projects", endpoint)

    req, err := http.NewRequest("GET", url, nil)
    if err != nil {
        panic(err)
    }

    req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", apiKey))
    req.Header.Set("Content-Type", "application/json")

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

    var result interface{}
    json.NewDecoder(resp.Body).Decode(&result)

    fmt.Printf("%#v\n", result)
}

Java​

The following is a Java example that uses the java.net.http.HttpClient class to interact with the Corellium REST API.

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Main {
    public static void main(String[] args) throws Exception {
        String apiKey = System.getenv("CORELLIUM_API_TOKEN");
        String endpoint = System.getenv("CORELLIUM_API_ENDPOINT");
        String url = endpoint + "/v1/projects";

        if (apiKey == null || endpoint == null) {
            System.out.println("Environment variables CORELLIUM_API_TOKEN and CORELLIUM_API_ENDPOINT must be set.");
            return;
        }

        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(url))
                .header("Authorization", "Bearer " + apiKey)
                .header("Content-Type", "application/json")
                .build();

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

        if (response.statusCode() == 200) {
            System.out.println(response.body());
        } else {
            System.out.println("Request failed with status code: " + response.statusCode());
        }
    }
}

Objective-C​

The following is an Objective-C example that uses the NSURLSession class to interact with the Corellium REST API.

To compile the code, you will need to link against the Foundation framework. For example, if your code is in main.m, you can compile it with clang -framework Foundation -o main main.m.

#import <Foundation/Foundation.h>

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        NSString *apiKey = [[[NSProcessInfo processInfo] environment] objectForKey:@"CORELLIUM_API_TOKEN"];
        NSString *endpoint = [[[NSProcessInfo processInfo] environment] objectForKey:@"CORELLIUM_API_ENDPOINT"];
        NSString *urlString = [NSString stringWithFormat:@"%@/v1/projects", endpoint];
        NSURL *url = [NSURL URLWithString:urlString];

        NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url];
        [request setValue:[NSString stringWithFormat:@"Bearer %@", apiKey] forHTTPHeaderField:@"Authorization"];
        [request setValue:@"application/json" forHTTPHeaderField:@"Content-Type"];
        [request setHTTPMethod:@"GET"];

        NSURLSession *session = [NSURLSession sharedSession];
        NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                                    completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
            if (error) {
                NSLog(@"Error: %@", error.localizedDescription);
            } else {
                NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *)response;
                if (httpResponse.statusCode == 200) {
                    NSError *jsonError;
                    NSDictionary *json = [NSJSONSerialization JSONObjectWithData:data options:0 error:&jsonError];
                    if (jsonError) {
                        NSLog(@"JSON Error: %@", jsonError.localizedDescription);
                    } else {
                        NSLog(@"%@", json);
                    }
                } else {
                    NSLog(@"Request failed with status code: %ld", (long)httpResponse.statusCode);
                }
            }
        }];

        [dataTask resume];
        [[NSRunLoop currentRunLoop] run];
    }
    return 0;
}

PHP​

The following is a PHP example that uses the curl library to interact with the Corellium REST API.

<?php
$api_key = getenv('CORELLIUM_API_TOKEN');
$endpoint = getenv('CORELLIUM_API_ENDPOINT');
$url = $endpoint . '/v1/projects';

$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer ' . $api_key,
    'Content-Type: application/json'
]);

$response = curl_exec($ch);

if (curl_errno($ch)) {
    echo 'Error:' . curl_error($ch);
} else {
    $http_code = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    if ($http_code == 200) {
        $result = json_decode($response, true);
        echo json_encode($result, JSON_PRETTY_PRINT);
    } else {
        echo "Request failed with status code: $http_code\n";
    }
}

curl_close($ch);
?>

Ruby​

The following is a Ruby example that uses the net/http and json, and uri libraries to interact with the Corellium REST API.

require 'net/http'
require 'json'
require 'uri'

api_key = ENV['CORELLIUM_API_TOKEN']
endpoint = ENV['CORELLIUM_API_ENDPOINT']
url = URI("#{endpoint}/v1/projects")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request['Authorization'] = "Bearer #{api_key}"
request['Content-Type'] = 'application/json'

response = http.request(request)
result = JSON.parse(response.body)

puts JSON.pretty_generate(result)

Rust​

The following is a Rust example that uses the reqwest and serde_json crates to interact with the Corellium REST API.

To satisfy dependencies, you will need to add reqwest, serde, and serde_json to your Cargo.toml file.

use reqwest::blocking::Client;
use std::env;
use serde_json::Value;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new();
    let api_key = env::var("CORELLIUM_API_TOKEN")?;
    let url = format!("{}/v1/projects", env::var("CORELLIUM_API_ENDPOINT")?);

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("Authorization", format!("Bearer {}", api_key).parse()?);

    let response = client.get(&url)
        .headers(headers)
        .send()?
        .json::<Value>()?;

    println!("{:#?}", response);
    Ok(())
}

Swift​

The following is a Swift example that uses the URLSession and JSONSerialization classes to interact with the Corellium REST API.

After creating a new Xcode project, either allow networking permissions or disable the sandbox in <your_project_name>.entitlements then to set the appropriate environmental variables in Product -> Scheme -> Edit Scheme.

For the project's main .swift file:

import SwiftUI

@main
struct swift_api_testApp: App {
    var body: some Scene {
        WindowGroup {
            ContentView()
        }
    }
}

For the ContentView.swift file:

import SwiftUI

struct ContentView: View {
    @State private var output: String = "Loading..."

    var body: some View {
        Text(output)
            .padding()
            .onAppear(perform: fetchProjects)
    }

    func fetchProjects() {
        guard let apiKey = ProcessInfo.processInfo.environment["CORELLIUM_API_TOKEN"],
              let endpoint = ProcessInfo.processInfo.environment["CORELLIUM_API_ENDPOINT"],
              let url = URL(string: "\(endpoint)/v1/projects") else {
            output = "Missing environment variables"
            return
        }

        var request = URLRequest(url: url)
        request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
        request.setValue("application/json", forHTTPHeaderField: "Content-Type")

        URLSession.shared.dataTask(with: request) { data, response, error in
            DispatchQueue.main.async {
                if let error = error {
                    self.output = "Error: \(error.localizedDescription)"
                } else if let data = data,
                          let json = try? JSONSerialization.jsonObject(with: data, options: []) {
                    self.output = "\(json)"
                } else {
                    self.output = "Failed to fetch projects"
                }
            }
        }.resume()
    }
}

struct ContentView_Previews: PreviewProvider {
    static var previews: some View {
        ContentView()
    }
}