Skip to content
Developers

Launch via a schedule

Full-seat members

How do I launch processes on a recurring schedule?

Section titled “How do I launch processes on a recurring schedule?”

You can auto-launch processes on a schedule - once at a set time, or daily, weekly, monthly, or at any interval you need. Tallyfy can run the schedule itself, as a scheduled job you set up through the API or by asking an AI assistant. You can also use a middleware platform like Zapier, Make.com, or Power Automate, or write your own script that calls the Tallyfy API on a cron schedule.

  • A Tallyfy account with process launch permission (Admin, template owner, or granted launch access)
  • A published template ready to launch
  • One of these: an AI assistant connected to Tallyfy, access to the Tallyfy API, a middleware account (Zapier, Make.com, Power Automate), or a server where you can run scheduled scripts

Option 1 - a scheduled job that Tallyfy runs

Section titled “Option 1 - a scheduled job that Tallyfy runs”

A scheduled job launches a process from a template on its own, once at a set time or on a repeat (hourly, daily, weekly, monthly or yearly). Tallyfy runs it, so you don’t need another tool or a server of your own. The web app doesn’t have a screen for scheduled jobs yet, so you set one up in one of two ways:

  • Ask an AI assistant connected to Tallyfy’s MCP server, such as Claude. For example: “Launch the Equipment Safety Check template every Monday at 8 AM.”
  • Call the Tallyfy API. The calls are listed under For developers below.

Times are read in your organization’s time zone.

Every scheduled job has an owner, and it runs as that person. The owner starts out as the person who created the job, so each process it launches is started by them.

Before each run, Tallyfy checks that the owner is still an active member who can launch the template. If they aren’t, that run fails, and the job’s run history says why. A one-time job that fails is paused.

An org admin can change who a scheduled job runs as, by asking their AI assistant or through the API. The new owner must be an active member who can launch the template, and Tallyfy Bot can’t be an owner. If the person you pick doesn’t qualify, Tallyfy refuses the change and the job keeps its current owner. Tallyfy also refuses any owner change while the job’s template is archived or deleted. Restore the template first. Through the API you can point the job at another template instead, but only while its current owner is still an active member who can launch it. If the owner has left too, restore the template, or delete the job and create a new one.

When an admin deactivates someone and hands their work to another person on the Automatic conflict resolution page, that person takes over their scheduled jobs too. Only the jobs the new person can run move to them. Any others stay with the person who left, and fail.

If nobody takes over their work, their scheduled jobs stay with them and fail. So change the owner of each of their jobs before you deactivate them. See removing a member.

No coding required.

  1. Connect your middleware platform to Tallyfy.
  2. Create a new workflow with a Schedule trigger.
  3. Set the frequency (time, day, interval).
  4. Add a Tallyfy Launch Process action pointing to your template.
  5. Set the process name format and fill any required kick-off form fields.
  6. Test and activate.

Example - daily equipment check:

Trigger: Schedule (Every day at 8:00 AM)
Action: Launch Tallyfy process
Template: Equipment Safety Check
Process name: Equipment Check - {date}

Write a server-side script and schedule it with cron (Linux/Mac) or Task Scheduler (Windows).

  1. Write a script that calls POST /organizations/{org}/runs with your checklist_id.
  2. Schedule it using cron or another task scheduler.
  3. Add logging and error handling.
  4. Run the script once by hand, and check that the process appears in Tallyfy before the schedule takes over.

Example - Node.js script launching every Monday at 9 AM:

const cron = require('node-cron');
const axios = require('axios');
cron.schedule('0 9 * * 1', async () => {
try {
await axios.post('https://go.tallyfy.com/api/organizations/YOUR_ORG_ID/runs', {
checklist_id: 'your-template-timeline-id',
name: `Weekly Report - ${new Date().toLocaleDateString()}`
}, {
headers: {
'Authorization': 'Bearer YOUR_API_TOKEN',
'X-Tallyfy-Client': 'APIClient',
'Content-Type': 'application/json'
}
});
console.log('Process launched');
} catch (error) {
console.error('Launch failed:', error);
}
});

