Making API Calls

curl --fail-with-body --silent --show-error \
  --request POST \
  --cert "$CLIENT_CERTIFICATE" \
  --key "$CLIENT_PRIVATE_KEY" \
  --header "Authorization: Bearer $ACCESS_TOKEN" \
  --header "Accept: application/json" \
  --header "Content-Type: application/json" \
  --data @request.json \
  "$API_BASE_URL$ENDPOINT_PATH"

openssl pkcs12 -export \
  -in pty-mtls-client-cert.cer \
  -inkey pty-mtls-client-cert.key.pem \
  -out client.p12 \
  -name paymentology

import java.io.InputStream;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.file.Files;
import java.nio.file.Path;
import java.security.KeyStore;
import java.time.Duration;
import javax.net.ssl.KeyManagerFactory;
import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManagerFactory;

public class PaymentologyApiClient {
    private static SSLContext createMtlsContext(Path keyStorePath, char[] password)
            throws Exception {
        KeyStore keyStore = KeyStore.getInstance("PKCS12");

        try (InputStream input = Files.newInputStream(keyStorePath)) {
            keyStore.load(input, password);
        }

        KeyManagerFactory keyManagers =
                KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
        keyManagers.init(keyStore, password);

        TrustManagerFactory trustManagers =
                TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
        trustManagers.init((KeyStore) null); // Use the default trusted certificate authorities.

        SSLContext context = SSLContext.getInstance("TLS");
        context.init(
                keyManagers.getKeyManagers(),
                trustManagers.getTrustManagers(),
                null
        );

        return context;
    }

    public static void main(String[] args) throws Exception {
        String apiBaseUrl = System.getenv("API_BASE_URL");
        String endpointPath = System.getenv("ENDPOINT_PATH");
        String accessToken = System.getenv("ACCESS_TOKEN");
        String keyStorePassword = System.getenv("CLIENT_KEYSTORE_PASSWORD");

        SSLContext sslContext = createMtlsContext(
                Path.of("client.p12"),
                keyStorePassword.toCharArray()
        );

        HttpClient client = HttpClient.newBuilder()
                .sslContext(sslContext)
                .connectTimeout(Duration.ofSeconds(10))
                .build();

        String requestBody = Files.readString(Path.of("request.json"));

        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(
                        apiBaseUrl.replaceAll("/$", "") + "/" +
                        endpointPath.replaceFirst("^/", "")
                ))
                .header("Authorization", "Bearer " + accessToken)
                .header("Accept", "application/json")
                .header("Content-Type", "application/json")
                .POST(HttpRequest.BodyPublishers.ofString(requestBody))
                .build();

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

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

npm install axios

const fs = require("node:fs");
const https = require("node:https");
const axios = require("axios");

const apiBaseUrl = process.env.API_BASE_URL.replace(/\/$/, "");
const endpointPath = process.env.ENDPOINT_PATH.replace(/^\//, "");
const accessToken = process.env.ACCESS_TOKEN;

const mtlsAgent = new https.Agent({
  cert: fs.readFileSync(process.env.CLIENT_CERTIFICATE),
  key: fs.readFileSync(process.env.CLIENT_PRIVATE_KEY),
});

async function callApi() {
  const response = await axios.post(
    `${apiBaseUrl}/${endpointPath}`,
    JSON.parse(fs.readFileSync("request.json", "utf8")),
    {
      httpsAgent: mtlsAgent,
      timeout: 10_000,
      headers: {
        Authorization: `Bearer ${accessToken}`,
        Accept: "application/json",
        "Content-Type": "application/json",
      },
    }
  );

  console.log(response.status);
  console.log(response.data);
}

callApi().catch((error) => {
  const status = error.response?.status;
  const body = error.response?.data;

  console.error(status ?? error.message);
  if (body) console.error(body);

  process.exitCode = 1;
});

openssl pkcs12 -export \
  -in pty-mtls-client-cert.cer \
  -inkey pty-mtls-client-cert.key.pem \
  -out client.pfx \
  -name paymentology

using System.Net.Http.Headers;
using System.Security.Cryptography.X509Certificates;
using System.Text;

var apiBaseUrl = Environment.GetEnvironmentVariable("API_BASE_URL")!
    .TrimEnd('/');
var endpointPath = Environment.GetEnvironmentVariable("ENDPOINT_PATH")!
    .TrimStart('/');
var accessToken = Environment.GetEnvironmentVariable("ACCESS_TOKEN")!;
var certificatePath = Environment.GetEnvironmentVariable("CLIENT_CERTIFICATE_PFX")!;
var certificatePassword =
    Environment.GetEnvironmentVariable("CLIENT_CERTIFICATE_PASSWORD")!;

var certificate = new X509Certificate2(
    certificatePath,
    certificatePassword,
    X509KeyStorageFlags.EphemeralKeySet
);

using var handler = new HttpClientHandler();
handler.ClientCertificates.Add(certificate);

using var client = new HttpClient(handler)
{
    Timeout = TimeSpan.FromSeconds(10)
};

var requestBody = await File.ReadAllTextAsync("request.json");

using var request = new HttpRequestMessage(
    HttpMethod.Post,
    $"{apiBaseUrl}/{endpointPath}"
);

request.Headers.Authorization =
    new AuthenticationHeaderValue("Bearer", accessToken);
request.Headers.Accept.Add(
    new MediaTypeWithQualityHeaderValue("application/json")
);
request.Content = new StringContent(
    requestBody,
    Encoding.UTF8,
    "application/json"
);

using var response = await client.SendAsync(request);
var responseBody = await response.Content.ReadAsStringAsync();

Console.WriteLine((int)response.StatusCode);
Console.WriteLine(responseBody);