# Connect Paige to any app with Zapier, Make, or Power Automate

The one pattern behind most Paige integrations: Paige drops each finished document and its data on an SFTP server, an automation platform picks the file up, and its built-in connector creates the record in QuickBooks, SharePoint, Salesforce, monday.com, or whatever you run — no code, no server.

Product: paige · Audience: system-administrator · Time: 45 minutes · Last verified: 2026-09-05

Canonical: https://help.ademero.com/paige/integrations/connect-paige-to-any-app-with-zapier-make-or-power-automate

**At the end of this guide, every document Paige finishes lands on an SFTP server as a searchable PDF plus a data file, and an automation you built picks it up within minutes and creates the matching record — bill, file, task, row — in the app you actually work in.**

This is the general-purpose route. Paige has native exports for Nucleus One and Content Central, and this site has a dedicated guide for each major system built on the pattern below. Read this one first if your app isn't covered yet, or if you want to understand what those guides are doing.

## How the handoff works

Paige doesn't call your other apps. It exports files, and the automation platform watches for them.

1. A document finishes in Paige (separated, typed, fields extracted, optionally reviewed).
2. Paige uploads the document to your SFTP folder as a PDF, then uploads three small data files with the same base name.
3. Your Zap, scenario, or flow notices the new data file, reads the field values out of it, fetches the PDF, and creates the record in the target app.

What Paige writes for each document:

| File | What's in it |
| --- | --- |
| `<name>.pdf` | The document, with a searchable text layer |
| `<name>.json` | Document type, scan job and page IDs, export timestamp, every field value by field name, and line-item tables |
| `<name>.xml` | The same data as XML |
| `<name>.csv` | The same data as a sectioned CSV (metadata, fields, then one table per line-item field) |

`<name>` is built by Paige from the scan job ID, the first page's ID, and a timestamp, so it is unique but not meaningful. Name things in the target app from the field values, not the filename.

Two facts make this reliable:

- **Paige uploads the PDF first, then the data files.** Trigger your automation on the `.json` file and the PDF is guaranteed to already be there.
- **The data file names the PDF.** The JSON's `metadata.pdf_file` value is the exact PDF filename, so your automation never has to guess.

> **NOTE:** If you turn on **Generate combined metadata file** in Paige's FTP settings, Paige also writes one combined JSON, XML, and CSV per export run. That's useful for batch imports into a spreadsheet or an accounting system; the per-document files are what an automation should trigger on.

## Step 1: Point Paige at your SFTP server

Paige connects to your SFTP server with a plain username and password. If you don't run one, hosted SFTP services take minutes to set up and cost a few dollars a month; any of them works.

1. Open **Settings** (the gear at the bottom of the left menu — administrators only), pick the scan job, and choose **Export**.

2. Click the **FTP** card.

3. Enter the server's **FTP Address** and **Port** (SFTP servers use `22`), then the **Username** and **Password** Paige should sign in with.

4. In **FTP Folder Path**, enter the folder Paige should write into, such as `/paige/invoices`. Paige creates it if it doesn't exist. Give each scan job its own folder — it keeps the automations simple.

5. Click **Test Connection**.
   
   **What you should see:** `FTP connection successful!` If you get `FTP connection failed:` followed by a reason, the reason is the server's own message — a wrong password, a blocked port, or a folder the account can't write to.

6. Connect. **What you should see:** `Connected to FTP Server!` and a green **Connected** label on the FTP card.

*[Screenshot: The FTP export dialog in Paige with address, port, credentials, and folder path filled in and the connection test showing success]*

7. Back on the Export page, turn on **Enable Auto Export** and set the criteria under **Auto Export Settings**:
   
   | Setting | Recommendation for an integration |
   |---|---|
   | **Document Types** | Leave empty for all, or pick only the types the target app should receive |
   | **Only documents having a document type** | On — untyped documents rarely map cleanly |
   | **Human Reviewed** | **Reviewed** if a person checks documents in Paige before they go out; **All** if the automation is the review |
   | **Auto Field Entry Complete** | **Yes** — a document with no field values has nothing to put in the record |
   
   Click **Save**.

From now on every document that meets the criteria exports on its own. Documents already in the scan job aren't sent retroactively; export those once from the **Documents** page with the **Export** button, which opens a four-step **Export Documents** dialog (Scope, Filters, Destinations, Confirm) — tick **FTP** under Destinations.

## Step 2: Build the automation

Pick your platform. The shape is the same in all three: *watch the folder → keep only `.json` files → read the values → fetch the PDF → create the record.*

### Zapier

1. **Trigger:** app **SFTP by Zapier**, event **New or Updated File**. Create the connection with your **Host**, **Username**, **Port Number** (22), and **Password**. Set the folder to the path you gave Paige.

2. **Filter:** add **Filter by Zapier** with the rule *File Name* **(Text) Ends with** `.json`. Without this the Zap fires four times per document.

3. **Read the values:** add **Code by Zapier**, event **Run Javascript**. In **Input Data**, map `file` to the trigger's file. Paste:
   
   ```javascript
   const res = await fetch(inputData.file);
   const doc = await res.json();
   const out = { pdf_file: doc.metadata.pdf_file, document_type: doc.metadata.document_type };
   for (const [name, value] of Object.entries(doc.fields)) out[name] = value;
   return out;
   ```
   
   Test the step. **What you should see:** one output field per Paige field, named exactly as the field is named in the scan job, plus `pdf_file` and `document_type`.

