Email a PDF for every form submission

Pick the route

• Zapier (Tally, Typeform, Jotform, Google Forms, any form with a Zapier trigger): trigger → Webhooks by Zapier → Gmail: Send Email. The PDF travels as a 24-hour download link.
• Make: Watch New Responses → HTTP: Make a request → Email or Gmail. The PDF travels as binary data inside the scenario.
• Google Forms: an Apps Script trigger on the linked sheet; the full script is in the Google Sheets guide (section Form submission → PDF by email).
• Your own endpoint: Tally's webhooks (free on every plan, per Tally's help) POST the submission as JSON to a URL you run; about 30 lines of Python turn it into a PDF and an email.

One honest note before you build: Tally's webhook payload already contains a submissionPdfUrl, a plain PDF of the raw answers. Use this guide when you want a formatted document (your layout, a letter, an invoice or certificate from a hosted template, a report with a table of contents), not a dump of the answers.

Zapier: form trigger → Webhooks → Gmail

Tally's help page describes a Zap as a trigger plus actions, with "a new Tally form submission" as the trigger event, and says the Zapier integration is available to all Tally users. Typeform and Jotform expose equivalent new-submission triggers. After the trigger, add Webhooks by Zapier → Custom Request, method POST, URL https://papertype.dev/v1/pdf, headers Authorization: Bearer dp_your_key and Content-Type: application/json, and this body with the form's fields inserted (create the key at /signup):

{
  "markdown": "# Workshop registration\n\nSubmitted {{submitted_at}}\n\n| Field | Value |\n|---|---|\n| Name | {{name}} |\n| Email | {{email}} |\n| Sessions | {{sessions}} |\n| Notes | {{notes}} |",
  "title": "Workshop registration",
  "theme": "clean",
  "page_numbers": true,
  "filename": "submission-{{submission_id}}.pdf",
  "output": "url"
}

Test the step. The live response for the sample submission was:

{
  "url": "https://papertype.dev/v1/files/XXXXXXXXXXXXXXXX.pdf",
  "filename": "submission-2wgx4n.pdf",
  "pages": 1,
  "bytes": 12866,
  "expires_at": "2026-10-24T03:05:43Z"
}

