Arawa PDF API

#!/usr/bin/env bash
set -euo pipefail

BASE="https://arawapdf.com/v1"
TOOL="compress"
AUTH="Authorization: Bearer ${ARAWA_API_KEY}"

# 1) Start — create the task.
TASK_ID=$(curl -fsS -X POST "${BASE}/tools/${TOOL}/start" \
  -H "${AUTH}" | python3 -c "import sys,json; print(json.load(sys.stdin)['taskId'])")

# 2) Upload — multipart field name MUST be "files". Repeat -F to add more.
curl -fsS -X POST "${BASE}/tools/${TOOL}/${TASK_ID}/upload" \
  -H "${AUTH}" \
  -F "files=@input.pdf;type=application/pdf"

# 3) Process — pass tool params as JSON under "params".
curl -fsS -X POST "${BASE}/tools/${TOOL}/${TASK_ID}/process" \
  -H "${AUTH}" \
  -H "Content-Type: application/json" \
  -d '{ "params": { "level": "recommended" } }'

# 4) Poll status until it is "success" (or fail on "error").
while :; do
  STATUS=$(curl -fsS "${BASE}/tools/${TOOL}/${TASK_ID}/status" \
    -H "${AUTH}" | python3 -c "import sys,json; print(json.load(sys.stdin)['status'])")
  case "${STATUS}" in
    success) break ;;
    error)   echo "Processing failed." >&2; exit 1 ;;
    *)       sleep 2 ;;
  esac
done

# 5) Download — stream the result to disk.
curl -fsS -o compressed.pdf "${BASE}/tools/${TOOL}/${TASK_ID}/download" \
  -H "${AUTH}"

// quickstart.mjs — run: node quickstart.mjs  (Node 18+)
import { readFile, writeFile } from "node:fs/promises";

const BASE = "https://arawapdf.com/v1";
const TOOL = "compress";
const API_KEY = process.env.ARAWA_API_KEY;
const authHeaders = { Authorization: `Bearer ${API_KEY}` };

// Throw the normalized error envelope on any non-2xx response.
async function ok(res) {
  if (res.ok) return res;
  const body = await res.json().catch(() => ({}));
  throw new Error(`${res.status} ${body.code ?? body.error}: ${body.message}`);
}

async function compress(inputPath, outputPath) {
  // 1) Start.
  const { taskId } = await ok(
    await fetch(`${BASE}/tools/${TOOL}/start`, { method: "POST", headers: authHeaders }),
  ).then((r) => r.json());

  // 2) Upload — multipart field name is "files".
  const bytes = await readFile(inputPath);
  const form = new FormData();
  form.append("files", new Blob([bytes], { type: "application/pdf" }), "input.pdf");
  await ok(
    await fetch(`${BASE}/tools/${TOOL}/${taskId}/upload`, {
      method: "POST",
      headers: authHeaders, // do NOT set Content-Type; fetch adds the boundary
      body: form,
    }),
  );

  // 3) Process — params go under "params".
  await ok(
    await fetch(`${BASE}/tools/${TOOL}/${taskId}/process`, {
      method: "POST",
      headers: { ...authHeaders, "Content-Type": "application/json" },
      body: JSON.stringify({ params: { level: "recommended" } }),
    }),
  );

  // 4) Poll status every 2s until success.
  for (;;) {
    const { status } = await ok(
      await fetch(`${BASE}/tools/${TOOL}/${taskId}/status`, { headers: authHeaders }),
    ).then((r) => r.json());
    if (status === "success") break;
    if (status === "error") throw new Error("Processing failed");
    await new Promise((r) => setTimeout(r, 2000));
  }

  // 5) Download — save the bytes.
  const out = await ok(
    await fetch(`${BASE}/tools/${TOOL}/${taskId}/download`, { headers: authHeaders }),
  );
  await writeFile(outputPath, Buffer.from(await out.arrayBuffer()));
}

await compress("input.pdf", "compressed.pdf");

# quickstart.py — run: python quickstart.py  (pip install requests)
import os
import time
import requests

BASE = "https://arawapdf.com/v1"
TOOL = "compress"
AUTH = {"Authorization": f"Bearer {os.environ['ARAWA_API_KEY']}"}


def raise_for_envelope(resp: requests.Response) -> requests.Response:
    """Raise with the normalized error envelope on any non-2xx response."""
    if resp.ok:
        return resp
    try:
        body = resp.json()
    except ValueError:
        body = {}
    code = body.get("code") or body.get("error") or ""
    raise RuntimeError(f"{resp.status_code} {code}: {body.get('message')}")


def compress(input_path: str, output_path: str) -> None:
    # 1) Start.
    started = raise_for_envelope(
        requests.post(f"{BASE}/tools/{TOOL}/start", headers=AUTH)
    ).json()
    task_id = started["taskId"]

    # 2) Upload — the multipart field name must be "files".
    with open(input_path, "rb") as fh:
        files = {"files": ("input.pdf", fh, "application/pdf")}
        raise_for_envelope(
            requests.post(f"{BASE}/tools/{TOOL}/{task_id}/upload", headers=AUTH, files=files)
        )

    # 3) Process — tool params live under "params".
    raise_for_envelope(
        requests.post(
            f"{BASE}/tools/{TOOL}/{task_id}/process",
            headers={**AUTH, "Content-Type": "application/json"},
            json={"params": {"level": "recommended"}},
        )
    )

    # 4) Poll status every 2s until success.
    while True:
        status = raise_for_envelope(
            requests.get(f"{BASE}/tools/{TOOL}/{task_id}/status", headers=AUTH)
        ).json()["status"]
        if status == "success":
            break
        if status == "error":
            raise RuntimeError("Processing failed")
        time.sleep(2)

    # 5) Download — stream the bytes to disk.
    with requests.get(
        f"{BASE}/tools/{TOOL}/{task_id}/download", headers=AUTH, stream=True
    ) as out:
        raise_for_envelope(out)
        with open(output_path, "wb") as dest:
            for chunk in out.iter_content(chunk_size=64 * 1024):
                dest.write(chunk)


