OmniFocus

The most important step is setting the right expectation: there is no OmniFocus REST API. Searching the web, asking AI tools, or reading older blog posts may suggest that one exists — it does not. The Omni Group has published URL scheme documentation and Omni Automation (a JavaScript-based scripting layer inside the app), but neither exposes an HTTP endpoint that FlutterFlow can call over the internet. This integration therefore has two distinct data flows you need to design before touching any tool. Flow 1 is outbound from OmniFocus to FlutterFlow: OmniFocus (on your Mac or iPhone) runs a Shortcut or Omni Automation script that serializes your tasks as JSON and POSTs them to a Firebase Cloud Function webhook. The Cloud Function saves the data into Firestore. FlutterFlow reads from Firestore, where it has a native connection, and displays the tasks in your app. Flow 2 is inbound from FlutterFlow into OmniFocus: a FlutterFlow Custom Action uses the Dart url_launcher package to open the omnifocus:///add?name=TASK_TITLE URL scheme — this only works on macOS and iOS where OmniFocus is installed. For cross-platform inbound (Android users, web), a Cloud Function can send an email to the OmniFocus Mail Drop address associated with the account, which OmniFocus converts into an Inbox task. Sketch this architecture on paper before starting. You are building two systems (Firebase/Firestore and the Shortcut/Automation) in addition to the FlutterFlow app, and understanding which components connect where will save significant debugging time.

In the Firebase console, open your project and navigate to Firestore Database. Click Create Database and choose production mode. Create a collection named omnifocus_tasks. The schema for each document should mirror the OmniFocus task data you plan to export: fields like id (string), name (string), notes (string), project (string), dueDate (timestamp), completionStatus (string), and syncedAt (timestamp). You can add these fields manually now, or let the Cloud Function create documents with these fields when the first Shortcut export runs. In FlutterFlow, go to Settings and Integrations → Firebase. Click Connect to Firebase and follow the prompts to link your Firebase project (you will need to download and upload the GoogleService-Info.plist for iOS and google-services.json for Android). Once connected, go to the Firestore panel in FlutterFlow's left nav. Click + Add Collection and point it to omnifocus_tasks. FlutterFlow will auto-detect the schema from existing documents, or let you define the fields manually if the collection is empty. Create a Firestore Data Type in FlutterFlow called OmniFocusTask with the same fields you defined in Firestore. This Data Type will be used to bind task data to ListView widgets in your app. Firestore real-time listeners in FlutterFlow mean the app will automatically refresh when new tasks are synced — no manual polling required.

1// Firestore document schema for omnifocus_tasks collection
2// Each document represents one OmniFocus task
3{
4  "id": "abc123-omni-id",         // OmniFocus internal task ID
5  "name": "Prepare Q3 report",    // task title
6  "notes": "Include revenue...",   // task notes
7  "project": "Work : Finance",     // project path
8  "dueDate": "2026-08-01T09:00:00Z", // ISO timestamp
9  "completionStatus": "incomplete", // incomplete | complete
10  "flagged": false,                 // flagged/starred task
11  "syncedAt": "2026-07-10T08:30:00Z" // last sync timestamp
12}

The Cloud Function acts as the secure receiver for task data pushed from the iOS Shortcut or Omni Automation script on your Apple device. In the Firebase console, open Functions and create an HTTP-triggered function named omnifocusSync. The function receives a POST request containing an array of OmniFocus task objects as JSON, validates an optional webhook secret header for security (so not just anyone can inject tasks into your Firestore), and writes each task as a document in the omnifocus_tasks collection using the OmniFocus task id as the document ID (enabling upsert behavior on repeat syncs). Deploy the function. You will receive an HTTPS URL such as https://us-central1-YOUR_PROJECT.cloudfunctions.net/omnifocusSync. Copy this URL — you will paste it into the iOS Shortcut in the next step. For the webhook secret: generate a random string (e.g., 32 hex characters from a password manager). Store it in Firebase Functions config: firebase functions:config:set omnifocus.secret=YOUR_SECRET. In the Cloud Function, read this secret from config and compare it against a custom header the Shortcut sends (e.g., X-Webhook-Secret). Reject requests with a 401 if the header is missing or wrong. This prevents unauthorized Firestore writes if the Cloud Function URL is ever discovered by others.

