How to Send a PDF for Signature Without Creating a Template

Most e-signature APIs make you create a template before you can send anything for signature. You upload your PDF, define your fields, save it as a template, and then create a signing request from that template.

That workflow makes sense when you're sending the same document over and over. Employment contracts, NDAs, vendor agreements. Anything you're going to use more than a few times deserves a template.

But sometimes you just need to send a one-off document. A custom proposal. A legal agreement that's different every time. A quick internal sign-off that you'll never repeat. Creating a template for a document you're only going to use once adds friction and clutters up your workspace.

Firma.dev now supports one-off signing requests. You can upload a PDF directly, define your recipients and fields inline, and send it for signature without ever creating a template. This post walks through how it works.

When Templates Make Sense (And When They Don't)

Templates are the right choice when you're sending the same document structure repeatedly. If you've got an offer letter that goes out to every new hire, or an NDA that every vendor signs, or a monthly invoice that always has the same fields in the same places, templates save you time. You set them up once and reuse them forever.

But templates become overhead when the document is unique. A custom proposal with pricing that changes for every prospect. A settlement agreement that gets negotiated and revised before signing. An internal approval form that's different depending on the situation.

For these cases, creating a template just to use it once is busywork. You end up with a workspace full of single-use templates that you'll never touch again.

The One-Off Signing Request Workflow

The one-off workflow skips the template step entirely. Here's what it looks like:

1. Take your PDF and base64-encode it

2. Define your recipients inline (name, email, whether they're a signer or CC'd, signing order if applicable)

3. Define your fields inline (signature boxes, text fields, dates, checkboxes, whatever you need) with their positions on the page

4. Call the create endpoint or the atomic create-and-send endpoint

5. Done. No template required.

The signing request works exactly like a template-based one. Your recipients get notified, they sign, you get the completed document and audit trail. The only difference is that you didn't have to create a template first.

Example: Sending a Custom Proposal

Let's say you're a SaaS company sending a custom pricing proposal to a prospect. The proposal is a one-page PDF with their company name, the pricing you've negotiated, and a signature line.

Here's what the API call looks like using the atomic create-and-send endpoint:

{
  "name": "Proposal - Acme Corp",
  "document": "JVBERi0xLjQK...",
  "recipients": [
    {
      "id": "temp_signer_1",
      "first_name": "Jane",
      "last_name": "Smith",
      "email": "jane@acmecorp.com",
      "designation": "Signer",
      "order": 1
    }
  ],
  "fields": [
    {
      "recipient_id": "temp_signer_1",
      "type": "signature",
      "page": 1,
      "x": 100,
      "y": 650,
      "width": 200,
      "height": 50
    },
    {
      "recipient_id": "temp_signer_1",
      "type": "date",
      "page": 1,
      "x": 320,
      "y": 650,
      "width": 100,
      "height": 30
    }
  ],
  "settings": {
    "send_signing_email": true
  }
}

The document field contains your base64-encoded PDF. The recipients array defines who needs to sign. The fields array places a signature box and a date field on page 1 at the coordinates you specify.

One API call, and Jane gets an email asking her to sign. No template creation required.

Note the temp_signer_1 pattern in the recipient ID. When you're creating recipients and fields in the same request, you use temporary IDs to link them together. The API resolves these to real UUIDs after creation.

Defining Fields Without the Template Editor

When you use templates, you can place fields visually using the embedded template editor. With one-off requests, you're defining field positions in the API call itself, which means you need to know the coordinates.

Each field needs:

• page – which page of the PDF (1-indexed)

• x and y – position from the bottom-left corner of the page, in points

• width and height – dimensions of the field, in points

If you're not sure where to place fields, open your PDF in a viewer that shows coordinates (most do), or just estimate and adjust. The signing experience is forgiving enough that you don't need pixel-perfect placement.

Field types available for one-off requests:

• signature – signature capture

• initials – initials capture

• text – free text input

• date – date picker

• checkbox – yes/no checkbox

You can also mark text fields as read_only if you want to pre-fill a value that the signer can see but not edit. This is useful for things like contract amounts, reference numbers, or any data that's already been agreed upon.

When to Use Templates Instead

One-off requests are great for ad-hoc documents, but templates are still the better choice when you're sending the same document structure more than a couple of times.

Templates let you use the embedded template editor to place fields visually instead of calculating coordinates. They also work with the embedded signing request editor, which lets non-technical users fill in recipient details and send documents without touching the API.

The rule of thumb: if you're going to send a document more than two or three times, create a template. If it's a one-time thing, skip the template and use a one-off request.

Wrapping Up

One-off signing requests remove the friction from ad-hoc documents. You don't have to create templates you'll never reuse, and you don't have to clutter up your workspace with one-time document structures.

Templates are still there when you need them. Both workflows use the same field types, the same recipient options, and the same tracking and audit trails. You're just choosing the path that fits the situation.

If you want to try it out, the create signing request endpoint has full documentation on the one-off workflow. Or use the atomic endpoint to create and send in a single call.

Get started with Firma.dev for free – no credit card required.