API 参考文档

import os
import requests
from PIL import Image   # pip install Pillow

API_KEY = "sk-ir-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
BASE = "https://imgroute.com/api/v1"
HEADERS = {"X-API-Key": API_KEY}

def upload(file_path: str) -> str:
    size = os.path.getsize(file_path)
    with Image.open(file_path) as im:
        width, height = im.size

    # Step 1：申请预签名（不传 album_id 即上传到默认相册）
    r = requests.post(f"{BASE}/upload", headers=HEADERS, json={
        "file_name": os.path.basename(file_path),
        "file_size": size,
        "mime_type": "image/jpeg",
        "width": width,
        "height": height
    }).json()
    if not r["success"]:
        raise RuntimeError(r.get("error"))
    info = r["data"]

    # Step 2：以 multipart 方式 POST 文件到 upload_url
    with open(file_path, "rb") as f:
        resp = requests.post(
            info["upload_url"],
            files={"file": (os.path.basename(file_path), f, "image/jpeg")},
            timeout=60
        ).json()
    if not resp.get("success"):
        raise RuntimeError(resp.get("error"))

    return info["cdn_url"]

print(upload("./cat.jpg"))

import fs from "node:fs";
import path from "node:path";
import sizeOf from "image-size";   // npm i image-size

const API_KEY = "sk-ir-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";
const BASE = "https://imgroute.com/api/v1";

async function upload(filePath) {
  const size = fs.statSync(filePath).size;
  const { width, height } = sizeOf(filePath);
  const name = path.basename(filePath);

  // Step 1：预签名（不传 album_id 即上传到默认相册）
  const presign = await fetch(`${BASE}/upload`, {
    method: "POST",
    headers: {
      "X-API-Key": API_KEY,
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
      file_name: name,
      file_size: size,
      mime_type: "image/jpeg",
      width, height
    })
  }).then(r => r.json());
  if (!presign.success) throw new Error(presign.error);

  // Step 2：以 multipart/form-data POST 到 upload_url
  const form = new FormData();
  const buf = fs.readFileSync(filePath);
  form.append("file", new Blob([buf], { type: "image/jpeg" }), name);
  const r2 = await fetch(presign.data.upload_url, {
    method: "POST",
    body: form
  }).then(r => r.json());
  if (!r2.success) throw new Error(r2.error);

  return presign.data.cdn_url;
}

upload("./cat.jpg").then(console.log);

# 列出相册与图片
curl -G "https://imgroute.com/api/v1/list" \
  -H "X-API-Key: sk-ir-xxxxxxxx" \
  --data-urlencode "album_id=alb_xxx" \
  --data-urlencode "page=1"

# 删除一张图片
curl -X DELETE "https://imgroute.com/api/v1/delete?img=A1b2C3d" \
  -H "X-API-Key: sk-ir-xxxxxxxx"

# 删除一个相册（如有子相册将递归删除）
curl -X DELETE "https://imgroute.com/api/v1/delete?album=alb_xxx" \
  -H "X-API-Key: sk-ir-xxxxxxxx"

# 创建相册
curl -X POST https://imgroute.com/api/v1/create_album \
  -H "X-API-Key: sk-ir-xxxxxxxx" \
  -H "Content-Type: application/json" \
  -d '{"name": "新相册", "parent_album": null}'

// 依赖：org.json（JSON 解析）
import java.io.*;
import java.net.URI;
import java.net.http.*;
import java.nio.file.*;
import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import org.json.JSONObject;

public class Upload {
    static final String API_KEY = "sk-ir-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";
    static final String BASE = "https://imgroute.com/api/v1";

    public static String upload(String filePath) throws Exception {
        Path p = Path.of(filePath);
        long size = Files.size(p);
        BufferedImage img = ImageIO.read(p.toFile());
        int width = img.getWidth(), height = img.getHeight();
        HttpClient client = HttpClient.newHttpClient();

        // Step 1：申请预签名（不传 album_id 即上传到默认相册）
        String body = new JSONObject()
            .put("file_name", p.getFileName().toString())
            .put("file_size", size)
            .put("mime_type", "image/jpeg")
            .put("width", width)
            .put("height", height)
            .toString();
        HttpRequest req1 = HttpRequest.newBuilder()
            .uri(URI.create(BASE + "/upload"))
            .header("X-API-Key", API_KEY)
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(body))
            .build();
        JSONObject r1 = new JSONObject(
            client.send(req1, HttpResponse.BodyHandlers.ofString()).body());
        if (!r1.getBoolean("success")) throw new RuntimeException(r1.optString("error"));
        JSONObject info = r1.getJSONObject("data");

