Skip to main content

Use Doqlo with Make

Use this page to understand how Doqlo works with Make today, whether it fits your workflow, and what you need before you automate Bulk Fill exports.

Support scope for this integration

This page provides implementation guidance and example workflow patterns for using Doqlo with Make. Doqlo supports its own API behavior, authentication, and documented product functionality. Doqlo does not provide hands-on scenario setup or end-to-end debugging inside your Make environment. If you suspect a Doqlo API issue or product defect, contact support with the relevant job_id, request_id, and error details.

Current Availability​

The Make integration is available to Doqlo users with Bulk Fill API access. You can set it up now using a BF export API key from your Doqlo account.

What This Integration Is​

The Make integration lets your Make scenarios call Doqlo's Bulk Fill export job system. It is an automation bridge for running Bulk Fill jobs from the tools you already use, such as spreadsheets, forms, and business systems.

Doqlo still handles document design, field placement, and mapping in the Doqlo web editor. Make handles automation and step-to-step workflow execution. This integration is useful when you want to trigger filled document exports from structured data without building a custom API workflow first.

What It Can Do Today​

Today the Make integration supports three actions:

  • Create Export Job: start a Doqlo Bulk Fill export job from Make using your prepared document package and source data
  • Get Export Job: check the current status of a job that is still running or confirm that a finished job completed successfully
  • Download Completed Export: retrieve the finished export file or package after the job is complete so later Make steps can use it

In practice, the flow is simple: create the job, check whether it is done, and then download the finished output for the next step in your scenario.

This integration is built around the Create → Get → Download workflow. It does not expose every option available in the underlying Public API. For the full API contract, see the API Quickstart.

What You Need Before Using It​

Before you use the Make integration, make sure you have:

  • a Doqlo account with Bulk Fill API access
  • a BF export API key
  • a source PDF
  • a .doqlo package exported from the Doqlo Bulk Fill web editor
  • row data or a CSV file to send into the export job
  • a Make account

The .doqlo package is the file you export from the Doqlo editor after you finish the layout and field mapping. It contains the layout and mapping configuration that Doqlo runs during the export job. Make does not replace that setup step.

Typical Workflows​

Doqlo provides the Make actions for export jobs. The other app steps in these workflows come from those apps' existing Make modules.

  • Google Sheets row using Google Sheets' Make modules -> Create Export Job -> Get Export Job -> Download Completed Export
  • Typeform submission using Typeform's Make modules -> Create Export Job -> Get Export Job -> Download Completed Export -> send the finished output to Google Drive, Gmail, or Dropbox using those apps' Make modules
  • Shopify order using Shopify's Make modules -> Create Export Job to generate order paperwork or fulfillment documents
  • CRM record update using that CRM's Make modules -> Create Export Job -> Get Export Job -> Download Completed Export for customer-facing or internal document delivery
  • Internal operations workflow -> send row data or a CSV export into Create Export Job -> monitor status -> route the completed output to the next system using that system's Make modules

How The Workflow Works​

  1. Prepare your PDF and .doqlo package in Doqlo.
  2. Connect Doqlo to Make with your BF export API key.
  3. Send row data or CSV data into the export job from earlier Make steps.
  4. Check the job status if the export is still running.
  5. Download the finished output and pass it to the next Make step.

This model keeps document design in Doqlo and execution in Make. You do not need to understand Doqlo internals or build a separate authoring workflow in Make.

For a step-by-step first test, see First Successful Make Scenario below.

First Successful Make Scenario​

Start with the smallest possible run before building larger scenarios.

  1. Prepare one document. Upload a source PDF to the Doqlo Bulk Fill web editor, place your fields, and export one .doqlo package.

  2. Get your API key. Create or copy a BF export API key from your Doqlo account.

  3. Create one test row. Use a single-row rows_json payload for your first test. A minimal example looks like this:

    [{"column_0": "Alice Nguyen", "column_1": "INV-1001"}]

    rows_json is an array of row objects. The keys (column_0, column_1, etc.) are positional and should match the column mapping already prepared in your .doqlo package. If you already have a CSV file from an earlier step, you can send that instead of rows_json: use one or the other, not both.

  4. Build the smallest scenario. Add three Doqlo modules in order: Create Export Job → Get Export Job → Download Completed Export.

  5. Run it. Test the scenario and confirm you get a downloaded file at the end. For normal use, the integration handles create request identity. If you design explicit retry logic around the same logical create, review Idempotency for the underlying API behavior.

  6. Connect a downstream step. After your first successful run, add one more module to send the downloaded output somewhere useful: for example, email it, save it to Google Drive, or post it to a webhook.

Current Limitations​

  • It supports actions only.
  • It does not currently provide Make triggers.
  • It does not currently provide a built-in async wait-until-complete user experience, so longer jobs need a follow-up status check step.
  • A .doqlo package must already exist before you run the workflow.
  • You must supply row data or CSV data in a supported form.
  • Very large exports may not be a good fit for this Make surface because Make file handling has its own size and runtime limits even when Doqlo completes successfully.

Who This Is Best For​

This integration is a good fit for:

  • operations teams automating document generation
  • teams already using Make for workflow automation
  • businesses generating recurring PDFs from structured data
  • teams that want to connect forms, spreadsheets, or business systems to Doqlo Bulk Fill