Font Identifier API

Copyimport requests

response = requests.post(
    "https://precisioncounter.com/api/v1/identify-font",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    files={"image": open("sample.png", "rb")}
)

data = response.json()
for font in data["fonts"]:
    print(f"{font['name']} ({font['confidence']:.0%})")

Copyconst fs = require("fs");
const FormData = require("form-data");

const form = new FormData();
form.append("image", fs.createReadStream("sample.png"));

const response = await fetch(
  "https://precisioncounter.com/api/v1/identify-font",
  {
    method: "POST",
    headers: {
      "Authorization": "Bearer YOUR_API_KEY",
      ...form.getHeaders()
    },
    body: form
  }
);

const data = await response.json();
data.fonts.forEach(f => console.log(`${f.name} (${f.confidence})`));

Copyimport requests
import sys

API_KEY = "YOUR_API_KEY"
API_URL = "https://precisioncounter.com/api/v1/identify-font"

def identify_font(input_path, max_results=5):
    """Identify fonts from an image file."""
    with open(input_path, "rb") as img:
        response = requests.post(
            API_URL,
            headers={"Authorization": f"Bearer {API_KEY}"},
            files={"image": img},
            data={"max_results": max_results, "include_similar": "true"}
        )

    if response.status_code == 200:
        data = response.json()
        for font in data["fonts"]:
            print(f"{font['name']} - {font['confidence']:.0%} confidence")
            print(f"  Style: {font['style']}, Weight: {font['weight']}")
            print(f"  Category: {font['category']}")
            if font.get("similar"):
                print(f"  Similar: {', '.join(font['similar'])}")
        print(f"\nText detected: {data['text_detected']}")
        print(f"Credits remaining: {response.headers.get('X-Credits-Remaining')}")
    else:
        print(f"Error {response.status_code}: {response.json()['error']}")

identify_font("sample.png")

Copyconst fs = require("fs");
const FormData = require("form-data");
const fetch = require("node-fetch");

const API_KEY = "YOUR_API_KEY";
const API_URL = "https://precisioncounter.com/api/v1/identify-font";

async function identifyFont(inputPath, maxResults = 5) {
  const form = new FormData();
  form.append("image", fs.createReadStream(inputPath));
  form.append("max_results", String(maxResults));
  form.append("include_similar", "true");

  const response = await fetch(API_URL, {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${API_KEY}`,
      ...form.getHeaders()
    },
    body: form
  });

  if (response.ok) {
    const data = await response.json();
    data.fonts.forEach(font => {
      console.log(`${font.name} - ${(font.confidence * 100).toFixed(0)}%`);
      console.log(`  Style: ${font.style}, Weight: ${font.weight}`);
      console.log(`  Similar: ${font.similar.join(", ")}`);
    });
    console.log(`Credits: ${response.headers.get("x-credits-remaining")}`);
  } else {
    const error = await response.json();
    console.error(`Error ${response.status}: ${error.error}`);
  }
}

identifyFont("sample.png");

Copy<?php
$api_key = "YOUR_API_KEY";
$url = "https://precisioncounter.com/api/v1/identify-font";

$ch = curl_init();
curl_setopt_array($ch, [
    CURLOPT_URL => $url,
    CURLOPT_POST => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        "Authorization: Bearer $api_key"
    ],
    CURLOPT_POSTFIELDS => [
        "image" => new CURLFile("sample.png"),
        "max_results" => "5",
        "include_similar" => "true"
    ]
]);

$response = curl_exec($ch);
$httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

if ($httpCode === 200) {
    $data = json_decode($response, true);
    foreach ($data["fonts"] as $font) {
        echo $font["name"] . " - " . ($font["confidence"] * 100) . "% confidence\n";
        echo "  Style: " . $font["style"] . ", Weight: " . $font["weight"] . "\n";
        echo "  Similar: " . implode(", ", $font["similar"]) . "\n";
    }
} else {
    echo "Error $httpCode: $response\n";
}
?>

Copypackage main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "mime/multipart"
    "net/http"
    "os"
)

type FontResult struct {
    Name       string   `json:"name"`
    Confidence float64  `json:"confidence"`
    Style      string   `json:"style"`
    Weight     int      `json:"weight"`
    Category   string   `json:"category"`
    Similar    []string `json:"similar"`
}

type Response struct {
    Fonts          []FontResult `json:"fonts"`
    TextDetected   string       `json:"text_detected"`
    ProcessingTime int          `json:"processing_time_ms"`
}

func identifyFont(inputPath string) error {
    file, _ := os.Open(inputPath)
    defer file.Close()

    body := &bytes.Buffer{}
    writer := multipart.NewWriter(body)
    part, _ := writer.CreateFormFile("image", inputPath)
    io.Copy(part, file)
    writer.WriteField("max_results", "5")
    writer.Close()

    req, _ := http.NewRequest("POST",
        "https://precisioncounter.com/api/v1/identify-font", body)
    req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
    req.Header.Set("Content-Type", writer.FormDataContentType())

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

    if resp.StatusCode == 200 {
        var result Response
        json.NewDecoder(resp.Body).Decode(&result)
        for _, font := range result.Fonts {
            fmt.Printf("%s - %.0f%% confidence\n", font.Name, font.Confidence*100)
        }
    }
    return nil
}

func main() {
    identifyFont("sample.png")
}

Copyrequire "net/http"
require "uri"
require "json"

api_key = "YOUR_API_KEY"
uri = URI("https://precisioncounter.com/api/v1/identify-font")

form_data = [
  ["image", File.open("sample.png", "rb")],
  ["max_results", "5"],
  ["include_similar", "true"]
]

req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer #{api_key}"
req.set_form(form_data, "multipart/form-data")

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(req)
end

if res.code == "200"
  data = JSON.parse(res.body)
  data["fonts"].each do |font|
    puts "#{font['name']} - #{(font['confidence'] * 100).round}% confidence"
    puts "  Style: #{font['style']}, Weight: #{font['weight']}"
    puts "  Similar: #{font['similar'].join(', ')}"
  end
else
  puts "Error #{res.code}: #{res.body}"
end

Copyusing System.Text.Json;

using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");

using var form = new MultipartFormDataContent();
var imageContent = new ByteArrayContent(File.ReadAllBytes("sample.png"));
imageContent.Headers.ContentType = new("image/png");
form.Add(imageContent, "image", "sample.png");
form.Add(new StringContent("5"), "max_results");
form.Add(new StringContent("true"), "include_similar");

var response = await client.PostAsync(
    "https://precisioncounter.com/api/v1/identify-font", form);

if (response.IsSuccessStatusCode)
{
    var json = await response.Content.ReadAsStringAsync();
    var data = JsonSerializer.Deserialize<JsonElement>(json);
    foreach (var font in data.GetProperty("fonts").EnumerateArray())
    {
        Console.WriteLine($"{font.GetProperty("name")} - {font.GetProperty("confidence")}");
    }
}