Tabscanner API v2

#!/usr/bin/env bash
# Full flow: upload a receipt, poll until the result is ready, print establishment and total.
# Needs curl and jq. Usage: TABSCANNER_API_KEY=your-key ./scan.sh receipt.jpg
set -euo pipefail
API_URL="${TABSCANNER_API_URL:-https://api3.tabscanner.com}"
IMAGE="${1:-receipt.jpg}"
AUTH="Authorization: Bearer ${TABSCANNER_API_KEY:?set TABSCANNER_API_KEY}"

# 1. Upload. 202 means accepted; anything else is an error described by the JSON body.
#    The Idempotency-Key makes it safe to resend this exact request after a network error.
upload=$(curl -sS -w '\n%{http_code}' "$API_URL/v2/receipts" \
  -H "$AUTH" -H "Idempotency-Key: $(uuidgen)" \
  -F "file=@$IMAGE" -F "region=us")
status=$(tail -n1 <<<"$upload"); body=$(sed '$d' <<<"$upload")
if [ "$status" != 202 ]; then
  echo "Upload failed: $status $(jq -r '.code + ": " + (.detail // .title)' <<<"$body")" >&2; exit 1
fi
token=$(jq -r .token <<<"$body")

# 2. Poll until done or failed, waiting as long as Retry-After says between calls.
deadline=$((SECONDS + 120))
while :; do
  headers=$(mktemp)
  body=$(curl -sS -D "$headers" -w '\n%{http_code}' "$API_URL/v2/receipts/$token" -H "$AUTH")
  status=$(tail -n1 <<<"$body"); body=$(sed '$d' <<<"$body")
  wait=$(awk -F': ' 'tolower($1)=="retry-after" {print $2+0}' "$headers"); rm -f "$headers"
  if [ "$status" != 200 ]; then
    echo "Result failed: $status $(jq -r '.code + ": " + (.detail // .title)' <<<"$body")" >&2; exit 1
  fi
  case $(jq -r .status <<<"$body") in
    done) break ;;
    failed) echo "Processing failed: $(jq -r .error.detail <<<"$body")" >&2; exit 1 ;;
  esac
  [ "$SECONDS" -lt "$deadline" ] || { echo "Timed out waiting for the result" >&2; exit 1; }
  sleep "${wait:-2}"
done

# 3. Use the data.
jq -r '"Establishment: \(.result.establishment)", "Total: \(.result.total) \(.result.currency)"' <<<"$body"

// Full flow: upload a receipt, poll until the result is ready, print establishment and total.
// Node 20 or newer, no packages.  Usage: node scan.js receipt.jpg
import { randomUUID } from 'node:crypto';
import { openAsBlob } from 'node:fs';
import path from 'node:path';

const API_URL = process.env.TABSCANNER_API_URL ?? 'https://api3.tabscanner.com';
const AUTH = { Authorization: `Bearer ${process.env.TABSCANNER_API_KEY}` };
const TIMEOUT_MS = 120_000;
const imagePath = process.argv[2] ?? 'receipt.jpg';

const sleep = (seconds) => new Promise((resolve) => setTimeout(resolve, seconds * 1000));

// Errors are application/problem+json: { status, code, title, detail, requestId, ... }
async function fail(what, response) {
  const problem = await response.json();
  console.error(`${what} failed: ${response.status} ${problem.code}: ${problem.detail ?? problem.title}`);
  process.exit(1);
}

// 1. Upload. 202 means accepted. The Idempotency-Key makes a resend after a network error safe.
const form = new FormData();
const mimeType = imagePath.toLowerCase().endsWith('.png') ? 'image/png' : 'image/jpeg';
form.append('file', await openAsBlob(imagePath, { type: mimeType }), path.basename(imagePath));
form.append('region', 'us'); // country of the receipt, improves accuracy

const upload = await fetch(`${API_URL}/v2/receipts`, {
  method: 'POST',
  headers: { ...AUTH, 'Idempotency-Key': randomUUID() },
  body: form,
});
if (upload.status !== 202) await fail('Upload', upload);
const { token } = await upload.json();

// 2. Poll until done or failed, waiting as long as Retry-After says between calls.
const deadline = Date.now() + TIMEOUT_MS;
let receipt;
for (;;) {
  const response = await fetch(`${API_URL}/v2/receipts/${token}`, { headers: AUTH });
  if (response.status !== 200) await fail('Result', response);
  receipt = await response.json();
  if (receipt.status === 'done') break;
  if (receipt.status === 'failed') {
    console.error(`Processing failed: ${receipt.error.detail}`);
    process.exit(1);
  }
  if (Date.now() > deadline) {
    console.error('Timed out waiting for the result');
    process.exit(1);
  }
  await sleep(Number(response.headers.get('retry-after') ?? 2));
}

// 3. Use the data.
console.log(`Establishment: ${receipt.result.establishment}`);
console.log(`Total: ${receipt.result.total} ${receipt.result.currency}`);

"""Full flow: upload a receipt, poll until the result is ready, print establishment and total.

Python 3.9 or newer, needs `pip install requests`.  Usage: python scan.py receipt.jpg
"""
import os
import sys
import time
import uuid

import requests

API_URL = os.environ.get("TABSCANNER_API_URL", "https://api3.tabscanner.com")
TIMEOUT_SECONDS = 120
image_path = sys.argv[1] if len(sys.argv) > 1 else "receipt.jpg"

session = requests.Session()
session.headers["Authorization"] = f"Bearer {os.environ['TABSCANNER_API_KEY']}"


def fail(what, response):
    # Errors are application/problem+json: {status, code, title, detail, requestId, ...}
    problem = response.json()
    sys.exit(f"{what} failed: {response.status_code} {problem['code']}: {problem.get('detail', problem['title'])}")


# 1. Upload. 202 means accepted. The Idempotency-Key makes a resend after a network error safe.
mime_type = "image/png" if image_path.lower().endswith(".png") else "image/jpeg"
with open(image_path, "rb") as image:
    upload = session.post(
        f"{API_URL}/v2/receipts",
        headers={"Idempotency-Key": str(uuid.uuid4())},
        files={"file": (os.path.basename(image_path), image, mime_type)},
        data={"region": "us"},  # country of the receipt, improves accuracy
        timeout=60,
    )
if upload.status_code != 202:
    fail("Upload", upload)
token = upload.json()["token"]