1// Firebase Cloud Function — OmniFocus task sync webhook
2// File: functions/index.js
3const functions = require('firebase-functions');
4const admin = require('firebase-admin');
5admin.initializeApp();
6
7const db = admin.firestore();
8
9exports.omnifocusSync = functions.https.onRequest(async (req, res) => {
10  if (req.method !== 'POST') {
11    res.status(405).send('Method Not Allowed');
12    return;
13  }
14
15  // Validate webhook secret
16  const expectedSecret = functions.config().omnifocus.secret;
17  const incomingSecret = req.headers['x-webhook-secret'];
18  if (!expectedSecret || incomingSecret !== expectedSecret) {
19    res.status(401).json({ error: 'Unauthorized' });
20    return;
21  }
22
23  const tasks = req.body.tasks;
24  if (!Array.isArray(tasks)) {
25    res.status(400).json({ error: 'Expected { tasks: [...] }' });
26    return;
27  }
28
29  const batch = db.batch();
30  const syncedAt = new Date().toISOString();
31
32  for (const task of tasks) {
33    if (!task.id) continue;
34    const ref = db.collection('omnifocus_tasks').doc(String(task.id));
35    batch.set(ref, {
36      id: task.id,
37      name: task.name || '',
38      notes: task.notes || '',
39      project: task.project || '',
40      dueDate: task.dueDate || null,
41      completionStatus: task.completionStatus || 'incomplete',
42      flagged: task.flagged || false,
43      syncedAt: syncedAt
44    }, { merge: true });
45  }
46
47  await batch.commit();
48  res.status(200).json({ synced: tasks.length });
49});

On your iPhone or Mac where OmniFocus is installed, open the Shortcuts app (iOS 16+ or macOS 12+). Create a new Shortcut named Export OmniFocus Tasks. The Shortcut will use OmniFocus's built-in Shortcuts actions to fetch tasks and convert them to JSON. In the Shortcut editor, add the action Find Tasks in OmniFocus. Configure it to find incomplete tasks (you can filter by project, flag, or due date — start with all incomplete tasks for simplicity). Next, add a Repeat with Each action over the task list. Inside the loop, add a Get Details of OmniFocus Task action to extract the fields you want: Name, Notes, Project, Due Date, Completion, ID, Flagged. Collect these fields into a Dictionary variable per task, then add each dictionary to an accumulating List variable. After the loop, add a Get Contents of URL action (this is how Shortcuts makes HTTP requests). Set the URL to your Cloud Function URL from Step 3. Set Method to POST. Add a header row: X-Webhook-Secret with your secret value. Set the request body type to JSON and pass the task list as { tasks: [...] }. For automated syncing without manually running the Shortcut each time, add a Shortcut Automation in the Shortcuts app: set it to run on a time trigger (e.g., every morning at 7am) or on the action Open App for OmniFocus. This keeps your Firestore data reasonably fresh without any manual effort. On macOS, you can also use OmniFocus's built-in Omni Automation (Automation menu → New Plug-In or Run Script) with a JavaScript snippet that calls the same Cloud Function URL via fetch().

1// Omni Automation JavaScript — runs inside OmniFocus on macOS or iOS
2// Automation menu -> New Plug-In Script (or paste in the console)
3// Exports all incomplete tasks to Firebase Cloud Function
4
5(async () => {
6  const tasks = flattenedTasks.filter(t => !t.completed);
7  const payload = tasks.map(t => ({
8    id: t.id.primaryKey,
9    name: t.name,
10    notes: t.note || '',
11    project: t.containingProject ? t.containingProject.name : '',
12    dueDate: t.dueDate ? t.dueDate.toISOString() : null,
13    completionStatus: t.completed ? 'complete' : 'incomplete',
14    flagged: t.flagged
15  }));
16
17  const url = URL.fromString('https://us-central1-YOUR_PROJECT.cloudfunctions.net/omnifocusSync');
18  const request = new URL.FetchRequest();
19  request.method = 'POST';
20  request.headers = {
21    'Content-Type': 'application/json',
22    'X-Webhook-Secret': 'YOUR_WEBHOOK_SECRET'
23  };
24  request.bodyString = JSON.stringify({ tasks: payload });
25
26  const response = await URL.fetch(url, request);
27  console.log('Synced:', response.bodyString);
28})();