Then add Gmail → Send Email (Zapier's Gmail page lists it as "Create and send a new email message"). Map the respondent's email answer into To, write the subject and body, and map url into the Attachment field. Zapier's "Send files in Zap workflows" article states the two conditions for a link in a file field: it must be publicly accessible (no login) and a direct download link (the file itself, not a page that previews it), and suggests testing the link in a private browser window. The url above meets both: fetching it with no credentials returned Content-Type: application/pdf and exactly the bytes the JSON reported. Free-text answers are the usual snag: a double quote or line break inside an answer breaks the JSON above. Keep long answers out of the table, or switch to the POST event with Payload Type JSON and one Data row per field so Zapier escapes them (details in the Zapier and Make guide).

Make: Watch New Responses → HTTP → Email

Tally's Make page names the trigger: Watch New Responses, "which triggers when someone submits a selected Tally form". Follow it with HTTP → Make a request: URL https://papertype.dev/v1/pdf, method POST, body content type JSON, body input method Data structure with the fields below (Make escapes quotes and newlines in mapped values), Parse response No, and the API key in a keychain header as described in the Zapier and Make guide. Leave output out; the response body is the PDF itself, which Make exposes as the module's binary Data. This is the body the live check sent:

{
  "markdown": "# Workshop registration\n\nSubmitted {{1.createdAt}}\n\n| Field | Value |\n|---|---|\n| Name | {{1.Name}} |\n| Email | {{1.Email}} |\n| Sessions | {{1.Sessions}} |\n| Notes | {{1.Notes}} |",
  "title": "Workshop registration",
  "theme": "clean",
  "page_numbers": true,
  "filename": "submission-{{1.submissionId}}.pdf"
}

Live result: 200, Content-Type: application/pdf, X-Pages: 1, Content-Disposition: attachment; filename="submission-2wgx4n.pdf". Then add Email → Send an email (Make's Email app page: send and receive emails, iterate attachments; it needs an existing mailbox, and Make advises against personal accounts) or Gmail → Send an email, map the respondent's address into To, and in Attachments set the file name to submission-{{1.submissionId}}.pdf and the data to the HTTP module's Data. The attachment mapping is the standard Make file-field pattern; the Make UI steps on this page were not exercised first-hand.

Your own endpoint: a Tally webhook receiver in Python

Tally's webhook help: when someone submits a form, "a notification containing the response data gets sent to your URL in JSON format via a POST request"; you add the endpoint under the form's Integrations tab, optionally with a signing secret and extra headers. The payload has data.formName, data.createdAt, data.submissionId and a data.fields list of {label, type, value} (multiple-choice values arrive as lists). This function turns that into Markdown; it was executed on a payload with Tally's published shape, including a pipe and a line break inside an answer:

def submission_to_markdown(payload: dict) -> str:
    data = payload.get("data", {})
    rows = []
    for f in data.get("fields", []):
        v = f.get("value")
        if isinstance(v, list):
            v = ", ".join(str(x) for x in v)
        v = "" if v is None else str(v)
        v = v.replace("|", "\\|").replace("\n", "<br>")
        rows.append(f"| {f.get('label', f.get('key', ''))} | {v} |")
    title = data.get("formName", "Form submission")
    when = data.get("createdAt", "")
    return (f"# {title}\n\nSubmitted {when}\n\n| Field | Value |\n|---|---|\n"
            + "\n".join(rows))

The handler (FastAPI shown; Flask or Express is the same three calls) renders and emails. The render call below is what the live check ran; the SMTP send is standard library code that was not run here, since this server sends no email:

import os, json, smtplib, requests
from email.message import EmailMessage
from fastapi import FastAPI, Request

app = FastAPI()

@app.post("/tally")
async def tally(req: Request):
    payload = await req.json()
    data = payload["data"]
    to = next(f["value"] for f in data["fields"] if f["type"] == "INPUT_EMAIL")
    r = requests.post("https://papertype.dev/v1/pdf",
        headers={"Authorization": "Bearer " + os.environ["PAPERTYPE_API_KEY"]},
        json={"markdown": submission_to_markdown(payload), "title": data["formName"],
              "theme": "clean", "page_numbers": True,
              "filename": f"submission-{data['submissionId']}.pdf"}, timeout=60)
    r.raise_for_status()                      # 400/401/413/422/429 carry a JSON detail
    msg = EmailMessage()
    msg["To"], msg["From"], msg["Subject"] = to, os.environ["MAIL_FROM"], "Your registration"
    msg.set_content("Thanks for registering. Your summary is attached.")
    msg.add_attachment(r.content, maintype="application", subtype="pdf",
                       filename=f"submission-{data['submissionId']}.pdf")
    with smtplib.SMTP_SSL(os.environ["SMTP_HOST"], 465) as s:
        s.login(os.environ["SMTP_USER"], os.environ["SMTP_PASS"]); s.send_message(msg)
    return {"ok": True}

Return quickly and let Tally retry on failure (Tally's page documents request failure and retries); if rendering plus SMTP takes longer than you like, queue the work and return 200 first. Verify Tally's signing secret on every request if you set one.

What to expect, and limits

• Status codes. A body with no markdown, html or template returns 400 ({"detail": "Provide 'html', 'markdown', or 'template' + 'data'."}, observed when the mapped field was empty); wrong key 401; input over 2 MB 413; a bad option or a missing template field 422 naming it; quota 429. All carry a JSON detail. In Zapier the step errors and the run stops; in Make set Return error if HTTP request fails to Yes.
• Links expire. With output: "url" the finished PDF (never the answers you sent) is kept at an unguessable link for 24 hours, then deleted; see the privacy policy. The link is public, and the document contains the respondent's answers, so attach it in the same Zap run and do not write the link anywhere else. The Make, Apps Script and own-endpoint routes store nothing at all.
• Quota. Free-plan output carries a small papertype.dev footer mark. Paid plans (from $9/month) do not. The free plan is 50 documents a month, one per submission; the API returns 429 at the limit, never overage. A form with 200 submissions a month needs the $9 plan.
• Images. The renderer has no network access. Images, fonts and stylesheets at external URLs are never fetched; inline them as data: URIs. A request that references an external URL fails with a 422 that names the URL, rather than silently dropping the asset. A logo goes in as a data:image/png;base64,… URI, or use a hosted template's logo field.
• Templates. For an invoice, certificate or report rather than a table of answers, send {"template": "invoice", "data": {...}} instead of markdown; the body is in the Zapier and Make guide, and a missing required field returns 422 naming it.

Related

• Generate a PDF in Zapier or Make
• Generate a PDF from a Google Sheets row with Apps Script
• Generate invoice PDFs from JSON
• Markdown to PDF API

All guides