4. **Fetch the PDF:** add **SFTP by Zapier**, action **Download File**, and set the path to the folder plus `pdf_file` from the Code step.

5. **Create the record:** add your target app's action — for example **QuickBooks Online → Create Bill**, **Google Drive → Upload File**, **monday.com → Create Item** — and map the Code step's fields into it. Where the action takes a file, map the Download File step's output.

6. Turn the Zap on.

> **NOTE:** Zapier polls the SFTP folder on your plan's interval (every 1 to 15 minutes). That's the delay between Paige finishing a document and the record appearing.

### Make

1. **Trigger:** module **SFTP → Watch files in a folder**. Create the connection with **Host**, **Port** (22), **Auth Type** *Username and Password*. Point it at the Paige folder.

2. **Filter:** on the line after the trigger, add a filter: *File name* **Ends with** `.json`.

3. **Read the values:** add **SFTP → Get a file** for the triggered file, then **JSON → Parse JSON** with the file's data as its input. Make builds the data structure from a sample the first time you run it — run the scenario once with a real Paige file so the field names appear.

4. **Fetch the PDF:** add **SFTP → Get a file** with the path set to the folder plus the parsed `metadata.pdf_file`.

5. **Create the record:** add the target app's module and map the parsed fields and the PDF file data into it.

6. Set the schedule (Make runs scenarios every 15 minutes on the basic plan; you can shorten it) and turn the scenario on.

### Power Automate

1. **Trigger:** connector **SFTP - SSH**, trigger **When a file is added or modified**. Create the connection with **Host server address**, **User name**, **Password**, and **Port number** 22. Under **Folder**, choose the Paige folder. Leave **Include file content** on.

2. **Condition:** add a **Condition**: *File name* **ends with** `.json`. Put the rest of the flow in the **If yes** branch.

3. **Read the values:** add **Parse JSON**. Content is the trigger's *File content*. For the schema, click **Use sample payload to generate schema** and paste a real `.json` from your folder. Every Paige field becomes a token you can pick in later steps.

4. **Fetch the PDF:** add **SFTP - SSH → Get file content using path**, with the path set to the folder plus the parsed `pdf_file`.

5. **Create the record:** add the target connector's action — **SharePoint → Create file**, **Dynamics 365 Business Central → Create record**, **OneDrive for Business → Create file**, and so on — mapping the parsed tokens and the file content.

6. Save. **What you should see:** the flow's checker reports no errors, and the first run appears in the run history within a few minutes of Paige exporting a document.

> **IMPORTANT:** The SFTP - SSH trigger skips files over 50 MB and only watches the folder itself, not subfolders. Keep Paige's folder flat and, if you scan very long documents, use the **(properties only)** trigger followed by **Get file content** instead.

## What the JSON looks like

A document with two fields and a line-item table exports like this (field names are whatever you named them in the scan job):

```json
{
  "metadata": {
    "pdf_file": "scan_job_abc123_page_def456_20260905_141502.pdf",
    "scan_job_id": "abc123",
    "page_id": "def456",
    "export_timestamp": "2026-09-05T14:15:02.101234",
    "document_type": "Vendor Invoice"
  },
  "fields": {
    "Vendor Name": "Acme Office Supply",
    "Invoice Number": "INV-20441",
    "Invoice Date": "08/28/2026",
    "Total": "1,284.50"
  },
  "line_items": {
    "fld_lineitems": {
      "name": "Line Items",
      "columns": ["Description", "Qty", "Amount"],
      "rows": {
        "0": { "0": "Copy paper, case", "1": "10", "2": "449.00" },
        "1": { "0": "Toner, black", "1": "5", "2": "835.50" }
      }
    }
  }
}
```

Values are strings exactly as extracted or reviewed in Paige. If the target field wants a number or a date, convert it in the automation (Zapier Formatter, Make's built-in functions, or Power Automate expressions) rather than changing how the field is extracted.

## Test it end to end

1. In Paige, scan or upload one document into the scan job and let it finish processing. If your auto-export criteria require review, review it.
2. Watch the SFTP folder: the PDF appears, then the three data files.
3. Watch the automation's run history: one run, triggered by the `.json`.
4. Open the target app: the record exists, its fields match what Paige extracted, and the PDF is attached or filed.

Then, and only then, point the real documents at it.

## When it doesn't work

| Symptom | Where to look |
| --- | --- |
| Paige says connected but no files appear | The scan job's auto-export criteria aren't met — check **Human Reviewed** and **Auto Field Entry Complete**. Documents finished before you enabled auto export must be exported once by hand. |
| Files appear but the automation never runs | The automation is watching a different folder or subfolder, or your SFTP client preserved an old timestamp on test files you copied in by hand. Let Paige write a fresh document instead. |
| The automation runs four times per document | The `.json` filter is missing or matching the wrong field. |
| Field names don't show up in the mapping | The parse step was built from a sample that lacked those fields. Re-generate it from a `.json` for the right document type. |
| The PDF step fails with "not found" | The path is wrong — it must be the Paige folder plus `metadata.pdf_file`, not the trigger file's name. |

If the Paige side is the problem, contact Ademero support with the scan job name, the time you expected an export, and the message from **Test Connection**.

## What's next

- [Integrate your own system with the Paige API](https://help.ademero.com/paige/integrations/integrate-your-own-system-with-the-paige-api)
- [Set up scan jobs](https://help.ademero.com/paige/document-processing/set-up-scan-jobs)