        // Step 2：multipart/form-data 上传
        String boundary = "----Boundary" + System.currentTimeMillis();
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        out.write(("--" + boundary + "\r\n").getBytes());
        out.write(("Content-Disposition: form-data; name=\"file\"; filename=\""
            + p.getFileName() + "\"\r\n").getBytes());
        out.write("Content-Type: image/jpeg\r\n\r\n".getBytes());
        out.write(Files.readAllBytes(p));
        out.write(("\r\n--" + boundary + "--\r\n").getBytes());

        HttpRequest req2 = HttpRequest.newBuilder()
            .uri(URI.create(info.getString("upload_url")))
            .header("Content-Type", "multipart/form-data; boundary=" + boundary)
            .POST(HttpRequest.BodyPublishers.ofByteArray(out.toByteArray()))
            .build();
        JSONObject r2 = new JSONObject(
            client.send(req2, HttpResponse.BodyHandlers.ofString()).body());
        if (!r2.optBoolean("success")) throw new RuntimeException(r2.optString("error"));

        return info.getString("cdn_url");
    }

    public static void main(String[] args) throws Exception {
        System.out.println(upload("./cat.jpg"));
    }
}

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "image"
    _ "image/jpeg"
    "io"
    "mime/multipart"
    "net/http"
    "os"
    "path/filepath"
)

const (
    apiKey = "sk-ir-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
    base   = "https://imgroute.com/api/v1"
)

type presignResp struct {
    Success bool   `json:"success"`
    Error   string `json:"error"`
    Data    struct {
        UploadURL string `json:"upload_url"`
        CdnURL    string `json:"cdn_url"`
    } `json:"data"`
}

func Upload(filePath string) (string, error) {
    info, err := os.Stat(filePath)
    if err != nil { return "", err }

    f, err := os.Open(filePath)
    if err != nil { return "", err }
    defer f.Close()
    cfg, _, err := image.DecodeConfig(f)
    if err != nil { return "", err }
    f.Seek(0, 0)

    // Step 1：申请预签名（不传 album_id 即上传到默认相册）
    payload, _ := json.Marshal(map[string]interface{}{
        "file_name": filepath.Base(filePath),
        "file_size": info.Size(),
        "mime_type": "image/jpeg",
        "width":     cfg.Width,
        "height":    cfg.Height,
    })
    req, _ := http.NewRequest("POST", base+"/upload", bytes.NewReader(payload))
    req.Header.Set("X-API-Key", apiKey)
    req.Header.Set("Content-Type", "application/json")
    resp, err := http.DefaultClient.Do(req)
    if err != nil { return "", err }
    defer resp.Body.Close()

    var pr presignResp
    json.NewDecoder(resp.Body).Decode(&pr)
    if !pr.Success { return "", fmt.Errorf("presign: %s", pr.Error) }

    // Step 2：multipart 上传
    var body bytes.Buffer
    w := multipart.NewWriter(&body)
    fw, _ := w.CreateFormFile("file", filepath.Base(filePath))
    io.Copy(fw, f)
    w.Close()

    req2, _ := http.NewRequest("POST", pr.Data.UploadURL, &body)
    req2.Header.Set("Content-Type", w.FormDataContentType())
    resp2, err := http.DefaultClient.Do(req2)
    if err != nil { return "", err }
    defer resp2.Body.Close()

    return pr.Data.CdnURL, nil
}

func main() {
    url, err := Upload("./cat.jpg")
    if err != nil { panic(err) }
    fmt.Println(url)
}

<?php
$apiKey = "sk-ir-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";
$base   = "https://imgroute.com/api/v1";

