{
  "caseFile": {
    // Case file configuration (see below)
  }
}

{
  "caseFile": {
    "title": "Simple Agreement",
    "signers": [
      {
        "name": "John Doe",
        "email": "[email protected]"
      }
    ],
    "documents": [
      {
        "title": "Agreement Document",
        "name": "agreement.pdf"
      }
    ]
  }
}

{
  "caseFile": {
    "title": "Commercial Agreement 2025",
    "senderName": "Acme Signing Department",
    "language": "en",
    "reference": "CONTRACT-2025-001",
    "metaData": "Q4 Commercial Contract",
    "sensitiveData": false,
    "disableNotificationsOwner": false,
    "disableEmailAttachments": false,
    "signOnMeeting": false,
    "sendAt": null,
    "expireAt": null,
    "visibilityMode": 0,
    "signers": [
      {
        "name": "John Doe",
        "email": "[email protected]",
        "role": "Client Signer",
        "language": "en",
        "socialSecurityNumberPlain": null,
        "ssnType": "dk:cpr",
        "vatin": null,
        "signOrder": 0,
        "onBehalfOf": "Acme Corporation",
        "accessControl": true,
        "storeAsContact": true,
        "successUrl": "https://example.com/success",
        "failUrl": "https://example.com/failure",
        "emailFormat": "html",
        "emailSubject": "Please sign the commercial agreement",
        "emailText": "Dear John, please review and sign the attached commercial agreement.",
        "reminderInterval": 3,
        "reminderEmailSubject": "Reminder: Please sign the commercial agreement",
        "reminderEmailText": "This is a friendly reminder to sign the agreement.",
        "completedEmailSubject": "Thank you for signing",
        "completedEmailText": "The agreement has been completed successfully.",
        "activeAt": null,
        "expireAt": null,
        "enableInsecureSigning": false,
        "insecureSigningMethods": [],
        "secureSigningMethods": [
          "mitid.dk",
          "bankid_se",
          "bankid_no",
          "itsme.be",
          "ftn.fi",
          "eid.belgium.be",
          "passport-reader.eident.dk",
          "ausweisapp.bund.de",
          "qes.personal.mitid.dk",
          "qes.erhverv.mitid.dk"
        ]
      },
      {
        "name": "Jane Smith",
        "email": "[email protected]",
        "role": "Company Signer",
        "channel": "eboks",
        "cpr": "1234567890",
        "language": "en",
        "signOrder": 1,
        "onBehalfOf": "Company Ltd",
        "accessControl": false,
        "storeAsContact": true,
        "emailFormat": "text",
        "reminderInterval": 2
      }
    ],
    "ccRecipients": [
      {
        "name": "John CC",
        "email": "[email protected]",
        "storeAsContact": false
      },
      {
        "name": "Jane CC",
        "email": "[email protected]",
        "storeAsContact": true
      }
    ],
    "documents": [
      {
        "title": "Main Contract",
        "name": "contract.pdf",
        "signable": true,
        "roles": [
          "Client Signer",
          "Company Signer"
        ],
        "documentOrder": 0,
        "metaData": "Primary contract document"
      },
      {
        "title": "Terms and Conditions",
        "name": "terms.pdf",
        "signable": false,
        "metaData": "Standard T&C attachment"
      }
    ]
  }
}

import { readFileSync } from "fs";

// 1. Build CaseFile JSON data
const caseFileData = {caseFile: {
    title: "My Contract",
    signers: [
      { name: "John Doe", email: "[email protected]" },
      { name: "Jane Doe", email: "[email protected]" }
    ],
    documents: [
      { title: "Contract", name: "contract.pdf" }, //name matches first uploaded doc
      { title: "Appendix", name: "appendix.pdf" }  //name matches second uploaded doc
    ]
  }};

// 2. Load files directly into File objects
const contractPdfBytes = readFileSync("./contract.pdf");
const appendixPdfBytes = readFileSync("./appendix.pdf");

const contractFile = new File([contractPdfBytes], "contract.pdf", {
  type: "application/pdf"
});

const appendixFile = new File([appendixPdfBytes], "appendix.pdf", {
  type: "application/pdf"
});

// 3. FormData
const formData = new FormData();

// JSON data field
formData.append(
  "data",
  JSON.stringify(caseFileData) // <-- Append the JSON as a simple string
);

// Add PDF files
formData.append("files", contractFile, contractFile.name);
formData.append("files", appendixFile, appendixFile.name);

// 4. POST request
const response = await fetch(
  "https://sandbox.penneo.com/send/api/v1/casefiles/20251022/create",
  {
    method: "POST",
    headers: {
      "X-Auth-Token": "YOUR_TOKEN_HERE" // Retrieve the JWT Token based on https://developer.penneo.com/docs/using-oauth#api-keys-grant
    },
    body: formData
  }
);

