Their font in every render.

curl https://engine.typomat.app/api/v1/fonts \
  -H "Authorization: Bearer $TYPOMAT_KEY" \
  -H "Content-Type: application/json" \
  -o brightside.ttf \
  -d '{
    "name": "Brightside",
    "parameters": {
      "weight": 185,
      "width": 0.66,
      "contrast": 0.1,
      "xHeight": 590,
      "curve": 0.85,
      "aperture": 0.05
    }
  }'

import { writeFile } from "node:fs/promises";

const response = await fetch("https://engine.typomat.app/api/v1/fonts", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.TYPOMAT_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    name: "Brightside",
    parameters: {
      weight: 185,
      width: 0.66,
      contrast: 0.1,
      xHeight: 590,
      curve: 0.85,
      aperture: 0.05
    }
  }),
});

if (!response.ok) throw new Error((await response.json()).error.message);

await writeFile("brightside.ttf", Buffer.from(await response.arrayBuffer()));

import os
import requests

response = requests.post(
    "https://engine.typomat.app/api/v1/fonts",
    headers={"Authorization": f"Bearer {os.environ['TYPOMAT_KEY']}"},
    json={
        "name": "Brightside",
        "parameters": {
            "weight": 185,
            "width": 0.66,
            "contrast": 0.1,
            "xHeight": 590,
            "curve": 0.85,
            "aperture": 0.05
        }
    },
)

if not response.ok:
    raise RuntimeError(response.json()["error"]["message"])

with open("brightside.ttf", "wb") as file:
    file.write(response.content)

<?php

$context = stream_context_create(["http" => [
    "method" => "POST",
    "header" => "Authorization: Bearer " . getenv("TYPOMAT_KEY") . "\r\nContent-Type: application/json\r\n",
    "content" => json_encode(["name" => "Brightside", "parameters" => ["weight" => 185, "width" => 0.66, "contrast" => 0.1, "xHeight" => 590, "curve" => 0.85, "aperture" => 0.05]]),
    "ignore_errors" => true,
]]);

$body = file_get_contents("https://engine.typomat.app/api/v1/fonts", false, $context);

if (!str_contains($http_response_header[0], " 200 ")) {
    throw new RuntimeException(json_decode($body, true)["error"]["message"]);
}

file_put_contents("brightside.ttf", $body);

require "json"
require "net/http"

uri = URI("https://engine.typomat.app/api/v1/fonts")
response = Net::HTTP.post(
  uri,
  { name: "Brightside", parameters: { weight: 185, width: 0.66, contrast: 0.1, xHeight: 590, curve: 0.85, aperture: 0.05 } }.to_json,
  "Authorization" => "Bearer #{ENV.fetch("TYPOMAT_KEY")}",
  "Content-Type" => "application/json",
)

raise JSON.parse(response.body)["error"]["message"] unless response.is_a?(Net::HTTPSuccess)

File.binwrite("brightside.ttf", response.body)

package main

import (
	"io"
	"net/http"
	"os"
	"strings"
)

func main() {
	body := `{ "name": "Brightside", "parameters": { "weight": 185, "width": 0.66, "contrast": 0.1, "xHeight": 590, "curve": 0.85, "aperture": 0.05 } }`
	request, err := http.NewRequest("POST", "https://engine.typomat.app/api/v1/fonts", strings.NewReader(body))
	if err != nil {
		panic(err)
	}
	request.Header.Set("Authorization", "Bearer "+os.Getenv("TYPOMAT_KEY"))
	request.Header.Set("Content-Type", "application/json")

	response, err := http.DefaultClient.Do(request)
	if err != nil {
		panic(err)
	}
	defer response.Body.Close()

	data, err := io.ReadAll(response.Body)
	if err != nil {
		panic(err)
	}

	if response.StatusCode != http.StatusOK {
		panic(string(data))
	}

	if err := os.WriteFile("brightside.ttf", data, 0o644); err != nil {
		panic(err)
	}
}

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;

public class Main {
    public static void main(String[] args) throws Exception {
        String body = """
            { "name": "Brightside", "parameters": { "weight": 185, "width": 0.66, "contrast": 0.1, "xHeight": 590, "curve": 0.85, "aperture": 0.05 } }
            """;

        HttpRequest request = HttpRequest.newBuilder(URI.create("https://engine.typomat.app/api/v1/fonts"))
            .header("Authorization", "Bearer " + System.getenv("TYPOMAT_KEY"))
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(body))
            .build();

        HttpClient client = HttpClient.newBuilder().version(HttpClient.Version.HTTP_1_1).build();
        HttpResponse<byte[]> response = client.send(request, HttpResponse.BodyHandlers.ofByteArray());

        if (response.statusCode() != 200) throw new RuntimeException(new String(response.body()));

        Files.write(Path.of("brightside.ttf"), response.body());
    }
}

using System.Net.Http.Headers;
using System.Net.Http.Json;

using var client = new HttpClient();
client.DefaultRequestHeaders.Authorization =
    new AuthenticationHeaderValue("Bearer", Environment.GetEnvironmentVariable("TYPOMAT_KEY"));

var response = await client.PostAsJsonAsync("https://engine.typomat.app/api/v1/fonts", new { name = "Brightside", parameters = new { weight = 185, width = 0.66, contrast = 0.1, xHeight = 590, curve = 0.85, aperture = 0.05 } });

if (!response.IsSuccessStatusCode) throw new Exception(await response.Content.ReadAsStringAsync());

await File.WriteAllBytesAsync("brightside.ttf", await response.Content.ReadAsByteArrayAsync());

import Foundation

var request = URLRequest(url: URL(string: "https://engine.typomat.app/api/v1/fonts")!)
request.httpMethod = "POST"
request.setValue("Bearer \(ProcessInfo.processInfo.environment["TYPOMAT_KEY"]!)", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = Data(#"{ "name": "Brightside", "parameters": { "weight": 185, "width": 0.66, "contrast": 0.1, "xHeight": 590, "curve": 0.85, "aperture": 0.05 } }"#.utf8)

let (data, response) = try await URLSession.shared.data(for: request)

guard (response as? HTTPURLResponse)?.statusCode == 200 else {
    fatalError(String(decoding: data, as: UTF8.self))
}

try data.write(to: URL(fileURLWithPath: "brightside.ttf"))