function upload($filePath) {
    global $apiKey, $base;

    $size = filesize($filePath);
    [$width, $height] = getimagesize($filePath);

    // Step 1：申请预签名（不传 album_id 即上传到默认相册）
    $ch = curl_init($base . "/upload");
    curl_setopt_array($ch, [
        CURLOPT_POST           => true,
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_HTTPHEADER     => [
            "X-API-Key: $apiKey",
            "Content-Type: application/json",
        ],
        CURLOPT_POSTFIELDS     => json_encode([
            "file_name" => basename($filePath),
            "file_size" => $size,
            "mime_type" => "image/jpeg",
            "width"     => $width,
            "height"    => $height,
        ]),
    ]);
    $r1 = json_decode(curl_exec($ch), true);
    curl_close($ch);
    if (empty($r1["success"])) throw new Exception($r1["error"] ?? "presign failed");

    // Step 2：multipart/form-data 上传
    $ch = curl_init($r1["data"]["upload_url"]);
    curl_setopt_array($ch, [
        CURLOPT_POST           => true,
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_POSTFIELDS     => [
            "file" => new CURLFile($filePath, "image/jpeg", basename($filePath)),
        ],
    ]);
    $r2 = json_decode(curl_exec($ch), true);
    curl_close($ch);
    if (empty($r2["success"])) throw new Exception($r2["error"] ?? "upload failed");

    return $r1["data"]["cdn_url"];
}

echo upload("./cat.jpg") . PHP_EOL;

require "json"
require "net/http"
require "uri"
require "fastimage"   # gem install fastimage

API_KEY = "sk-ir-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
BASE    = "https://imgroute.com/api/v1"

def upload(file_path)
  size = File.size(file_path)
  width, height = FastImage.size(file_path)

  # Step 1：申请预签名（不传 album_id 即上传到默认相册）
  uri = URI("#{BASE}/upload")
  req = Net::HTTP::Post.new(uri,
    "X-API-Key"    => API_KEY,
    "Content-Type" => "application/json")
  req.body = {
    file_name: File.basename(file_path),
    file_size: size,
    mime_type: "image/jpeg",
    width: width,
    height: height
  }.to_json
  res = Net::HTTP.start(uri.host, uri.port, use_ssl: true) { |h| h.request(req) }
  r1 = JSON.parse(res.body)
  raise r1["error"] unless r1["success"]

  # Step 2：multipart/form-data 上传
  upload_uri = URI(r1["data"]["upload_url"])
  boundary = "----Ruby#{Time.now.to_i}"
  body = String.new(encoding: "ASCII-8BIT")
  body << "--#{boundary}\r\n"
  body << %(Content-Disposition: form-data; name="file"; filename="#{File.basename(file_path)}"\r\n)
  body << "Content-Type: image/jpeg\r\n\r\n"
  body << File.binread(file_path)
  body << "\r\n--#{boundary}--\r\n"

  req2 = Net::HTTP::Post.new(upload_uri,
    "Content-Type" => "multipart/form-data; boundary=#{boundary}")
  req2.body = body
  Net::HTTP.start(upload_uri.host, upload_uri.port, use_ssl: true) { |h| h.request(req2) }

  r1["data"]["cdn_url"]
end

puts upload("./cat.jpg")

// .NET 6+，依赖：SixLabors.ImageSharp
using System;
using System.IO;
using System.Net.Http;
using System.Net.Http.Json;
using System.Text.Json;
using System.Threading.Tasks;
using SixLabors.ImageSharp;

class Program
{
    const string ApiKey = "sk-ir-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";
    const string Base   = "https://imgroute.com/api/v1";

    static async Task<string> UploadAsync(string filePath)
    {
        long size = new FileInfo(filePath).Length;
        using var img = Image.Load(filePath);
        int width = img.Width, height = img.Height;

        using var client = new HttpClient();
        client.DefaultRequestHeaders.Add("X-API-Key", ApiKey);

        // Step 1：申请预签名（不传 album_id 即上传到默认相册）
        var payload = new {
            file_name = Path.GetFileName(filePath),
            file_size = size,
            mime_type = "image/jpeg",
            width, height
        };
        var presign = await client.PostAsJsonAsync($"{Base}/upload", payload);
        using var doc = JsonDocument.Parse(await presign.Content.ReadAsStringAsync());
        var root = doc.RootElement;
        if (!root.GetProperty("success").GetBoolean())
            throw new Exception(root.GetProperty("error").GetString());
        var data      = root.GetProperty("data");
        var uploadUrl = data.GetProperty("upload_url").GetString();
        var cdnUrl    = data.GetProperty("cdn_url").GetString();

        // Step 2：multipart/form-data 上传
        using var form = new MultipartFormDataContent();
        var fileContent = new ByteArrayContent(await File.ReadAllBytesAsync(filePath));
        fileContent.Headers.ContentType = new("image/jpeg");
        form.Add(fileContent, "file", Path.GetFileName(filePath));
        await client.PostAsync(uploadUrl, form);

        return cdnUrl!;
    }

    static async Task Main() => Console.WriteLine(await UploadAsync("./cat.jpg"));
}