// 5. Handle Penneo response
if (!response.ok) {
  console.error("Status code:", await response.status);
  console.error("Error:", await response.text());
  process.exit(1);
}

console.log("Success:", await response.json());

import { readFileSync } from "fs";

const BASE_URL = "https://sandbox.penneo.com/send/api/v1";
const TOKEN = "YOUR_TOKEN_HERE"; // Retrieve the JWT Token based on https://developer.penneo.com/docs/using-oauth#api-keys-grant

const CREATE_CONCURRENCY = 4; // create requests in flight at the same time
const MAX_CREATE_ATTEMPTS = 5; // per case file, counting the ones rejected with 429
const POLL_INTERVAL_SECONDS = 3; // stays within 20 status checks per job per minute
const MAX_STATUS_ROUNDS = 200; // about 10 minutes
const STATUS_BATCH_SIZE = 500; // jobs per batch status request

// 1. The case files to create, each with the PDF files its documents name.
const caseFiles = [
  {
    data: {
      caseFile: {
        title: "Contract - John Doe",
        signers: [{ name: "John Doe", email: "[email protected]" }],
        documents: [{ title: "Contract", name: "contract-john.pdf" }]
      }
    },
    files: ["./contract-john.pdf"]
  },
  {
    data: {
      caseFile: {
        title: "Contract - Jane Doe",
        signers: [{ name: "Jane Doe", email: "[email protected]" }],
        documents: [{ title: "Contract", name: "contract-jane.pdf" }]
      }
    },
    files: ["./contract-jane.pdf"]
  }
];

const sleep = (seconds) => new Promise((resolve) => setTimeout(resolve, seconds * 1000));
// After a 429: Retry-After + 1 seconds, so the next attempt lands in a fresh rate limit window.
const secondsToWait = (response) => (Number(response.headers.get("Retry-After")) || 60) + 1;

function buildFormData(item) {
  const formData = new FormData();
  formData.append("data", JSON.stringify(item.data));
  for (const path of item.files) {
    const name = path.split("/").pop();
    formData.append("files", new File([readFileSync(path)], name, { type: "application/pdf" }), name);
  }
  return formData;
}

// 2. Create one case file, waiting out any 429.
async function createCaseFile(item) {
  const title = item.data.caseFile.title;

  for (let attempt = 1; attempt <= MAX_CREATE_ATTEMPTS; attempt++) {
    const response = await fetch(`${BASE_URL}/casefiles/20251022/create`, {
      method: "POST",
      headers: { "X-Auth-Token": TOKEN },
      body: buildFormData(item)
    });

    if (response.status === 429) {
      const wait = secondsToWait(response);
      console.warn(`[${title}] create rate limited (attempt ${attempt}/${MAX_CREATE_ATTEMPTS}), retrying in ${wait}s`);
      await sleep(wait);
      continue;
    }

    if (!response.ok) {
      throw new Error(`[${title}] create failed with ${response.status}: ${await response.text()}`);
    }

    const { jobs } = await response.json();
    // Store uuid and payloadHash now: they are returned only once.
    console.log(`[${title}] job created: ${jobs[0].uuid}`);
    return { title, uuid: jobs[0].uuid, payloadHash: jobs[0].payloadHash };
  }

  throw new Error(`[${title}] still rate limited after ${MAX_CREATE_ATTEMPTS} create attempts`);
}

// 3. Check the status of every job until none is pending or processing.
// Returns, per job uuid, { result } on success or { error } on failure.
async function waitForJobs(jobs) {
  const outcomes = new Map();
  const pending = new Map(jobs.map((job) => [job.uuid, job]));
  const notBefore = new Map(); // rate_limited jobs: when they can be checked again

  for (let round = 1; round <= MAX_STATUS_ROUNDS && pending.size > 0; round++) {
    const due = [...pending.values()].filter((job) => (notBefore.get(job.uuid) ?? 0) <= Date.now());

    for (let start = 0; start < due.length; start += STATUS_BATCH_SIZE) {
      const chunk = due.slice(start, start + STATUS_BATCH_SIZE);
      const response = await fetch(`${BASE_URL}/queue/public/status/batch`, {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        // Send only uuid and payloadHash: the endpoint rejects any other property.
        body: JSON.stringify({ jobs: chunk.map(({ uuid, payloadHash }) => ({ uuid, payloadHash })) })
      });

      if (response.status === 429) {
        // Over the per-IP limit: wait, then check the rest in the next round.
        await sleep(secondsToWait(response));
        break;
      }

      if (!response.ok) {
        throw new Error(`Status check failed with ${response.status}: ${await response.text()}`);
      }

      const { jobs: entries } = await response.json();
      for (const entry of entries) {
        if (entry.status === "rate_limited") {
          notBefore.set(entry.uuid, Date.now() + (entry.retryAfter + 1) * 1000);
          continue;
        }

        if (entry.status === "not_found") {
          outcomes.set(entry.uuid, { error: "job not found" });
        } else if (entry.job.jobStatus === "completed") {
          outcomes.set(entry.uuid, { result: entry.job.result });
        } else if (entry.job.jobStatus === "pending" || entry.job.jobStatus === "processing") {
          continue;
        } else {
          outcomes.set(entry.uuid, { error: `job ${entry.job.jobStatus}: ${entry.job.errorMessage}` });
        }
        pending.delete(entry.uuid);
      }
    }

    if (pending.size > 0) {
      await sleep(POLL_INTERVAL_SECONDS);
    }
  }

  for (const uuid of pending.keys()) {
    outcomes.set(uuid, { error: `job not finished after ${MAX_STATUS_ROUNDS} rounds` });
  }
  return outcomes;
}