In your FlutterFlow project, create a new Page named My OmniFocus Tasks. In the widget tree, add a Column filling the screen. Inside, add a Text widget at the top displaying the last sync time (you will bind this to the most recent syncedAt value from Firestore). Below, add a ListView widget. Click the ListView and set Generate Children from Variable to a Backend Query against Firestore. Choose the omnifocus_tasks collection. Add a filter: completionStatus == 'incomplete' to show only open tasks. Add an order by: dueDate ascending to show soonest-due tasks first. FlutterFlow will automatically set up a real-time Firestore listener, so the list updates immediately when the Shortcut syncs new data. For each child item in the ListView, add a Card. Inside: a Row at the top with a Text widget bound to OmniFocusTask.name (in bold, font size 16) and a Chip widget for the project name bound to OmniFocusTask.project. Below, a Text widget showing the due date formatted as a readable string, using FlutterFlow's date format action. Add a Conditional Styling rule to the Card's left border: if the dueDate is in the past and completionStatus is incomplete, show a red left border (overdue indicator). Add a Floating Action Button to the page. This button will navigate to a Create Task page (built in the next step). The overall page now shows a live, refreshing task list synchronized from OmniFocus via your Firestore bridge.

To create tasks from FlutterFlow back into OmniFocus, you need a Custom Action for Apple platforms and a Mail Drop fallback for Android or web users. Custom Actions that use url_launcher do not run in the FlutterFlow web/Run Mode preview — you must test this on a real iOS or macOS device build. In FlutterFlow, go to left nav → Custom Code → + Add → Action. Name it LaunchOmniFocusTask. In the Dependencies field, add the pub.dev package url_launcher with a recent version (check pub.dev for the latest stable version number). Write the Dart action as shown below: it takes taskName (String) and taskNote (String) as input parameters, encodes them as URL components, and launches the omnifocus:///add URL scheme. On the Create Task page, add a Form with a TextField for task name and a multi-line TextField for notes. Add a Submit button. In the button's Action Flow, first check the device platform using an If/Else Conditional Action: if Platform is iOS or macOS, call the LaunchOmniFocusTask Custom Action with the form field values as parameters. If the platform is Android or Web, call a Cloud Function via an API Call action that sends an email to the OmniFocus Mail Drop address — the email subject becomes the task name and the body becomes the notes. For the Mail Drop route: go to OmniFocus settings on any Apple device, navigate to Mail Drop, and copy the unique email address. Paste it into your Cloud Function as a config value. The Cloud Function sends an email via an SMTP service (for example, using Firebase's recommended Trigger Email extension, which connects to an email provider). Do not embed the Mail Drop address in the client app — keep it in the Cloud Function config.

1// FlutterFlow Custom Action — LaunchOmniFocusTask
2// Dependency: url_launcher (add exact version from pub.dev)
3// Arguments: taskName (String), taskNote (String)
4// Returns: void
5
6import 'package:flutter/material.dart';
7import 'package:url_launcher/url_launcher.dart';
8import 'dart:io' show Platform;
9
10Future<void> launchOmniFocusTask(
11  String taskName,
12  String taskNote,
13) async {
14  // Guard: OmniFocus only exists on Apple platforms
15  if (!Platform.isIOS && !Platform.isMacOS) {
16    debugPrint('OmniFocus URL scheme only works on iOS and macOS');
17    return;
18  }
19
20  final encodedName = Uri.encodeComponent(taskName);
21  final encodedNote = Uri.encodeComponent(taskNote);
22
23  // OmniFocus URL scheme: https://help.omnigroup.com/omnifocus-url-schemes
24  final uri = Uri.parse(
25    'omnifocus:///add?name=$encodedName&note=$encodedNote',
26  );
27
28  if (await canLaunchUrl(uri)) {
29    await launchUrl(uri);
30  } else {
31    debugPrint('Could not launch OmniFocus URL scheme — is OmniFocus installed?');
32  }
33}