# 2. Poll until done or failed, waiting as long as Retry-After says between calls.
deadline = time.monotonic() + TIMEOUT_SECONDS
while True:
    response = session.get(f"{API_URL}/v2/receipts/{token}", timeout=30)
    if response.status_code != 200:
        fail("Result", response)
    receipt = response.json()
    if receipt["status"] == "done":
        break
    if receipt["status"] == "failed":
        sys.exit(f"Processing failed: {receipt['error']['detail']}")
    if time.monotonic() > deadline:
        sys.exit("Timed out waiting for the result")
    time.sleep(int(response.headers.get("Retry-After", "2")))

# 3. Use the data.
result = receipt["result"]
print(f"Establishment: {result['establishment']}")
print(f"Total: {result['total']} {result['currency']}")

<?php
// Full flow: upload a receipt, poll until the result is ready, print establishment and total.
// PHP 8 with the curl extension.  Usage: php scan.php receipt.jpg

$apiUrl = getenv('TABSCANNER_API_URL') ?: 'https://api3.tabscanner.com';
$auth = 'Authorization: Bearer ' . getenv('TABSCANNER_API_KEY');
$imagePath = $argv[1] ?? 'receipt.jpg';

// Returns [HTTP status, decoded JSON body, Retry-After seconds].
function call(string $url, array $headers, ?array $form = null): array
{
    $retryAfter = 2;
    $ch = curl_init($url);
    curl_setopt_array($ch, [
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_HTTPHEADER => $headers,
        CURLOPT_TIMEOUT => 60,
        CURLOPT_HEADERFUNCTION => function ($ch, $line) use (&$retryAfter) {
            if (stripos($line, 'retry-after:') === 0) {
                $retryAfter = (int) trim(substr($line, 12));
            }
            return strlen($line);
        },
    ]);
    if ($form !== null) {
        curl_setopt($ch, CURLOPT_POSTFIELDS, $form);
    }
    $body = curl_exec($ch);
    if ($body === false) {
        fwrite(STDERR, 'Request failed: ' . curl_error($ch) . "\n");
        exit(1);
    }
    $status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);
    return [$status, json_decode($body, true), $retryAfter];
}

// Errors are application/problem+json: {status, code, title, detail, requestId, ...}
function fail(string $what, int $status, array $problem): never
{
    fwrite(STDERR, "$what failed: $status {$problem['code']}: " . ($problem['detail'] ?? $problem['title']) . "\n");
    exit(1);
}

// 1. Upload. 202 means accepted. The Idempotency-Key makes a resend after a network error safe.
$mimeType = str_ends_with(strtolower($imagePath), '.png') ? 'image/png' : 'image/jpeg';
[$status, $upload] = call("$apiUrl/v2/receipts", [$auth, 'Idempotency-Key: ' . bin2hex(random_bytes(16))], [
    'file' => new CURLFile($imagePath, $mimeType, basename($imagePath)),
    'region' => 'us', // country of the receipt, improves accuracy
]);
if ($status !== 202) {
    fail('Upload', $status, $upload);
}

// 2. Poll until done or failed, waiting as long as Retry-After says between calls.
$deadline = time() + 120;
while (true) {
    [$status, $receipt, $retryAfter] = call("$apiUrl/v2/receipts/{$upload['token']}", [$auth]);
    if ($status !== 200) {
        fail('Result', $status, $receipt);
    }
    if ($receipt['status'] === 'done') {
        break;
    }
    if ($receipt['status'] === 'failed') {
        fwrite(STDERR, "Processing failed: {$receipt['error']['detail']}\n");
        exit(1);
    }
    if (time() > $deadline) {
        fwrite(STDERR, "Timed out waiting for the result\n");
        exit(1);
    }
    sleep($retryAfter);
}

// 3. Use the data.
$result = $receipt['result'];
echo "Establishment: {$result['establishment']}\n";
echo "Total: {$result['total']} {$result['currency']}\n";

# Full flow: upload a receipt, poll until the result is ready, print establishment and total.
# Ruby 3.0 or newer, standard library only.  Usage: ruby scan.rb receipt.jpg
require 'json'
require 'net/http'
require 'securerandom'

API_URL = ENV.fetch('TABSCANNER_API_URL', 'https://api3.tabscanner.com')
AUTH = "Bearer #{ENV.fetch('TABSCANNER_API_KEY')}"
image_path = ARGV[0] || 'receipt.jpg'

def send_request(request)
  uri = request.uri
  request['Authorization'] = AUTH
  Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https', read_timeout: 60) { |http| http.request(request) }
end

# Errors are application/problem+json: {status, code, title, detail, requestId, ...}
def fail!(what, response)
  problem = JSON.parse(response.body)
  abort "#{what} failed: #{response.code} #{problem['code']}: #{problem['detail'] || problem['title']}"
end

# 1. Upload. 202 means accepted. The Idempotency-Key makes a resend after a network error safe.
mime_type = image_path.downcase.end_with?('.png') ? 'image/png' : 'image/jpeg'
upload = Net::HTTP::Post.new(URI("#{API_URL}/v2/receipts"))
upload['Idempotency-Key'] = SecureRandom.uuid
uploaded = File.open(image_path, 'rb') do |image|
  upload.set_form([
    ['file', image, { filename: File.basename(image_path), content_type: mime_type }],
    ['region', 'us'] # country of the receipt, improves accuracy
  ], 'multipart/form-data')
  send_request(upload)
end
fail!('Upload', uploaded) unless uploaded.code == '202'
token = JSON.parse(uploaded.body)['token']

# 2. Poll until done or failed, waiting as long as Retry-After says between calls.
deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + 120
receipt = nil
loop do
  response = send_request(Net::HTTP::Get.new(URI("#{API_URL}/v2/receipts/#{token}")))
  fail!('Result', response) unless response.code == '200'
  receipt = JSON.parse(response.body)
  break if receipt['status'] == 'done'
  abort "Processing failed: #{receipt['error']['detail']}" if receipt['status'] == 'failed'
  abort 'Timed out waiting for the result' if Process.clock_gettime(Process::CLOCK_MONOTONIC) > deadline
  sleep Integer(response['Retry-After'] || 2)
end

# 3. Use the data.
result = receipt['result']
puts "Establishment: #{result['establishment']}"
puts "Total: #{result['total']} #{result['currency']}"