// 4. Create the case files, CREATE_CONCURRENCY at a time: when one request finishes, the next one starts.
const created = [];
const queue = [...caseFiles];
async function createNext() {
  while (queue.length > 0) {
    const item = queue.shift();
    try {
      created.push(await createCaseFile(item));
    } catch (error) {
      console.error(error.message);
    }
  }
}
await Promise.all(Array.from({ length: CREATE_CONCURRENCY }, createNext));

// 5. Wait for all the jobs, then print each result.
const outcomes = await waitForJobs(created);

for (const { title, uuid } of created) {
  const { result, error } = outcomes.get(uuid);
  if (error) {
    console.error(`[${title}] ${error}`);
    continue;
  }

  console.log(`[${title}] case file ${result.data.caseFile.id} created`);
  for (const link of result.data.signingLinks) {
    console.log(`[${title}]   ${link.name} (${link.role}): ${link.signingLink}`);
  }
}

{
  "jobs": [
    {
      "uuid": "123e4567-e89b-12d3-a456-426614174000",
      "payloadHash": "3a7bd3e2360a3d485f2a5f4d8e6f1e8b9c6d5e4f3a2b1c0d9e8f7a6b5c4d3e2f",
      "status": "found",
      "rateLimit": { "limit": 20, "remaining": 16, "reset": 42 },
      "job": {
        "uuid": "123e4567-e89b-12d3-a456-426614174000",
        "type": "etl-queue",
        "payloadHash": "3a7bd3e2360a3d485f2a5f4d8e6f1e8b9c6d5e4f3a2b1c0d9e8f7a6b5c4d3e2f",
        "jobStatus": "completed",
        "errorMessage": null,
        "retries": 0,
        "maxRetries": 0,
        "createdAt": "2026-10-14T07:07:51.130Z",
        "updatedAt": "2026-10-14T07:07:54.873Z",
        "result": {
          "data": {
            "caseFile": { "id": 1234 },
            "signingLinks": [
              {
                "name": "John Doe",
                "role": "signer",
                "signerId": 5678,
                "signOrder": [0],
                "signingLink": "https://sandbox.penneo.com/signing/AAAAA-BBBBB-CCCCC-DDDDD-EEEEE-FFFFF"
              }
            ]
          },
          "errors": null,
          "success": true
        }
      }
    },
    {
      "uuid": "7e47477c-e543-43ad-90a9-50e6abe9abdc",
      "payloadHash": "1d3644ac95ec37b073d9d8be2dca5da66f36533397a88c0462dcc219d049db70",
      "status": "found",
      "rateLimit": { "limit": 20, "remaining": 19, "reset": 60 },
      "job": {
        "uuid": "7e47477c-e543-43ad-90a9-50e6abe9abdc",
        "type": "etl-queue",
        "payloadHash": "1d3644ac95ec37b073d9d8be2dca5da66f36533397a88c0462dcc219d049db70",
        "jobStatus": "completed",
        "errorMessage": null,
        "retries": 0,
        "maxRetries": 0,
        "createdAt": "2026-10-14T07:08:41.343Z",
        "updatedAt": "2026-10-14T07:08:45.465Z",
        "result": {
          "data": {
            "caseFile": { "id": 1235 },
            "signingLinks": [
              {
                "name": "Jane Doe",
                "role": "signer",
                "signerId": 5679,
                "signOrder": [0],
                "signingLink": "https://sandbox.penneo.com/signing/GGGGG-HHHHH-IIIII-JJJJJ-KKKKK-LLLLL"
              }
            ]
          },
          "errors": null,
          "success": true
        }
      }
    }
  ]
}

// JavaScript example to get Unix timestamp
const timestamp = Math.floor(Date.now() / 1000);