metadata detection API

Copyimport requests

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

data = response.json()
for metadata in data["metadata"]:
    print(f"{metadata['name']} ({metadata['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/extract-image-metadata",
  {
    method: "POST",
    headers: {
      "Authorization": "Bearer YOUR_API_KEY",
      ...form.getHeaders()
    },
    body: form
  }
);

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

Copyimport requests
import sys

API_KEY = "YOUR_API_KEY"
API_URL = "https://precisioncounter.com/api/v1/extract-image-metadata"

def detect_metadata(input_path, max_fields=5):
    """Extract Metadata 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_fields": max_fields, "include_exif": "true"}
        )

    if response.status_code == 200:
        data = response.json()
        for metadata in data["metadata"]:
            print(f"{metadata['name']} - {metadata['confidence']:.0%} confidence")
            print(f"  Category: {metadata['category']}")
            if metadata.get("box"):
              print(f"  Box: {metadata['box']}")
        print(f"Credits remaining: {response.headers.get('X-Credits-Remaining')}")
    else:
        print(f"Error {response.status_code}: {response.json()['error']}")

detect_metadata("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/extract-image-metadata";

async function detectmetadata(inputPath, maxResults = 5) {
  const form = new FormData();
  form.append("image", fs.createReadStream(inputPath));
  form.append("max_fields", String(maxResults));
  form.append("include_exif", "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.metadata.forEach(metadata => {
      console.log(`${metadata.name} - ${(metadata.confidence * 100).toFixed(0)}%`);
      console.log(`  Category: ${metadata.category}`);
      if (metadata.box) console.log(`  Box: ${JSON.stringify(metadata.box)}`);
    });
    console.log(`Credits: ${response.headers.get("x-credits-remaining")}`);
  } else {
    const error = await response.json();
    console.error(`Error ${response.status}: ${error.error}`);
  }
}

detectmetadata("sample.png");

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

$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_fields" => "5",
        "include_exif" => "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["metadata"] as $metadata) {
        echo $metadata["name"] . " - " . ($metadata["confidence"] * 100) . "% confidence\n";
        echo "  Category: " . $metadata["category"] . "\n";
        if (isset($metadata["box"])) {
          echo "  Box: " . json_encode($metadata["box"]) . "\n";
        }
    }
} else {
    echo "Error $httpCode: $response\n";
}
?>

Copypackage main

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

type metadataResult struct {
    Name       string   `json:"name"`
    Confidence float64  `json:"confidence"`
    Category   string   `json:"category"`
  Box        map[string]int `json:"box"`
}

type Response struct {
  metadata        []metadataResult `json:"metadata"`
  ImageWidth     int            `json:"image_width"`
  ImageHeight    int            `json:"image_height"`
  ProcessingTime int            `json:"processing_time_ms"`
}

func detectmetadata(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_fields", "5")
    writer.Close()

    req, _ := http.NewRequest("POST",
        "https://precisioncounter.com/api/v1/extract-image-metadata", 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 _, metadata := range result.metadata {
            fmt.Printf("%s - %.0f%% confidence\n", metadata.Name, metadata.Confidence*100)
        }
    }
    return nil
}

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

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

api_key = "YOUR_API_KEY"
uri = URI("https://precisioncounter.com/api/v1/extract-image-metadata")

form_data = [
  ["image", File.open("sample.png", "rb")],
  ["max_fields", "5"],
  ["include_exif", "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["metadata"].each do |metadata|
    puts "#{metadata['name']} - #{(metadata['confidence'] * 100).round}% confidence"
    puts "  Category: #{metadata['category']}"
    puts "  Box: #{metadata['box']}" if metadata['box']
  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_fields");
form.Add(new StringContent("true"), "include_exif");

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

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