// Full flow: upload a receipt, poll until the result is ready, print establishment and total.
// Java 17 or newer, standard library only.  Run: java Scan.java receipt.jpg
import java.net.URI;
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;
import java.util.List;
import java.util.UUID;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Scan {
    static final String API_URL = System.getenv().getOrDefault("TABSCANNER_API_URL", "https://api3.tabscanner.com");
    static final String AUTH = "Bearer " + System.getenv("TABSCANNER_API_KEY");
    static final HttpClient CLIENT = HttpClient.newHttpClient();

    public static void main(String[] args) throws Exception {
        Path image = Path.of(args.length > 0 ? args[0] : "receipt.jpg");

        // 1. Upload. 202 means accepted. The Idempotency-Key makes a resend after a network error safe.
        String boundary = "----TabscannerBoundary" + System.nanoTime();
        HttpResponse<String> upload = CLIENT.send(HttpRequest.newBuilder(URI.create(API_URL + "/v2/receipts"))
            .header("Authorization", AUTH)
            .header("Idempotency-Key", UUID.randomUUID().toString())
            .header("Content-Type", "multipart/form-data; boundary=" + boundary)
            .POST(multipartBody(boundary, image, "us")) // "us": country of the receipt
            .build(), HttpResponse.BodyHandlers.ofString());
        if (upload.statusCode() != 202) fail("Upload", upload);
        String token = field(upload.body(), "token");

        // 2. Poll until done or failed, waiting as long as Retry-After says between calls.
        long deadline = System.currentTimeMillis() + 120_000;
        String receipt;
        while (true) {
            HttpResponse<String> response = CLIENT.send(HttpRequest.newBuilder(URI.create(API_URL + "/v2/receipts/" + token))
                .header("Authorization", AUTH).build(), HttpResponse.BodyHandlers.ofString());
            if (response.statusCode() != 200) fail("Result", response);
            receipt = response.body();
            String status = field(receipt, "status");
            if (status.equals("done")) break;
            if (status.equals("failed")) {
                System.err.println("Processing failed: " + field(receipt, "detail"));
                System.exit(1);
            }
            if (System.currentTimeMillis() > deadline) {
                System.err.println("Timed out waiting for the result");
                System.exit(1);
            }
            Thread.sleep(1000L * Long.parseLong(response.headers().firstValue("Retry-After").orElse("2")));
        }

        // 3. Use the data.
        System.out.println("Establishment: " + field(receipt, "establishment"));
        System.out.println("Total: " + field(receipt, "total") + " " + field(receipt, "currency"));
    }

    // Errors are application/problem+json: {status, code, title, detail, requestId, ...}
    static void fail(String what, HttpResponse<String> response) {
        String detail = field(response.body(), "detail");
        System.err.println(what + " failed: " + response.statusCode() + " " + field(response.body(), "code") + ": "
            + (detail.isEmpty() ? field(response.body(), "title") : detail));
        System.exit(1);
    }

    static HttpRequest.BodyPublisher multipartBody(String boundary, Path image, String region) throws Exception {
        String type = image.toString().toLowerCase().endsWith(".png") ? "image/png" : "image/jpeg";
        String head = "--" + boundary + "\r\nContent-Disposition: form-data; name=\"region\"\r\n\r\n" + region + "\r\n"
            + "--" + boundary + "\r\nContent-Disposition: form-data; name=\"file\"; filename=\"" + image.getFileName()
            + "\"\r\nContent-Type: " + type + "\r\n\r\n";
        String tail = "\r\n--" + boundary + "--\r\n";
        return HttpRequest.BodyPublishers.ofByteArrays(List.of(
            head.getBytes(StandardCharsets.UTF_8), Files.readAllBytes(image), tail.getBytes(StandardCharsets.UTF_8)));
    }

    // Reads one scalar field from a JSON body. Use a JSON library such as Jackson in real code.
    static String field(String json, String name) {
        Matcher m = Pattern.compile("\"" + name + "\"\\s*:\\s*(\"((?:[^\"\\\\]|\\\\.)*)\"|[^,}\\]\\s]+)").matcher(json);
        if (!m.find()) return "";
        return m.group(2) != null ? m.group(2) : m.group(1);
    }
}

// Full flow: upload a receipt, poll until the result is ready, print establishment and total.
// Go 1.21 or newer, standard library only.  Run: go run ./cmd/scan receipt.jpg
package main

import (
	"bytes"
	"crypto/rand"
	"encoding/json"
	"fmt"
	"io"
	"mime/multipart"
	"net/http"
	"net/textproto"
	"os"
	"path/filepath"
	"strconv"
	"strings"
	"time"
)

var (
	apiURL = envOr("TABSCANNER_API_URL", "https://api3.tabscanner.com")
	auth   = "Bearer " + os.Getenv("TABSCANNER_API_KEY")
)

// problem is the application/problem+json body of every error response.
type problem struct {
	Code   string `json:"code"`
	Title  string `json:"title"`
	Detail string `json:"detail"`
}

type receipt struct {
	Token  string `json:"token"`
	Status string `json:"status"` // pending, done or failed
	Result struct {
		Establishment string      `json:"establishment"`
		Total         json.Number `json:"total"`
		Currency      string      `json:"currency"`
	} `json:"result"`
	Error struct {
		Detail string `json:"detail"`
	} `json:"error"`
}

func main() {
	imagePath := "receipt.jpg"
	if len(os.Args) > 1 {
		imagePath = os.Args[1]
	}

	// 1. Upload. 202 means accepted. The Idempotency-Key makes a resend after a network error safe.
	body, contentType, err := multipartBody(imagePath, "us") // "us": country of the receipt
	check(err)
	req, _ := http.NewRequest(http.MethodPost, apiURL+"/v2/receipts", body)
	req.Header.Set("Content-Type", contentType)
	req.Header.Set("Idempotency-Key", newUUID())
	var upload receipt
	resp, err := call(req, http.StatusAccepted, &upload)
	check(err)
	resp.Body.Close()

	// 2. Poll until done or failed, waiting as long as Retry-After says between calls.
	deadline := time.Now().Add(120 * time.Second)
	var result receipt
	for {
		req, _ := http.NewRequest(http.MethodGet, apiURL+"/v2/receipts/"+upload.Token, nil)
		resp, err := call(req, http.StatusOK, &result)
		check(err)
		if result.Status == "done" {
			break
		}
		if result.Status == "failed" {
			check(fmt.Errorf("processing failed: %s", result.Error.Detail))
		}
		if time.Now().After(deadline) {
			check(fmt.Errorf("timed out waiting for the result"))
		}
		wait, err := strconv.Atoi(resp.Header.Get("Retry-After"))
		if err != nil {
			wait = 2
		}
		time.Sleep(time.Duration(wait) * time.Second)
	}

	// 3. Use the data.
	fmt.Println("Establishment:", result.Result.Establishment)
	fmt.Println("Total:", result.Result.Total, result.Result.Currency)
}