If you’re already using an ERP, HRIS, or another system with scheduling, you can have it call the Tallyfy API directly or go through middleware.

  1. Pick the system that already knows when the work is due, such as your HRIS for a new hire’s start date or your ERP for month-end close.
  2. Set up an integration from that system to Tallyfy.
  3. Map data from the source system to Tallyfy form fields.
  4. Let it run once, and check that the process launches with the right form field values.
Process typeFrequencyExample
Compliance auditsMonthlyAn inspection checklist on the 1st of each month
Financial reportingWeeklyExpense approvals at 4 PM every Friday
Team updatesDailyA standup checklist at 9 AM, Monday to Friday
Maintenance checksQuarterlyA facility inspection every three months, from the first day of a quarter

(Skip this unless you’re setting up the technical side.)

Scheduled jobs use the API’s recurring-jobs endpoints. Send the same headers as on any other call: Authorization: Bearer, X-Tallyfy-Client: APIClient and Accept: application/json.

  • GET /organizations/{org}/recurring-job-types lists the kinds of job. Use the id of the launch-process type.
  • POST /organizations/{org}/recurring-jobs creates a job. The body needs the job’s own name (up to 50 characters), recurring_job_type_id, start_date, schedule and data. end_date and max_occurrences are optional, and stop a repeating job.
  • start_date is the day the schedule is counted from, today or later. The first run isn’t always on that day. To see when it is, read the job back with GET /organizations/{org}/recurring-jobs/{id} and check its next_occurrence.
  • schedule needs recurring_type (hourly, daily, weekly, monthly or yearly) and start_time (HH:MM), and takes interval. A weekly schedule also needs days_of_week (1 for Monday to 7 for Sunday). A monthly one needs day_of_month, or week_of_month with one day in days_of_week.
  • data takes the template’s checklist_id, the name each launched process gets, and optional prerun values for the kick-off form.
  • GET, PUT and DELETE /organizations/{org}/recurring-jobs/{id} read, change and delete a job. GET /organizations/{org}/recurring-jobs/{id}/history returns its run history.
  • PUT /organizations/{org}/recurring-jobs/{id}/owner with the body {"user_id": 123} changes the owner. Only an org admin can call it. It answers 422 and changes nothing when the new owner isn’t an active member who can launch the template, or is the organization’s bot. It also answers 422 when the job’s template was archived or deleted, with the message a failed run records: “The template this job launches was archived or deleted. Restore it, or pick another template.” If the job’s owner has also left the organization, the message says instead: “The template this job launches was archived or deleted, and the job’s owner can no longer run it. Restore the template, or delete this job and create a new one.”

start_date and start_time are read in the organization’s time zone. The owner is kept in the job’s data.created_by, and updating a job with PUT /organizations/{org}/recurring-jobs/{id} never changes it, even when an owner change lands while the update is running. Each job the API returns also carries an owner object with the owner’s id, full_name and email.

A one-time job is a daily schedule with max_occurrences set to 1, and its date and time must still be ahead. max_occurrences goes at the top level of the body, beside start_date. Inside schedule it’s ignored, and the job runs every day. This body launches one process at 9 AM on December 31:

{
"name": "Year-end audit",
"recurring_job_type_id": 12,
"start_date": "2026-12-31",
"max_occurrences": 1,
"schedule": {
"recurring_type": "daily",
"interval": 1,
"start_time": "09:00"
},
"data": {
"checklist_id": "YOUR_TEMPLATE_ID",
"name": "Year-end audit 2026"
}
}

Replace 12 with the id of the launch-process type from GET /organizations/{org}/recurring-job-types.

Through the MCP server, schedule_process_launch creates a job and change_scheduled_job_owner changes its owner.

Launching > Triggers

Tallyfy offers seven ways to start a process, from manual clicks and form submissions to API…

Pro > Launching

Tallyfy lets you launch reusable templates into independent trackable processes, each with its…