Embossify API

#!/usr/bin/env bash
# Starts an Embossify render, waits for it to finish, and saves the STL.
# Needs only bash and curl. Replace CODE and IMAGE, then run: bash embossify.sh
set -euo pipefail

API="https://api.embossify.com/"
CODE="YOUR_VOLUME_EMBOSSMENT_CODE"
IMAGE="https://www.embossify.com/assets/img/matsu.jpg"

# 1. Start the render (this uses one embossment from your code)
RESPONSE=$(curl -sG "$API" \
  --data-urlencode "cmd=redeem" \
  --data-urlencode "code=$CODE" \
  --data-urlencode "imageurl=$IMAGE" \
  --data-urlencode "width=120" \
  --data-urlencode "depth=5" \
  --data-urlencode "thicker=lighter")

BID=$(echo "$RESPONSE" | grep -o '"success":"[^"]*"' | cut -d'"' -f4 || true)
if [ -z "$BID" ]; then
  echo "Could not start the render: $RESPONSE" >&2
  exit 1
fi

# 2. Wait until it is ready (please keep to one request per second or slower)
until curl -s "$API?cmd=status&bid=$BID" | grep -q '"complete"'; do
  sleep 2
done

# 3. Download the STL
curl -s -o embossment.stl "$API?cmd=download&bid=$BID"
echo "Saved embossment.stl"

# Starts an Embossify render, waits for it to finish, and saves the STL.
# Needs Python 3 and the requests package (pip install requests).
import time

import requests

API = "https://api.embossify.com/"
CODE = "YOUR_VOLUME_EMBOSSMENT_CODE"
IMAGE = "https://www.embossify.com/assets/img/matsu.jpg"

# 1. Start the render (this uses one embossment from your code)
started = requests.get(API, params={
    "cmd": "redeem",
    "code": CODE,
    "imageurl": IMAGE,
    "width": 120,
    "depth": 5,
    "thicker": "lighter",
}, timeout=60).json()
if "error" in started:
    raise SystemExit(started["error"])
bid = started["success"]

# 2. Wait until it is ready (please keep to one request per second or slower)
while True:
    status = requests.get(API, params={"cmd": "status", "bid": bid}, timeout=30).json()
    if "error" in status:
        raise SystemExit(status["error"])
    if status.get("status") == "complete":
        break
    time.sleep(2)

# 3. Download the STL
with requests.get(API, params={"cmd": "download", "bid": bid}, stream=True, timeout=300) as download:
    download.raise_for_status()
    with open("embossment.stl", "wb") as out:
        for chunk in download.iter_content(chunk_size=256 * 1024):
            out.write(chunk)
print("Saved embossment.stl")

// Starts an Embossify render, waits for it to finish, and saves the STL.
// Needs Node.js 18 or newer (built-in fetch). Save as embossify.mjs and run: node embossify.mjs
import { createWriteStream } from "node:fs";
import { Readable } from "node:stream";
import { pipeline } from "node:stream/promises";

const API = "https://api.embossify.com/";
const CODE = "YOUR_VOLUME_EMBOSSMENT_CODE";
const IMAGE = "https://www.embossify.com/assets/img/matsu.jpg";

const url = (params) => `${API}?${new URLSearchParams(params)}`;
const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

// 1. Start the render (this uses one embossment from your code)
const started = await (await fetch(url({
  cmd: "redeem", code: CODE, imageurl: IMAGE, width: 120, depth: 5, thicker: "lighter",
}))).json();
if (started.error) throw new Error(started.error);
const bid = started.success;

// 2. Wait until it is ready (please keep to one request per second or slower)
while (true) {
  const status = await (await fetch(url({ cmd: "status", bid }))).json();
  if (status.error) throw new Error(status.error);
  if (status.status === "complete") break;
  await sleep(2000);
}

// 3. Download the STL
const download = await fetch(url({ cmd: "download", bid }));
if (!download.ok) throw new Error(`Download failed (HTTP ${download.status})`);
await pipeline(Readable.fromWeb(download.body), createWriteStream("embossment.stl"));
console.log("Saved embossment.stl");

<?php
// Starts an Embossify render, waits for it to finish, and saves the STL.
// Needs PHP 7.4 or newer with allow_url_fopen on (the default). Run: php embossify.php
$api = "https://api.embossify.com/";
$code = "YOUR_VOLUME_EMBOSSMENT_CODE";
$image = "https://www.embossify.com/assets/img/matsu.jpg";

