# Tally partial submissions: how they work and what they cost

_By Luka Brzin, Senior Product Marketing Manager_

Tally's partial submissions save the answers of respondents who start a Tally form but never press submit. They are a Tally Pro feature ($29 a month, or $290 a year, checked October 2026), you switch them on per form in Settings, and they only collect from that moment on. Partials appear in the form's Submissions tab, but they don't send email notifications and don't go to integrations such as Zapier, Make, Google Sheets or webhooks. To act on them, you download a CSV from the Partial tab or pull them from Tally's API.

## Key takeaways

-   Partial submissions need Tally Pro: $29 a month, or $290 a year, which the pricing page shows as $24 a month (checked October 2026).
-   Turn them on in the form's Settings. Tally doesn't keep partials from before you switched them on.
-   A partial is only captured once the respondent answers a question, and signatures are never saved in one.
-   Partials trigger no email notifications and no integrations, webhooks included. The CSV download and the API's `filter=partial` are the ways out.
-   Saving answers before someone presses submit needs a clear notice on the form, and in the EU and UK the cautious reading is that you need consent first.

## How to turn on partial submissions in Tally

1.  **Be on Tally Pro.** The feature is listed under Pro on [Tally's pricing page](https://tally.so/pricing) ("Capture unfinished form responses before respondents submit your form"), and [Tally's Pro page](https://tally.so/help/tally-pro) gives the price as $29 a month or $290 a year. Business ($89 a month) includes everything in Pro.
2.  **Open the form and click Settings.** Switch on **Partial submissions**.
3.  **Test it.** Open the live form in a private window, answer the first question, and close the tab without submitting.
4.  **Find it under Submissions.** Partials are listed in the **All** tab with an icon, and the **Partial** tab shows only partials.

The steps and limits on this page come from [Tally's partial submissions help page](https://tally.so/help/partial-submissions), checked October 2026.

## What Tally saves, and what it doesn't

-   **Only answered questions.** Tally says partials are "only captured when a respondent answers a form field". Someone who opens the form and leaves without answering anything leaves no partial.
-   **Only from when you switched it on.** Turning the setting on doesn't reveal earlier drop-offs; Tally collects partials only while it is on.
-   **No signatures.** For security reasons, signature answers are not saved in partials.
-   **Not in the Summary tab.** Partials appear under Submissions, not in the form's Summary.

Tally's help page doesn't say exactly when an answer is saved (as each question is answered, or when the respondent moves to the next page), so run the private-window test above on your own form before you rely on it.

Partial submissions are also not the same as **Save answers for later**. That setting lets respondents come back and finish; partial submissions let you, the form owner, see what unfinished respondents entered.

## Partial and completed submissions compared

What you need

Completed

Partial

Listed under Submissions

Yes

Yes, with an icon, and in the Partial tab

In the Summary tab

Yes

No

Email notifications

Yes

No

Integrations and webhooks

Yes

No

CSV download

Yes

Yes, from the Partial tab

Tally API

Yes

Yes, with `filter=partial`

Signatures

Yes

Not saved

The webhook row follows from two of Tally's pages: its [webhooks page](https://tally.so/help/webhooks) names "a new form submission" as the trigger, and the partial submissions page says partials "can't be synced to other applications using integrations". Webhooks themselves are free on every Tally plan.

## How to get partial submissions out of Tally

### Download a CSV

Open the form's Submissions, choose the **Partial** tab and click **Download CSV**. Fine for a weekly look, but too slow for replying while the respondent still remembers you.

### Pull them from the API

Tally's API lists a form's submissions and takes `filter=all`, `completed` or `partial`; each submission carries `isCompleted` ([API reference](https://developers.tally.so/api-reference/endpoint/forms/submissions/list), checked October 2026). Create a key under Settings, API keys, then:

```
curl 'https://api.tally.so/forms/YOUR_FORM_ID/submissions?filter=partial&limit=100' \
  -H 'Authorization: Bearer tly-xxxx'
```

To hear about partials without opening Tally, run a small script once an hour. This one posts each partial with an email address from the hour before last to a Slack channel (through an incoming webhook URL), and skips anyone who completed the form since. It finds the email by the question's type, `INPUT_EMAIL`.

```
// tally-partials.mjs: run once an hour (cron, GitHub Actions, a scheduled Worker). Node 18 or later.
// Posts each partial submission that has an email address to Slack,
// unless the same email completed the form since.
const FORM_ID = process.env.TALLY_FORM_ID;
const headers = { Authorization: `Bearer ${process.env.TALLY_API_KEY}` };
const HOUR = 60 * 60 * 1000;
const from = new Date(Date.now() - 2 * HOUR).toISOString();
const to = new Date(Date.now() - HOUR).toISOString(); // an hour of quiet before you hear about it

async function list(filter, range) {
  const params = new URLSearchParams({ filter, limit: '500', ...range });
  const res = await fetch(`https://api.tally.so/forms/${FORM_ID}/submissions?${params}`, { headers });
  if (!res.ok) throw new Error(`Tally API answered ${res.status}`);
  const data = await res.json();
  const emailQuestion = data.questions.find((q) => q.type === 'INPUT_EMAIL');
  const emailOf = (s) => s.responses.find((r) => r.questionId === emailQuestion?.id)?.answer;
  return data.submissions.map((s) => ({ ...s, email: emailOf(s) }));
}

const partial = await list('partial', { startDate: from, endDate: to });
const completed = await list('completed', { startDate: from });
const finished = new Set(completed.map((s) => s.email).filter(Boolean));

for (const s of partial) {
  if (!s.email || finished.has(s.email)) continue;
  await fetch(process.env.SLACK_WEBHOOK_URL, {
    method: 'POST',
    headers: { 'content-type': 'application/json' },
    body: JSON.stringify({ text: `Left the Tally form early: ${s.email} (${s.submittedAt})` })
  });
}
```

Three things to know first. A Tally API key belongs to a user and can reach everything that user can, so keep it in your scheduler's secrets, never in a page. The API allows 100 requests a minute. And at most 500 submissions come back per page, which is plenty for an hourly window on most forms; past that, follow `hasMore` and `page`. We tested the script against a mock of the documented response, not against a live Tally account.

## See where respondents stop

Partials tell you who left. To see where, Tally Pro includes drop-off analytics ("Identify where respondents abandon your form") and a Google Analytics integration. If you embed the form on your own site, Tally's embed script also sends a `Tally.FormPageView` event to your page each time the respondent reaches a page of the form, and `Tally.FormSubmitted` when they finish ([widget events](https://developers.tally.so/widgets/events)), so you can count page by page in your own analytics.

## Tell respondents first

Partial submissions save what people typed before they chose to send it, so say so at the top of the form, for example: "We save your answers as you go, so we can follow up even if you don't finish." Where your respondents are changes what else you need:

-   **EU.** The EDPB reads Article 5(3) of the ePrivacy Directive as covering information a user types in before it is collected ([Guidelines 2/2023](https://www.edpb.europa.eu/system/files/2024-10/edpb_guidelines_202302_technical_scope_art_53_eprivacydirective_v2_en_0.pdf), paragraph 62), which means consent unless a narrow exception applies.
-   **UK.** PECR regulation 6 is the same rule, and the ICO's [guidance on storage and access technologies](https://ico.org.uk/for-organisations/direct-marketing-and-privacy-and-electronic-communications/guidance-on-the-use-of-storage-and-access-technologies/) lists the exceptions; none is written for saving an unsent form.
-   **Switzerland.** Tell respondents what you do and why, and that they can refuse and how (Article 45c of the Telecommunications Act, explained in the FDPIC's [cookie guidelines](https://www.edoeb.admin.ch/en/guidelines-on-data-processing-using-cookies)).
-   **United States.** No federal consent rule, but California's wiretap law has been used against tools that record what visitors type without consent given beforehand ([_Javier v. Assurance IQ_](https://cdn.ca9.uscourts.gov/datastore/memoranda/2022/05/31/21-16351.pdf), 9th Cir., 2022, unpublished).

Tally's help page doesn't describe a way to hold partial saving until a respondent agrees, so if you need consent first for EU or UK respondents, weigh that before you switch it on. Our [form abandonment guide](/guides/form-abandonment) covers the law and the follow-up etiquette in more depth. This page is not legal advice.

## If your form is not a Tally form

Everything above applies to forms built in Tally. If the form is your own HTML, written by you or a coding agent, Tally's setting can't reach it. That is the case OllieLeads is built for: it isn't a form builder, it is where the form on your site sends its leads, and it catches people who leave halfway. Here is how it handles each limit above:

-   **Plan.** Partial capture is on every plan, including Free ($0, 500 leads in total, no card). Pro is $29 a month for 1,000 leads a month ([pricing](/pricing), checked October 2026).
-   **No notification.** About 30 minutes after a visitor goes quiet, you get one "left early" alert by email, Slack or Discord.
-   **No integrations.** Left-early leads go to signed webhooks (the `lead.left_early` event), the REST API and the MCP server like any other lead.
-   **Consent.** With `data-consent="required"` on the script tag, nothing is saved before the visitor agrees.
-   **What is saved.** Less than Tally: before submit, only name, email and phone, each as the visitor leaves the field. Everything else arrives when they press Send. If you want every answer from people who leave, Tally keeps more.

Moving means building the form in your own site, so it is only worth it if you want that anyway. Download your Tally submissions as CSV first. Then build the form in your HTML, set its `action` to `https://ollieleads.com/f/{formId}` (or keep your own submit handler), add `<script src="https://ollieleads.com/sdk/v1.js" defer></script>` and `data-ollie-form` on the form, and test on localhost (ports 3000, 5173, 4321 or 8080), where every lead is a test lead automatically. The [partial submissions page](/features/partial-submissions) has the details. If you like building forms in Tally, with its logic, payments and signatures, stay with Tally and use the API script above.

## FAQ

### Are Tally partial submissions free?

No. They are a Tally Pro feature: $29 a month, or $290 a year (checked October 2026). Tally's free plan includes unlimited forms and submissions within its fair use policy, but not partials.

### Why are my Tally partial submissions not showing?

Check four things: the form owner is on Pro, Partial submissions is switched on in that form's Settings, the respondent answered at least one question after you switched it on, and you are looking under Submissions (the All or Partial tab), not in the Summary tab, which leaves partials out.

### Do Tally partial submissions trigger Zapier or webhooks?

No. Tally says partials can't be synced to other applications through integrations, and they don't send email notifications. Completed submissions still go to Zapier, Make and webhooks as usual. To get partials out automatically, use the API with `filter=partial`.

### Can I get an email when someone leaves a Tally form?

Not from Tally's own notifications. A script that polls the API once an hour, like the one above, can send each new partial with an email address to Slack or your inbox.

### Are signatures saved in Tally partial submissions?

No. Tally doesn't save signature answers in partials, for security reasons. A respondent who signs and then leaves shows up without the signature.

Built with [SuperDuperSEO](https://superduperseo.com/published-by): programmatic SEO content for SaaS, agencies and indie hackers