if __name__ == "__main__":
    compress("input.pdf", "compressed.pdf")

curl -X POST https://arawapdf.com/v1/tools/compress/start \
  -H "Authorization: Bearer $ARAWA_API_KEY"

const r = await fetch(`${BASE}/tools/${tool}/start`, {
  method: "POST",
  headers: { Authorization: `Bearer ${apiKey}` },
});
const { taskId, status } = await r.json();

r = requests.post(f"{BASE}/tools/{tool}/start", headers=auth)
task_id = r.json()["taskId"]

# Repeat -F "files=@..." for up to 50 files in one call.
curl -X POST https://arawapdf.com/v1/tools/merge/$TASK_ID/upload \
  -H "Authorization: Bearer $ARAWA_API_KEY" \
  -F "files=@chapter-1.pdf" \
  -F "files=@chapter-2.pdf"

const form = new FormData();
form.append("files", new Blob([bytes], { type: "application/pdf" }), "input.pdf");
await fetch(`${BASE}/tools/${tool}/${taskId}/upload`, {
  method: "POST",
  headers: { Authorization: `Bearer ${apiKey}` }, // no Content-Type!
  body: form,
});

with open("input.pdf", "rb") as fh:
    files = {"files": ("input.pdf", fh, "application/pdf")}
    requests.post(f"{BASE}/tools/{tool}/{task_id}/upload", headers=auth, files=files)

curl -X POST https://arawapdf.com/v1/tools/compress/$TASK_ID/process \
  -H "Authorization: Bearer $ARAWA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "params": { "level": "recommended" } }'

await fetch(`${BASE}/tools/${tool}/${taskId}/process`, {
  method: "POST",
  headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" },
  body: JSON.stringify({ params: { level: "recommended" } }),
});

requests.post(
    f"{BASE}/tools/{tool}/{task_id}/process",
    headers={**auth, "Content-Type": "application/json"},
    json={"params": {"level": "recommended"}},
)

# Poll every 1–2s until status is "success" or "error".
curl https://arawapdf.com/v1/tools/compress/$TASK_ID/status \
  -H "Authorization: Bearer $ARAWA_API_KEY"

for (;;) {
  const { status } = await fetch(
    `${BASE}/tools/${tool}/${taskId}/status`,
    { headers: { Authorization: `Bearer ${apiKey}` } },
  ).then((r) => r.json());
  if (status === "success") break;
  if (status === "error") throw new Error("Processing failed");
  await new Promise((r) => setTimeout(r, 2000));
}

while True:
    status = requests.get(
        f"{BASE}/tools/{tool}/{task_id}/status", headers=auth
    ).json()["status"]
    if status == "success":
        break
    if status == "error":
        raise RuntimeError("Processing failed")
    time.sleep(2)

curl -L https://arawapdf.com/v1/tools/compress/$TASK_ID/download \
  -H "Authorization: Bearer $ARAWA_API_KEY" \
  -o compressed.pdf

const out = await fetch(`${BASE}/tools/${tool}/${taskId}/download`, {
  headers: { Authorization: `Bearer ${apiKey}` },
});
await writeFile("compressed.pdf", Buffer.from(await out.arrayBuffer()));

with requests.get(
    f"{BASE}/tools/{tool}/{task_id}/download", headers=auth, stream=True
) as out:
    with open("compressed.pdf", "wb") as dest:
        for chunk in out.iter_content(chunk_size=64 * 1024):
            dest.write(chunk)

curl -X DELETE https://arawapdf.com/v1/tools/compress/$TASK_ID \
  -H "Authorization: Bearer $ARAWA_API_KEY"

await fetch(`${BASE}/tools/${tool}/${taskId}`, {
  method: "DELETE",
  headers: { Authorization: `Bearer ${apiKey}` },
});

requests.delete(f"{BASE}/tools/{tool}/{task_id}", headers=auth)

# Every response carries your current budget — inspect without doing work.
curl -sI https://arawapdf.com/v1/openapi.json | grep -i x-ratelimit
# x-ratelimit-limit: 120
# x-ratelimit-remaining: 119
# x-ratelimit-reset: 1717369200   (absolute UNIX epoch seconds)

async function withRateLimitRetry(doRequest) {
  for (let attempt = 0; attempt < 5; attempt++) {
    const res = await doRequest();
    if (res.status !== 429) return res;

    // Prefer Retry-After; fall back to the absolute reset header.
    const retryAfter = Number(res.headers.get("retry-after"));
    const reset = Number(res.headers.get("x-ratelimit-reset"));
    const waitSec = retryAfter > 0
      ? retryAfter
      : Math.max(1, reset - Math.floor(Date.now() / 1000));

    await new Promise((r) => setTimeout(r, waitSec * 1000));
  }
  throw new Error("Rate limit: exhausted retries");
}