// call sends the request and decodes the JSON body into out when the status is the
// expected one; otherwise it returns the problem details as an error.
func call(req *http.Request, want int, out any) (*http.Response, error) {
	req.Header.Set("Authorization", auth)
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()
	data, err := io.ReadAll(resp.Body)
	if err != nil {
		return nil, err
	}
	if resp.StatusCode != want {
		var p problem
		_ = json.Unmarshal(data, &p)
		if p.Detail == "" {
			p.Detail = p.Title
		}
		return nil, fmt.Errorf("%s %s: %d %s: %s", req.Method, req.URL.Path, resp.StatusCode, p.Code, p.Detail)
	}
	return resp, json.Unmarshal(data, out)
}

func multipartBody(imagePath, region string) (io.Reader, string, error) {
	image, err := os.ReadFile(imagePath)
	if err != nil {
		return nil, "", err
	}
	var buf bytes.Buffer
	w := multipart.NewWriter(&buf)
	_ = w.WriteField("region", region)
	header := textproto.MIMEHeader{}
	header.Set("Content-Disposition", fmt.Sprintf(`form-data; name="file"; filename=%q`, filepath.Base(imagePath)))
	if strings.HasSuffix(strings.ToLower(imagePath), ".png") {
		header.Set("Content-Type", "image/png")
	} else {
		header.Set("Content-Type", "image/jpeg")
	}
	part, err := w.CreatePart(header)
	if err != nil {
		return nil, "", err
	}
	if _, err := part.Write(image); err != nil {
		return nil, "", err
	}
	return &buf, w.FormDataContentType(), w.Close()
}

func newUUID() string {
	b := make([]byte, 16)
	_, _ = rand.Read(b)
	b[6], b[8] = b[6]&0x0f|0x40, b[8]&0x3f|0x80
	return fmt.Sprintf("%x-%x-%x-%x-%x", b[0:4], b[4:6], b[6:8], b[8:10], b[10:])
}

func envOr(name, fallback string) string {
	if v := os.Getenv(name); v != "" {
		return v
	}
	return fallback
}

func check(err error) {
	if err != nil {
		fmt.Fprintln(os.Stderr, err)
		os.Exit(1)
	}
}

// Full flow: upload a receipt, poll until the result is ready, print establishment and total.
// .NET 8, no packages.  Run: dotnet run -- scan receipt.jpg
using System.Net;
using System.Net.Http.Headers;
using System.Text.Json;

static class ScanSample
{
    static readonly string ApiUrl = Environment.GetEnvironmentVariable("TABSCANNER_API_URL") ?? "https://api3.tabscanner.com";
    static readonly string ApiKey = Environment.GetEnvironmentVariable("TABSCANNER_API_KEY") ?? "";

    public static async Task<int> Run(string[] args)
    {
        var imagePath = args.Length > 0 ? args[0] : "receipt.jpg";
        using var client = new HttpClient();
        client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", ApiKey);

        // 1. Upload. 202 means accepted. The Idempotency-Key makes a resend after a network error safe.
        using var form = new MultipartFormDataContent();
        var file = new StreamContent(File.OpenRead(imagePath));
        var mimeType = imagePath.EndsWith(".png", StringComparison.OrdinalIgnoreCase) ? "image/png" : "image/jpeg";
        file.Headers.ContentType = new MediaTypeHeaderValue(mimeType);
        form.Add(file, "file", Path.GetFileName(imagePath));
        form.Add(new StringContent("us"), "region"); // country of the receipt, improves accuracy

        using var uploadRequest = new HttpRequestMessage(HttpMethod.Post, $"{ApiUrl}/v2/receipts") { Content = form };
        uploadRequest.Headers.Add("Idempotency-Key", Guid.NewGuid().ToString());
        using var uploadResponse = await client.SendAsync(uploadRequest);
        using var upload = JsonDocument.Parse(await uploadResponse.Content.ReadAsStringAsync());
        if (uploadResponse.StatusCode != HttpStatusCode.Accepted) return Fail("Upload", uploadResponse, upload);
        var token = upload.RootElement.GetProperty("token").GetString();

        // 2. Poll until done or failed, waiting as long as Retry-After says between calls.
        var deadline = DateTime.UtcNow.AddSeconds(120);
        while (true)
        {
            using var response = await client.GetAsync($"{ApiUrl}/v2/receipts/{token}");
            using var receipt = JsonDocument.Parse(await response.Content.ReadAsStringAsync());
            if (response.StatusCode != HttpStatusCode.OK) return Fail("Result", response, receipt);
            var status = receipt.RootElement.GetProperty("status").GetString();
            if (status == "done")
            {
                // 3. Use the data.
                var result = receipt.RootElement.GetProperty("result");
                Console.WriteLine($"Establishment: {result.GetProperty("establishment").GetString()}");
                Console.WriteLine($"Total: {result.GetProperty("total")} {result.GetProperty("currency").GetString()}");
                return 0;
            }
            if (status == "failed")
            {
                Console.Error.WriteLine($"Processing failed: {receipt.RootElement.GetProperty("error").GetProperty("detail").GetString()}");
                return 1;
            }
            if (DateTime.UtcNow > deadline)
            {
                Console.Error.WriteLine("Timed out waiting for the result");
                return 1;
            }
            await Task.Delay(response.Headers.RetryAfter?.Delta ?? TimeSpan.FromSeconds(2));
        }
    }

    // Errors are application/problem+json: {status, code, title, detail, requestId, ...}
    static int Fail(string what, HttpResponseMessage response, JsonDocument problem)
    {
        var p = problem.RootElement;
        var detail = p.TryGetProperty("detail", out var d) ? d.GetString() : p.GetProperty("title").GetString();
        Console.Error.WriteLine($"{what} failed: {(int)response.StatusCode} {p.GetProperty("code").GetString()}: {detail}");
        return 1;
    }
}

#!/usr/bin/env bash
# Upload a receipt. Prints the 202 response: the token, the duplicate flag and the result link.
# Usage: TABSCANNER_API_KEY=your-key ./upload.sh receipt.jpg
set -euo pipefail
API_URL="${TABSCANNER_API_URL:-https://api3.tabscanner.com}"

