Original downloads

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

const apiKey = process.env.EPOCHAL_API_KEY;
const imageId = "es_001_example";

// 1) Mint token
const mint = await fetch("https://epochalstock.com/api/v1/downloads", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${apiKey}`,
    "Content-Type": "application/json",
    Accept: "application/json",
  },
  body: JSON.stringify({ image_id: imageId }),
});
if (!mint.ok) {
  throw new Error(`mint ${mint.status}: ${await mint.text()}`);
}
const { data } = await mint.json();
const downloadUrl = data.download_url;

// 2) Fetch original — no Authorization header
const fileRes = await fetch(downloadUrl);
if (!fileRes.ok) {
  throw new Error(`download ${fileRes.status}`);
}
const buffer = Buffer.from(await fileRes.arrayBuffer());
await writeFile("image.jpg", buffer);

$apiKey = getenv('EPOCHAL_API_KEY');
$imageId = 'es_001_example';

// 1) Mint token
$ch = curl_init('https://epochalstock.com/api/v1/downloads');
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer ' . $apiKey,
        'Content-Type: application/json',
        'Accept: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode(['image_id' => $imageId], JSON_THROW_ON_ERROR),
    CURLOPT_TIMEOUT => 20,
]);
$raw = curl_exec($ch);
$status = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($status !== 201) {
    throw new RuntimeException('mint failed: ' . $raw);
}
$downloadUrl = json_decode($raw, true, 512, JSON_THROW_ON_ERROR)['data']['download_url'];

// 2) Binary GET — no API key
$ch = curl_init($downloadUrl);
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_FOLLOWLOCATION => true,
    CURLOPT_TIMEOUT => 120,
]);
$bytes = curl_exec($ch);
if ((int) curl_getinfo($ch, CURLINFO_HTTP_CODE) !== 200) {
    throw new RuntimeException('download failed');
}
file_put_contents('image.jpg', $bytes);

import os
import requests

api_key = os.environ["EPOCHAL_API_KEY"]
image_id = "es_001_example"

# 1) Mint token
mint = requests.post(
    "https://epochalstock.com/api/v1/downloads",
    headers={
        "Authorization": f"Bearer {api_key}",
        "Content-Type": "application/json",
        "Accept": "application/json",
    },
    json={"image_id": image_id},
    timeout=20,
)
mint.raise_for_status()
download_url = mint.json()["data"]["download_url"]

# 2) Binary GET — no API key
with requests.get(download_url, stream=True, timeout=120) as r:
    r.raise_for_status()
    with open("image.jpg", "wb") as f:
        for chunk in r.iter_content(chunk_size=1024 * 256):
            if chunk:
                f.write(chunk)

package main

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

func main() {
    apiKey := os.Getenv("EPOCHAL_API_KEY")
    body, _ := json.Marshal(map[string]string{"image_id": "es_001_example"})

    // 1) Mint token
    req, _ := http.NewRequest(http.MethodPost,
        "https://epochalstock.com/api/v1/downloads",
        bytes.NewReader(body))
    req.Header.Set("Authorization", "Bearer "+apiKey)
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("Accept", "application/json")

    client := &http.Client{Timeout: 20 * time.Second}
    res, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer res.Body.Close()
    var payload struct {
        Data struct {
            DownloadURL string `json:"download_url"`
        } `json:"data"`
    }
    if err := json.NewDecoder(res.Body).Decode(&payload); err != nil {
        panic(err)
    }

    // 2) Binary GET — no API key
    dlClient := &http.Client{Timeout: 120 * time.Second}
    dl, err := dlClient.Get(payload.Data.DownloadURL)
    if err != nil {
        panic(err)
    }
    defer dl.Body.Close()
    out, _ := os.Create("image.jpg")
    defer out.Close()
    io.Copy(out, dl.Body)
}

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

var apiKey = Environment.GetEnvironmentVariable("EPOCHAL_API_KEY");
using var client = new HttpClient { Timeout = TimeSpan.FromSeconds(20) };

// 1) Mint token
using var mintReq = new HttpRequestMessage(
    HttpMethod.Post,
    "https://epochalstock.com/api/v1/downloads");
mintReq.Headers.Authorization = new AuthenticationHeaderValue("Bearer", apiKey);
mintReq.Headers.Accept.ParseAdd("application/json");
mintReq.Content = new StringContent(
    """{"image_id":"es_001_example"}""",
    Encoding.UTF8,
    "application/json");

using var mintRes = await client.SendAsync(mintReq);
mintRes.EnsureSuccessStatusCode();
using var mintDoc = JsonDocument.Parse(await mintRes.Content.ReadAsStringAsync());
var downloadUrl = mintDoc.RootElement
    .GetProperty("data")
    .GetProperty("download_url")
    .GetString()!;

// 2) Binary GET — no API key
using var dlClient = new HttpClient { Timeout = TimeSpan.FromMinutes(2) };
using var fileRes = await dlClient.GetAsync(downloadUrl);
fileRes.EnsureSuccessStatusCode();
await using var fs = File.Create("image.jpg");
await fileRes.Content.CopyToAsync(fs);

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

api_key = ENV.fetch("EPOCHAL_API_KEY")

# 1) Mint token
uri = URI("https://epochalstock.com/api/v1/downloads")
req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer #{api_key}"
req["Content-Type"] = "application/json"
req["Accept"] = "application/json"
req.body = { image_id: "es_001_example" }.to_json

mint = Net::HTTP.start(uri.host, uri.port, use_ssl: true) do |http|
  http.request(req)
end
raise "mint failed: #{mint.code}" unless mint.code.to_i == 201
download_url = JSON.parse(mint.body).dig("data", "download_url")

# 2) Binary GET — no API key
dl_uri = URI(download_url)
Net::HTTP.start(dl_uri.host, dl_uri.port, use_ssl: true) do |http|
  resp = http.get(dl_uri.request_uri)
  raise "download failed: #{resp.code}" unless resp.code.to_i == 200
  File.binwrite("image.jpg", resp.body)
end