curl --request GET \
  --url 'https://api.typecast.ai/v2/voices?model=ssfm-v30&gender=female&age=young_adult' \
  --header 'X-API-KEY: <api-key>'

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

var client = new HttpClient();
client.DefaultRequestHeaders.Add("X-API-KEY", "<api-key>");

var response = await client.GetAsync("https://api.typecast.ai/v2/voices?model=ssfm-v30&gender=female&age=young_adult");

if (response.IsSuccessStatusCode)
{
    var content = await response.Content.ReadAsStringAsync();
    Console.WriteLine(content);
}

import okhttp3.OkHttpClient
import okhttp3.Request

val client = OkHttpClient()

val request = Request.Builder()
    .url("https://api.typecast.ai/v2/voices?model=ssfm-v30&gender=female&age=young_adult")
    .addHeader("X-API-KEY", "<api-key>")
    .get()
    .build()

client.newCall(request).execute().use { response ->
    if (response.isSuccessful) {
        println(response.body?.string())
    }
}

#include <curl/curl.h>
#include <string>
#include <iostream>

size_t WriteCallback(void* contents, size_t size, size_t nmemb, void* userp) {
    ((std::string*)userp)->append((char*)contents, size * nmemb);
    return size * nmemb;
}

int main() {
    CURL* curl = curl_easy_init();
    if(curl) {
        std::string readBuffer;
        struct curl_slist* headers = NULL;

        headers = curl_slist_append(headers, "X-API-KEY: <api-key>");

        curl_easy_setopt(curl, CURLOPT_URL, "https://api.typecast.ai/v2/voices?model=ssfm-v30&gender=female&age=young_adult");
        curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &readBuffer);

        CURLcode res = curl_easy_perform(curl);
        if(res == CURLE_OK) {
            std::cout << readBuffer << std::endl;
        }

        curl_slist_free_all(headers);
        curl_easy_cleanup(curl);
    }
    return 0;
}

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

typedef struct {
    char* data;
    size_t size;
} MemoryStruct;

size_t WriteMemoryCallback(void* contents, size_t size, size_t nmemb, void* userp) {
    size_t realsize = size * nmemb;
    MemoryStruct* mem = (MemoryStruct*)userp;

    char* ptr = realloc(mem->data, mem->size + realsize + 1);
    if(!ptr) return 0;

    mem->data = ptr;
    memcpy(&(mem->data[mem->size]), contents, realsize);
    mem->size += realsize;
    mem->data[mem->size] = 0;

    return realsize;
}

int main(void) {
    CURL* curl;
    CURLcode res;
    MemoryStruct chunk = {NULL, 0};

    curl_global_init(CURL_GLOBAL_ALL);
    curl = curl_easy_init();

    if(curl) {
        struct curl_slist* headers = NULL;
        headers = curl_slist_append(headers, "X-API-KEY: <api-key>");

        curl_easy_setopt(curl, CURLOPT_URL, "https://api.typecast.ai/v2/voices?model=ssfm-v30&gender=female&age=young_adult");
        curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteMemoryCallback);
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void*)&chunk);

        res = curl_easy_perform(curl);

        if(res == CURLE_OK) {
            printf("%s\n", chunk.data);
        }

        curl_slist_free_all(headers);
        curl_easy_cleanup(curl);
        free(chunk.data);
    }

    curl_global_cleanup();
    return 0;
}

import Foundation

let url = URL(string: "https://api.typecast.ai/v2/voices?model=ssfm-v30&gender=female&age=young_adult")!
var request = URLRequest(url: url)
request.httpMethod = "GET"
request.setValue("<api-key>", forHTTPHeaderField: "X-API-KEY")

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let data = data, let jsonString = String(data: data, encoding: .utf8) {
        print(jsonString)
    }
}
task.resume()

use reqwest;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = reqwest::Client::new();

    let response = client
        .get("https://api.typecast.ai/v2/voices?model=ssfm-v30&gender=female&age=young_adult")
        .header("X-API-KEY", "<api-key>")
        .send()
        .await?;

    if response.status().is_success() {
        let body = response.text().await?;
        println!("{}", body);
    }

    Ok(())
}

import requests

url = "https://api.typecast.ai/v2/voices"

headers = {"X-API-KEY": "<api-key>"}

response = requests.get(url, headers=headers)

print(response.text)

const options = {method: 'GET', headers: {'X-API-KEY': '<api-key>'}};

fetch('https://api.typecast.ai/v2/voices', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.typecast.ai/v2/voices",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "X-API-KEY: <api-key>"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

package main

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

func main() {

	url := "https://api.typecast.ai/v2/voices"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("X-API-KEY", "<api-key>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}

HttpResponse<String> response = Unirest.get("https://api.typecast.ai/v2/voices")
  .header("X-API-KEY", "<api-key>")
  .asString();

require 'uri'
require 'net/http'

url = URI("https://api.typecast.ai/v2/voices")

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

request = Net::HTTP::Get.new(url)
request["X-API-KEY"] = '<api-key>'

response = http.request(request)
puts response.read_body

[
  {
    "voice_id": "tc_60e5426de8b95f1d3000d7b5",
    "voice_name": "Olivia",
    "models": [
      {
        "version": "ssfm-v30",
        "emotions": [
          "normal",
          "happy",
          "sad",
          "angry",
          "whisper",
          "toneup",
          "tonedown"
        ]
      },
      {
        "version": "ssfm-v21",
        "emotions": [
          "normal",
          "happy",
          "sad",
          "angry"
        ]
      }
    ],
    "gender": "female",
    "age": "young_adult",
    "use_cases": [
      "Audiobook",
      "E-learning",
      "Ads"
    ],
    "voice_type": "original"
  }
]

{
  "detail": "Invalid API key"
}

{
  "detail": "Invalid request format"
}