Authentication

import fs from 'fs';
import axios from 'axios';

const cert = fs.readFileSync('client.cert.pem', 'utf-8');
const encodedCert = encodeURIComponent(cert);

async function getToken(): Promise<string> {
  const { data } = await axios.post(
    'https://sandbox.mx.ntxpay.com/api/auth/token',
    {
      clientId: process.env.NTXPAY_CLIENT_ID,
      clientSecret: process.env.NTXPAY_CLIENT_SECRET,
    },
    {
      headers: {
        'X-SSL-Client-Cert': encodedCert,
        'Content-Type': 'application/json',
      },
    },
  );
  return data.access_token;
}

import os
import urllib.parse
import requests

with open("client.cert.pem", "r") as f:
    cert = f.read()
encoded_cert = urllib.parse.quote(cert)

def get_token() -> str:
    resp = requests.post(
        "https://sandbox.mx.ntxpay.com/api/auth/token",
        json={
            "clientId": os.environ["NTXPAY_CLIENT_ID"],
            "clientSecret": os.environ["NTXPAY_CLIENT_SECRET"],
        },
        headers={
            "X-SSL-Client-Cert": encoded_cert,
            "Content-Type": "application/json",
        },
        timeout=10,
    )
    resp.raise_for_status()
    return resp.json()["access_token"]

import java.net.URI;
import java.net.URLEncoder;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;

public class NtxPayAuth {
    public static String getToken() throws Exception {
        String cert = Files.readString(Path.of("client.cert.pem"));
        String encodedCert = URLEncoder.encode(cert, StandardCharsets.UTF_8);

        String body = """
            {
              "clientId": "%s",
              "clientSecret": "%s"
            }
            """.formatted(
                System.getenv("NTXPAY_CLIENT_ID"),
                System.getenv("NTXPAY_CLIENT_SECRET")
            );

        HttpRequest req = HttpRequest.newBuilder()
            .uri(URI.create("https://sandbox.mx.ntxpay.com/api/auth/token"))
            .header("X-SSL-Client-Cert", encodedCert)
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(body))
            .build();

        HttpResponse<String> resp = HttpClient.newHttpClient()
            .send(req, HttpResponse.BodyHandlers.ofString());

        // Parse access_token with the JSON library of your choice (Jackson, Gson, etc.)
        return resp.body();
    }
}

package main

import (
    "bytes"
    "encoding/json"
    "io"
    "net/http"
    "net/url"
    "os"
)

type tokenResponse struct {
    AccessToken string `json:"access_token"`
}

func getToken() (string, error) {
    certBytes, err := os.ReadFile("client.cert.pem")
    if err != nil {
        return "", err
    }
    encodedCert := url.QueryEscape(string(certBytes))

    payload, _ := json.Marshal(map[string]string{
        "clientId":     os.Getenv("NTXPAY_CLIENT_ID"),
        "clientSecret": os.Getenv("NTXPAY_CLIENT_SECRET"),
    })

    req, err := http.NewRequest(
        "POST",
        "https://sandbox.mx.ntxpay.com/api/auth/token",
        bytes.NewReader(payload),
    )
    if err != nil {
        return "", err
    }
    req.Header.Set("X-SSL-Client-Cert", encodedCert)
    req.Header.Set("Content-Type", "application/json")

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        return "", err
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    var tr tokenResponse
    if err := json.Unmarshal(body, &tr); err != nil {
        return "", err
    }
    return tr.AccessToken, nil
}