function call(string $api, array $params): array
{
    $json = file_get_contents($api . "?" . http_build_query($params));
    return json_decode((string) $json, true) ?: ["error" => "No answer from the API"];
}

// 1. Start the render (this uses one embossment from your code)
$started = call($api, [
    "cmd" => "redeem",
    "code" => $code,
    "imageurl" => $image,
    "width" => 120,
    "depth" => 5,
    "thicker" => "lighter",
]);
if (isset($started["error"])) {
    exit($started["error"] . "\n");
}
$bid = $started["success"];

// 2. Wait until it is ready (please keep to one request per second or slower)
do {
    sleep(2);
    $status = call($api, ["cmd" => "status", "bid" => $bid]);
    if (isset($status["error"])) {
        exit($status["error"] . "\n");
    }
} while (($status["status"] ?? "") !== "complete");

// 3. Download the STL
$in = fopen($api . "?" . http_build_query(["cmd" => "download", "bid" => $bid]), "rb");
$out = fopen("embossment.stl", "wb");
stream_copy_to_stream($in, $out);
fclose($in);
fclose($out);
echo "Saved embossment.stl\n";

// Starts an Embossify render, waits for it to finish, and saves the STL.
// Needs .NET 6 or newer. Create a console app (dotnet new console), paste this into Program.cs, then: dotnet run
using System.Text.Json;

const string Api = "https://api.embossify.com/";
const string Code = "YOUR_VOLUME_EMBOSSMENT_CODE";
const string Image = "https://www.embossify.com/assets/img/matsu.jpg";

using var http = new HttpClient { Timeout = TimeSpan.FromMinutes(10) };

async Task<JsonElement> Call(string query)
{
    var json = await http.GetStringAsync($"{Api}?{query}");
    return JsonDocument.Parse(json).RootElement;
}

// 1. Start the render (this uses one embossment from your code)
var started = await Call($"cmd=redeem&code={Uri.EscapeDataString(Code)}&imageurl={Uri.EscapeDataString(Image)}&width=120&depth=5&thicker=lighter");
if (started.TryGetProperty("error", out var startError))
    throw new Exception(startError.GetString());
var bid = started.GetProperty("success").ToString();

// 2. Wait until it is ready (please keep to one request per second or slower)
while (true)
{
    var status = await Call($"cmd=status&bid={bid}");
    if (status.TryGetProperty("error", out var statusError))
        throw new Exception(statusError.GetString());
    if (status.GetProperty("status").GetString() == "complete")
        break;
    await Task.Delay(2000);
}

// 3. Download the STL
await using var stream = await http.GetStreamAsync($"{Api}?cmd=download&bid={bid}");
await using var file = File.Create("embossment.stl");
await stream.CopyToAsync(file);
Console.WriteLine("Saved embossment.stl");

// Starts an Embossify render, waits for it to finish, and saves the STL.
// Needs Go 1.18 or newer. Save as main.go and run: go run main.go
package main

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

const (
	api   = "https://api.embossify.com/"
	code  = "YOUR_VOLUME_EMBOSSMENT_CODE"
	image = "https://www.embossify.com/assets/img/matsu.jpg"
)

func call(params url.Values) map[string]any {
	resp, err := http.Get(api + "?" + params.Encode())
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	var out map[string]any
	if err := json.NewDecoder(resp.Body).Decode(&out); err != nil {
		panic(err)
	}
	if msg, failed := out["error"]; failed {
		panic(msg)
	}
	return out
}

func main() {
	// 1. Start the render (this uses one embossment from your code)
	started := call(url.Values{
		"cmd":      {"redeem"},
		"code":     {code},
		"imageurl": {image},
		"width":    {"120"},
		"depth":    {"5"},
		"thicker":  {"lighter"},
	})
	bid := fmt.Sprint(started["success"])

	// 2. Wait until it is ready (please keep to one request per second or slower)
	for call(url.Values{"cmd": {"status"}, "bid": {bid}})["status"] != "complete" {
		time.Sleep(2 * time.Second)
	}

	// 3. Download the STL
	resp, err := http.Get(api + "?" + url.Values{"cmd": {"download"}, "bid": {bid}}.Encode())
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	file, err := os.Create("embossment.stl")
	if err != nil {
		panic(err)
	}
	defer file.Close()
	if _, err := io.Copy(file, resp.Body); err != nil {
		panic(err)
	}
	fmt.Println("Saved embossment.stl")
}