curl -sS --fail-with-body "$API_URL/v2/receipts" \
  -H "Authorization: Bearer ${TABSCANNER_API_KEY:?set TABSCANNER_API_KEY}" \
  -H "Idempotency-Key: $(uuidgen)" \
  -F "file=@${1:-receipt.jpg}" \
  -F "region=us"

// Upload a receipt. Prints the token, the duplicate flag and the result link.
// Node 20 or newer, no packages.  Usage: node upload.js receipt.jpg
import { randomUUID } from 'node:crypto';
import { openAsBlob } from 'node:fs';
import path from 'node:path';

const API_URL = process.env.TABSCANNER_API_URL ?? 'https://api3.tabscanner.com';
const imagePath = process.argv[2] ?? 'receipt.jpg';

const form = new FormData();
const mimeType = imagePath.toLowerCase().endsWith('.png') ? 'image/png' : 'image/jpeg';
form.append('file', await openAsBlob(imagePath, { type: mimeType }), path.basename(imagePath));
form.append('region', 'us');

const response = await fetch(`${API_URL}/v2/receipts`, {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${process.env.TABSCANNER_API_KEY}`,
    'Idempotency-Key': randomUUID(),
  },
  body: form,
});
const body = await response.json();
if (response.status !== 202) {
  console.error(`Upload failed: ${response.status} ${body.code}: ${body.detail ?? body.title}`);
  process.exit(1);
}
console.log(`Token: ${body.token}`);
console.log(`Duplicate: ${body.duplicate}`);
console.log(`Result: ${response.headers.get('location')}`);

"""Upload a receipt. Prints the token, the duplicate flag and the result link.

Python 3.9 or newer, needs `pip install requests`.  Usage: python upload.py receipt.jpg
"""
import os
import sys
import uuid

import requests

API_URL = os.environ.get("TABSCANNER_API_URL", "https://api3.tabscanner.com")
image_path = sys.argv[1] if len(sys.argv) > 1 else "receipt.jpg"

mime_type = "image/png" if image_path.lower().endswith(".png") else "image/jpeg"
with open(image_path, "rb") as image:
    response = requests.post(
        f"{API_URL}/v2/receipts",
        headers={
            "Authorization": f"Bearer {os.environ['TABSCANNER_API_KEY']}",
            "Idempotency-Key": str(uuid.uuid4()),
        },
        files={"file": (os.path.basename(image_path), image, mime_type)},
        data={"region": "us"},
        timeout=60,
    )
body = response.json()
if response.status_code != 202:
    sys.exit(f"Upload failed: {response.status_code} {body['code']}: {body.get('detail', body['title'])}")
print(f"Token: {body['token']}")
print(f"Duplicate: {body['duplicate']}")
print(f"Result: {response.headers['Location']}")

<?php
// Upload a receipt. Prints the token, the duplicate flag and the result link.
// PHP 8 with the curl extension.  Usage: php upload.php receipt.jpg

$apiUrl = getenv('TABSCANNER_API_URL') ?: 'https://api3.tabscanner.com';
$imagePath = $argv[1] ?? 'receipt.jpg';
$mimeType = str_ends_with(strtolower($imagePath), '.png') ? 'image/png' : 'image/jpeg';

$ch = curl_init("$apiUrl/v2/receipts");
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer ' . getenv('TABSCANNER_API_KEY'),
        'Idempotency-Key: ' . bin2hex(random_bytes(16)),
    ],
    CURLOPT_POSTFIELDS => [
        'file' => new CURLFile($imagePath, $mimeType, basename($imagePath)),
        'region' => 'us',
    ],
]);
$body = json_decode(curl_exec($ch), true);
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);
if ($status !== 202) {
    fwrite(STDERR, "Upload failed: $status {$body['code']}: " . ($body['detail'] ?? $body['title']) . "\n");
    exit(1);
}
echo "Token: {$body['token']}\n";
echo 'Duplicate: ' . ($body['duplicate'] ? 'true' : 'false') . "\n";
echo "Result: {$body['links']['result']}\n";

# Upload a receipt. Prints the token, the duplicate flag and the result link.
# Ruby 3.0 or newer, standard library only.  Usage: ruby upload.rb receipt.jpg
require 'json'
require 'net/http'
require 'securerandom'

API_URL = ENV.fetch('TABSCANNER_API_URL', 'https://api3.tabscanner.com')
image_path = ARGV[0] || 'receipt.jpg'
mime_type = image_path.downcase.end_with?('.png') ? 'image/png' : 'image/jpeg'

uri = URI("#{API_URL}/v2/receipts")
request = Net::HTTP::Post.new(uri)
request['Authorization'] = "Bearer #{ENV.fetch('TABSCANNER_API_KEY')}"
request['Idempotency-Key'] = SecureRandom.uuid
response = File.open(image_path, 'rb') do |image|
  request.set_form([
    ['file', image, { filename: File.basename(image_path), content_type: mime_type }],
    ['region', 'us']
  ], 'multipart/form-data')
  Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') { |http| http.request(request) }
end
body = JSON.parse(response.body)
abort "Upload failed: #{response.code} #{body['code']}: #{body['detail'] || body['title']}" unless response.code == '202'
puts "Token: #{body['token']}"
puts "Duplicate: #{body['duplicate']}"
puts "Result: #{response['Location']}"

// Upload a receipt. Prints the token, the duplicate flag and the result link.
// Java 17 or newer, standard library only.  Run: java Upload.java receipt.jpg
import java.net.URI;
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;
import java.util.List;
import java.util.UUID;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Upload {
    public static void main(String[] args) throws Exception {
        String apiUrl = System.getenv().getOrDefault("TABSCANNER_API_URL", "https://api3.tabscanner.com");
        Path image = Path.of(args.length > 0 ? args[0] : "receipt.jpg");
        String type = image.toString().toLowerCase().endsWith(".png") ? "image/png" : "image/jpeg";
        String boundary = "----TabscannerBoundary" + System.nanoTime();
        String head = "--" + boundary + "\r\nContent-Disposition: form-data; name=\"region\"\r\n\r\nus\r\n"
            + "--" + boundary + "\r\nContent-Disposition: form-data; name=\"file\"; filename=\"" + image.getFileName()
            + "\"\r\nContent-Type: " + type + "\r\n\r\n";
        String tail = "\r\n--" + boundary + "--\r\n";

        HttpResponse<String> response = HttpClient.newHttpClient().send(
            HttpRequest.newBuilder(URI.create(apiUrl + "/v2/receipts"))
                .header("Authorization", "Bearer " + System.getenv("TABSCANNER_API_KEY"))
                .header("Idempotency-Key", UUID.randomUUID().toString())
                .header("Content-Type", "multipart/form-data; boundary=" + boundary)
                .POST(HttpRequest.BodyPublishers.ofByteArrays(List.of(
                    head.getBytes(StandardCharsets.UTF_8), Files.readAllBytes(image), tail.getBytes(StandardCharsets.UTF_8))))
                .build(),
            HttpResponse.BodyHandlers.ofString());
        if (response.statusCode() != 202) {
            System.err.println("Upload failed: " + response.statusCode() + " " + response.body());
            System.exit(1);
        }
        System.out.println("Token: " + field(response.body(), "token"));
        System.out.println("Duplicate: " + field(response.body(), "duplicate"));
        System.out.println("Result: " + response.headers().firstValue("Location").orElse(""));
    }

    // Reads one scalar field from a JSON body. Use a JSON library such as Jackson in real code.
    static String field(String json, String name) {
        Matcher m = Pattern.compile("\"" + name + "\"\\s*:\\s*(\"((?:[^\"\\\\]|\\\\.)*)\"|[^,}\\]\\s]+)").matcher(json);
        if (!m.find()) return "";
        return m.group(2) != null ? m.group(2) : m.group(1);
    }
}

// Upload a receipt. Prints the token, the duplicate flag and the result link.
// Go 1.21 or newer, standard library only.  Run: go run ./cmd/upload receipt.jpg
package main

import (
	"bytes"
	"crypto/rand"
	"encoding/json"
	"fmt"
	"io"
	"mime/multipart"
	"net/http"
	"net/textproto"
	"os"
	"path/filepath"
	"strings"
)

func main() {
	apiURL := os.Getenv("TABSCANNER_API_URL")
	if apiURL == "" {
		apiURL = "https://api3.tabscanner.com"
	}
	imagePath := "receipt.jpg"
	if len(os.Args) > 1 {
		imagePath = os.Args[1]
	}
	image, err := os.ReadFile(imagePath)
	check(err)

	var buf bytes.Buffer
	w := multipart.NewWriter(&buf)
	_ = w.WriteField("region", "us")
	header := textproto.MIMEHeader{}
	header.Set("Content-Disposition", fmt.Sprintf(`form-data; name="file"; filename=%q`, filepath.Base(imagePath)))
	header.Set("Content-Type", "image/jpeg")
	if strings.HasSuffix(strings.ToLower(imagePath), ".png") {
		header.Set("Content-Type", "image/png")
	}
	part, err := w.CreatePart(header)
	check(err)
	_, _ = part.Write(image)
	check(w.Close())

	key := make([]byte, 16)
	_, _ = rand.Read(key)
	req, _ := http.NewRequest(http.MethodPost, apiURL+"/v2/receipts", &buf)
	req.Header.Set("Authorization", "Bearer "+os.Getenv("TABSCANNER_API_KEY"))
	req.Header.Set("Content-Type", w.FormDataContentType())
	req.Header.Set("Idempotency-Key", fmt.Sprintf("%x", key))
	resp, err := http.DefaultClient.Do(req)
	check(err)
	defer resp.Body.Close()
	data, _ := io.ReadAll(resp.Body)
	if resp.StatusCode != http.StatusAccepted {
		check(fmt.Errorf("upload failed: %d %s", resp.StatusCode, data))
	}
	var body struct {
		Token     string `json:"token"`
		Duplicate bool   `json:"duplicate"`
	}
	check(json.Unmarshal(data, &body))
	fmt.Println("Token:", body.Token)
	fmt.Println("Duplicate:", body.Duplicate)
	fmt.Println("Result:", resp.Header.Get("Location"))
}

func check(err error) {
	if err != nil {
		fmt.Fprintln(os.Stderr, err)
		os.Exit(1)
	}
}

// Upload a receipt. Prints the token, the duplicate flag and the result link.
// .NET 8, no packages.  Run: dotnet run -- upload receipt.jpg
using System.Net;
using System.Net.Http.Headers;
using System.Text.Json;

static class UploadSample
{
    public static async Task<int> Run(string[] args)
    {
        var apiUrl = Environment.GetEnvironmentVariable("TABSCANNER_API_URL") ?? "https://api3.tabscanner.com";
        var imagePath = args.Length > 0 ? args[0] : "receipt.jpg";
        using var client = new HttpClient();
        client.DefaultRequestHeaders.Authorization =
            new AuthenticationHeaderValue("Bearer", Environment.GetEnvironmentVariable("TABSCANNER_API_KEY"));

        using var form = new MultipartFormDataContent();
        var file = new StreamContent(File.OpenRead(imagePath));
        file.Headers.ContentType = new MediaTypeHeaderValue(
            imagePath.EndsWith(".png", StringComparison.OrdinalIgnoreCase) ? "image/png" : "image/jpeg");
        form.Add(file, "file", Path.GetFileName(imagePath));
        form.Add(new StringContent("us"), "region");

        using var request = new HttpRequestMessage(HttpMethod.Post, $"{apiUrl}/v2/receipts") { Content = form };
        request.Headers.Add("Idempotency-Key", Guid.NewGuid().ToString());
        using var response = await client.SendAsync(request);
        var json = await response.Content.ReadAsStringAsync();
        if (response.StatusCode != HttpStatusCode.Accepted)
        {
            Console.Error.WriteLine($"Upload failed: {(int)response.StatusCode} {json}");
            return 1;
        }
        using var body = JsonDocument.Parse(json);
        Console.WriteLine($"Token: {body.RootElement.GetProperty("token").GetString()}");
        Console.WriteLine($"Duplicate: {body.RootElement.GetProperty("duplicate").GetBoolean()}");
        Console.WriteLine($"Result: {response.Headers.Location}");
        return 0;
    }
}

#!/usr/bin/env bash
# Fetch a result once. status is "pending" (call again after Retry-After), "done" or "failed".
# Usage: TABSCANNER_API_KEY=your-key ./result.sh TOKEN
set -euo pipefail
API_URL="${TABSCANNER_API_URL:-https://api3.tabscanner.com}"

curl -sS --fail-with-body "$API_URL/v2/receipts/${1:?token}" \
  -H "Authorization: Bearer ${TABSCANNER_API_KEY:?set TABSCANNER_API_KEY}"

// Fetch a result once. status is "pending" (call again after Retry-After), "done" or "failed".
// Node 20 or newer, no packages.  Usage: node result.js TOKEN
const API_URL = process.env.TABSCANNER_API_URL ?? 'https://api3.tabscanner.com';
const token = process.argv[2];

const response = await fetch(`${API_URL}/v2/receipts/${token}`, {
  headers: { Authorization: `Bearer ${process.env.TABSCANNER_API_KEY}` },
});
const body = await response.json();
if (response.status !== 200) {
  console.error(`Result failed: ${response.status} ${body.code}: ${body.detail ?? body.title}`);
  process.exit(1);
}
if (body.status === 'pending') {
  console.log(`Pending, try again in ${response.headers.get('retry-after')} seconds`);
} else if (body.status === 'failed') {
  console.log(`Failed: ${body.error.detail}`);
} else {
  console.log(`Establishment: ${body.result.establishment}`);
  console.log(`Total: ${body.result.total} ${body.result.currency}`);
}

"""Fetch a result once. status is "pending" (call again after Retry-After), "done" or "failed".

Python 3.9 or newer, needs `pip install requests`.  Usage: python result.py TOKEN
"""
import os
import sys

import requests

API_URL = os.environ.get("TABSCANNER_API_URL", "https://api3.tabscanner.com")

response = requests.get(
    f"{API_URL}/v2/receipts/{sys.argv[1]}",
    headers={"Authorization": f"Bearer {os.environ['TABSCANNER_API_KEY']}"},
    timeout=30,
)
body = response.json()
if response.status_code != 200:
    sys.exit(f"Result failed: {response.status_code} {body['code']}: {body.get('detail', body['title'])}")
if body["status"] == "pending":
    print(f"Pending, try again in {response.headers['Retry-After']} seconds")
elif body["status"] == "failed":
    print(f"Failed: {body['error']['detail']}")
else:
    print(f"Establishment: {body['result']['establishment']}")
    print(f"Total: {body['result']['total']} {body['result']['currency']}")

<?php
// Fetch a result once. status is "pending" (call again after Retry-After), "done" or "failed".
// PHP 8 with the curl extension.  Usage: php result.php TOKEN

$apiUrl = getenv('TABSCANNER_API_URL') ?: 'https://api3.tabscanner.com';

$ch = curl_init("$apiUrl/v2/receipts/{$argv[1]}");
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ['Authorization: Bearer ' . getenv('TABSCANNER_API_KEY')],
]);
$body = json_decode(curl_exec($ch), true);
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);
if ($status !== 200) {
    fwrite(STDERR, "Result failed: $status {$body['code']}: " . ($body['detail'] ?? $body['title']) . "\n");
    exit(1);
}
match ($body['status']) {
    'pending' => print("Pending, try again shortly\n"),
    'failed' => print("Failed: {$body['error']['detail']}\n"),
    'done' => print("Establishment: {$body['result']['establishment']}\nTotal: {$body['result']['total']} {$body['result']['currency']}\n"),
};

# Fetch a result once. status is "pending" (call again after Retry-After), "done" or "failed".
# Ruby 3.0 or newer, standard library only.  Usage: ruby result.rb TOKEN
require 'json'
require 'net/http'

API_URL = ENV.fetch('TABSCANNER_API_URL', 'https://api3.tabscanner.com')

uri = URI("#{API_URL}/v2/receipts/#{ARGV.fetch(0)}")
request = Net::HTTP::Get.new(uri)
request['Authorization'] = "Bearer #{ENV.fetch('TABSCANNER_API_KEY')}"
response = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') { |http| http.request(request) }
body = JSON.parse(response.body)
abort "Result failed: #{response.code} #{body['code']}: #{body['detail'] || body['title']}" unless response.code == '200'
case body['status']
when 'pending' then puts "Pending, try again in #{response['Retry-After']} seconds"
when 'failed' then puts "Failed: #{body['error']['detail']}"
else
  puts "Establishment: #{body['result']['establishment']}"
  puts "Total: #{body['result']['total']} #{body['result']['currency']}"
end

// Fetch a result once. status is "pending" (call again after Retry-After), "done" or "failed".
// Java 17 or newer, standard library only.  Run: java Result.java TOKEN
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Result {
    public static void main(String[] args) throws Exception {
        String apiUrl = System.getenv().getOrDefault("TABSCANNER_API_URL", "https://api3.tabscanner.com");
        HttpResponse<String> response = HttpClient.newHttpClient().send(
            HttpRequest.newBuilder(URI.create(apiUrl + "/v2/receipts/" + args[0]))
                .header("Authorization", "Bearer " + System.getenv("TABSCANNER_API_KEY"))
                .build(),
            HttpResponse.BodyHandlers.ofString());
        if (response.statusCode() != 200) {
            System.err.println("Result failed: " + response.statusCode() + " " + response.body());
            System.exit(1);
        }
        // Print the whole JSON body; see Scan.java for reading individual fields.
        System.out.println(response.body());
    }
}

// Fetch a result once. status is "pending" (call again after Retry-After), "done" or "failed".
// Go 1.21 or newer, standard library only.  Run: go run ./cmd/result TOKEN
package main

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

func main() {
	apiURL := os.Getenv("TABSCANNER_API_URL")
	if apiURL == "" {
		apiURL = "https://api3.tabscanner.com"
	}
	req, _ := http.NewRequest(http.MethodGet, apiURL+"/v2/receipts/"+os.Args[1], nil)
	req.Header.Set("Authorization", "Bearer "+os.Getenv("TABSCANNER_API_KEY"))
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		fmt.Fprintln(os.Stderr, err)
		os.Exit(1)
	}
	defer resp.Body.Close()
	data, _ := io.ReadAll(resp.Body)
	if resp.StatusCode != http.StatusOK {
		fmt.Fprintf(os.Stderr, "result failed: %d %s\n", resp.StatusCode, data)
		os.Exit(1)
	}
	// Print the whole JSON body; see cmd/scan for decoding individual fields.
	fmt.Println(string(data))
}

// Fetch a result once. status is "pending" (call again after Retry-After), "done" or "failed".
// .NET 8, no packages.  Run: dotnet run -- result TOKEN
using System.Net;
using System.Net.Http.Headers;

static class ResultSample
{
    public static async Task<int> Run(string[] args)
    {
        var apiUrl = Environment.GetEnvironmentVariable("TABSCANNER_API_URL") ?? "https://api3.tabscanner.com";
        using var client = new HttpClient();
        client.DefaultRequestHeaders.Authorization =
            new AuthenticationHeaderValue("Bearer", Environment.GetEnvironmentVariable("TABSCANNER_API_KEY"));

        using var response = await client.GetAsync($"{apiUrl}/v2/receipts/{args[0]}");
        var json = await response.Content.ReadAsStringAsync();
        if (response.StatusCode != HttpStatusCode.OK)
        {
            Console.Error.WriteLine($"Result failed: {(int)response.StatusCode} {json}");
            return 1;
        }
        // Print the whole JSON body; see Scan.cs for reading individual fields.
        Console.WriteLine(json);
        return 0;
    }
}

#!/usr/bin/env bash
# Show the account: remaining credit, billing type and enabled features.
# Usage: TABSCANNER_API_KEY=your-key ./account.sh
set -euo pipefail
API_URL="${TABSCANNER_API_URL:-https://api3.tabscanner.com}"

curl -sS --fail-with-body "$API_URL/v2/account" \
  -H "Authorization: Bearer ${TABSCANNER_API_KEY:?set TABSCANNER_API_KEY}"

// Show the account: remaining credit, billing type and enabled features.
// Node 20 or newer, no packages.  Usage: node account.js
const API_URL = process.env.TABSCANNER_API_URL ?? 'https://api3.tabscanner.com';

const response = await fetch(`${API_URL}/v2/account`, {
  headers: { Authorization: `Bearer ${process.env.TABSCANNER_API_KEY}` },
});
const body = await response.json();
if (response.status !== 200) {
  console.error(`Account failed: ${response.status} ${body.code}: ${body.detail ?? body.title}`);
  process.exit(1);
}
console.log(`Credit: ${body.credit} (${body.billing})`);
console.log(`Features: ${JSON.stringify(body.features)}`);

"""Show the account: remaining credit, billing type and enabled features.

Python 3.9 or newer, needs `pip install requests`.  Usage: python account.py
"""
import os
import sys

import requests

API_URL = os.environ.get("TABSCANNER_API_URL", "https://api3.tabscanner.com")

response = requests.get(
    f"{API_URL}/v2/account",
    headers={"Authorization": f"Bearer {os.environ['TABSCANNER_API_KEY']}"},
    timeout=30,
)
body = response.json()
if response.status_code != 200:
    sys.exit(f"Account failed: {response.status_code} {body['code']}: {body.get('detail', body['title'])}")
print(f"Credit: {body['credit']} ({body['billing']})")
print(f"Features: {body['features']}")

<?php
// Show the account: remaining credit, billing type and enabled features.
// PHP 8 with the curl extension.  Usage: php account.php

$apiUrl = getenv('TABSCANNER_API_URL') ?: 'https://api3.tabscanner.com';

$ch = curl_init("$apiUrl/v2/account");
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ['Authorization: Bearer ' . getenv('TABSCANNER_API_KEY')],
]);
$body = json_decode(curl_exec($ch), true);
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);
if ($status !== 200) {
    fwrite(STDERR, "Account failed: $status {$body['code']}: " . ($body['detail'] ?? $body['title']) . "\n");
    exit(1);
}
echo "Credit: {$body['credit']} ({$body['billing']})\n";
echo 'Features: ' . json_encode($body['features']) . "\n";

# Show the account: remaining credit, billing type and enabled features.
# Ruby 3.0 or newer, standard library only.  Usage: ruby account.rb
require 'json'
require 'net/http'

API_URL = ENV.fetch('TABSCANNER_API_URL', 'https://api3.tabscanner.com')

uri = URI("#{API_URL}/v2/account")
request = Net::HTTP::Get.new(uri)
request['Authorization'] = "Bearer #{ENV.fetch('TABSCANNER_API_KEY')}"
response = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') { |http| http.request(request) }
body = JSON.parse(response.body)
abort "Account failed: #{response.code} #{body['code']}: #{body['detail'] || body['title']}" unless response.code == '200'
puts "Credit: #{body['credit']} (#{body['billing']})"
puts "Features: #{body['features']}"

// Show the account: remaining credit, billing type and enabled features.
// Java 17 or newer, standard library only.  Run: java Account.java
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Account {
    public static void main(String[] args) throws Exception {
        String apiUrl = System.getenv().getOrDefault("TABSCANNER_API_URL", "https://api3.tabscanner.com");
        HttpResponse<String> response = HttpClient.newHttpClient().send(
            HttpRequest.newBuilder(URI.create(apiUrl + "/v2/account"))
                .header("Authorization", "Bearer " + System.getenv("TABSCANNER_API_KEY"))
                .build(),
            HttpResponse.BodyHandlers.ofString());
        if (response.statusCode() != 200) {
            System.err.println("Account failed: " + response.statusCode() + " " + response.body());
            System.exit(1);
        }
        System.out.println(response.body());
    }
}

// Show the account: remaining credit, billing type and enabled features.
// Go 1.21 or newer, standard library only.  Run: go run ./cmd/account
package main

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

func main() {
	apiURL := os.Getenv("TABSCANNER_API_URL")
	if apiURL == "" {
		apiURL = "https://api3.tabscanner.com"
	}
	req, _ := http.NewRequest(http.MethodGet, apiURL+"/v2/account", nil)
	req.Header.Set("Authorization", "Bearer "+os.Getenv("TABSCANNER_API_KEY"))
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		fmt.Fprintln(os.Stderr, err)
		os.Exit(1)
	}
	defer resp.Body.Close()
	data, _ := io.ReadAll(resp.Body)
	if resp.StatusCode != http.StatusOK {
		fmt.Fprintf(os.Stderr, "account failed: %d %s\n", resp.StatusCode, data)
		os.Exit(1)
	}
	fmt.Println(string(data))
}

// Show the account: remaining credit, billing type and enabled features.
// .NET 8, no packages.  Run: dotnet run -- account
using System.Net;
using System.Net.Http.Headers;

static class AccountSample
{
    public static async Task<int> Run(string[] args)
    {
        var apiUrl = Environment.GetEnvironmentVariable("TABSCANNER_API_URL") ?? "https://api3.tabscanner.com";
        using var client = new HttpClient();
        client.DefaultRequestHeaders.Authorization =
            new AuthenticationHeaderValue("Bearer", Environment.GetEnvironmentVariable("TABSCANNER_API_KEY"));

        using var response = await client.GetAsync($"{apiUrl}/v2/account");
        var json = await response.Content.ReadAsStringAsync();
        if (response.StatusCode != HttpStatusCode.OK)
        {
            Console.Error.WriteLine($"Account failed: {(int)response.StatusCode} {json}");
            return 1;
        }
        Console.WriteLine(json);
        return 0;
    }
}