Resources · Make integration

FastField Make integrationAutomate FastField with Make.

What happens after a field form lands in FastField is up to you. The FastField Make integration gives you 10 modules: 1 instant trigger, 6 actions and 3 searches. This guide is for ops teams who run mobile forms, and it walks you from the connection to a scenario that works.

Try the FastField integration on MakeSee the 10 modules

Verified Trustpilot reviews · AI, automation & growth agency

What you can automate

What can the FastField Make integration automate?

The FastField Make integration links your FastField account to Make so a submitted form can set off work in other tools, and so Make can send forms and maintain lists in FastField for you. You build it as a scenario: the automation you assemble in Make, one module after another, without writing code.

A follow-up form that sends itself. Watch Form Submissions starts the scenario the moment a crew member submits a form, and Create a Dispatch sends the next form to the colleague who takes over. Nobody has to remember the hand-off.

Lists that match your other systems. When a record changes in the tool your office already uses, Update a Global List or Update a Lookup List carries the change into FastField, and Create a Global List or Create a Lookup List adds a new one when it does not exist yet.

A view of open work per person. List Dispatches by a User returns the dispatched forms a user has not completed yet, which you can pass on to a report or a message.

Know the boundaries too. FastField has no scheduled trigger in Make and no module that deletes a dispatch or a list; Make an API Call is the route for anything the listed modules skip. If you are weighing tools, the n8n vs Make comparison sets out the criteria. To learn the editor properly, start with Make training, and keep Make troubleshooting close when a run fails.

Connect

How do you connect FastField to Make?

  1. 01

    Copy your API key in FastField

    You need an active FastField developer account. In the developer portal dashboard, click your name in the top right corner, pick Profile, then click Show next to the keys under Your subscriptions and copy the API key.

  2. 02

    Open the connection window in Make

    Add any FastField module to your scenario and click Create a connection. A connection is your FastField account linked to Make once, then reused by every FastField module. The Connection name field is optional.

  3. 03

    Paste the key and save

    Enter the credentials you copied from FastField, or follow the instructions Make shows on screen. Once saved, the connection appears in the dropdown of every other FastField module you add later.

First scenario

Your first scenario with FastField

GoalWhen a form is submitted in FastField, Make dispatches a follow-up form to the next user.

  1. 01

    Create the scenario

    On the Scenarios page, create a new scenario and click the + in the middle of the editor. Search for FastField and pick Watch Form Submissions as the first module.

  2. 02

    Set up the webhook and connection

    Click Create a webhook, then Create a connection and paste your API key. This trigger is instant: FastField calls Make through the webhook as soon as a form comes in.

  3. 03

    Add the dispatch

    Click the + on the right of the trigger and add Create a Dispatch. Fill its fields, mapping data from the submission that the trigger received from the submitted form.

  4. 04

    Test with Run once

    Click Run once, then submit a test form in FastField. Open each module afterward to read the bundle it received: one bundle is one item passed from a module to the next, here one submission.

  5. 05

    Switch it on

    When the test looks right, switch the scenario on. Each module run counts as one operation, the unit Make counts on your plan, so a submission here uses two.

Triggers

What starts a FastField scenario

1 module starts a scenario when something happens in FastField. A scheduled trigger is checked by Make on the scenario's schedule; an instant one is called by FastField as soon as it happens.

FastField1Watch Form Submissions

Watch Form Submissions

Instant trigger

In Make“Triggers when a new Form is submitted to FastField.”

Every time someone submits a form to FastField, this trigger hands the submission to your scenario so the next steps can run without anyone copying data by hand. It is the only way a FastField event can start a scenario.

How it fires
instant. FastField calls Make through a webhook as soon as a submission happens, so the scenario does not wait for a schedule.
When to use it
pick it when a completed inspection or delivery form should start a follow-up, a notification or an update in another tool.
Watch out
the module asks you to click Create a webhook before Create a connection, and it only reacts to new submissions.
Modules

What FastField can do in Make

FastField gives you 9 modules. For each one: what it does for you, when to reach for it, and what to watch out for.

FastField1

Create a Dispatch

Action

In Make“Dispatches a form to one or more users.”

Sends a form to one or more FastField users, so the right people find the work waiting in FastField without a manager assigning it by hand.

When to use it
after a submission or a new job in another tool, to push the next form to the technician who handles that step.
Watch out
one dispatch can target several users, so check the recipients you map before you switch the scenario on.
FastField2

Create a Global List

Action

In Make“Creates a Global List in calling user's account.”

Adds a new Global List to the FastField account behind your connection, which saves you from building it again in the FastField interface each time a new set of values shows up.

When to use it
when another system introduces a set of values that your team does not have in FastField yet.
Watch out
run List Global Lists first if you are not sure the list exists, or you may end up with two.
FastField3

Create a Lookup List

Action

In Make“Creates a Lookup List in calling user's account.”

Builds a brand new Lookup List in the FastField account tied to your connection. The list is created from the data your scenario maps into it, with no manual import.

When to use it
when a spreadsheet or database elsewhere holds reference data that your forms should be able to use.
Watch out
Lookup Lists and Global Lists are separate modules, so pick the type your forms actually rely on.
FastField4

Make an API Call

Action

In Make“Performs an arbitrary authorized API call.”

Reaches any endpoint of the FastField API through the same connection, which covers the gaps when none of the ready-made modules does what your process needs.

When to use it
for an action the nine other modules do not offer, provided the FastField API exposes it; no delete module exists, for instance.
Watch out
you describe the request yourself, so keep the FastField API documentation open while you set it up.
FastField5

Update a Global List

Action

In Make“Updates a Global List in calling user's account.”

Updates a Global List you already have, so its values stay in line with your source of truth, and the forms your crews open keep offering current choices.

When to use it
when the matching record changes in your CRM or spreadsheet and FastField should follow.
Watch out
you need to point the module at the right list, so place List Global Lists before it when the scenario does not already know which one.
FastField6

Update a Lookup List

Action

In Make“Updates a Lookup List in calling user's account.”

Refreshes a Lookup List that already exists in FastField, which keeps the reference data behind your forms from going stale while teams are out in the field.

When to use it
right after the reference data changes in the tool where your office maintains it.
Watch out
this module changes a list and never creates one; pair it with List Lookup Lists to find the list first.
FastField7

List Dispatches by a User

Search

In Make“Returns all uncompleted dispatched Forms for a given User.”

Returns every form dispatched to a given user that is still not completed, giving you a clear picture of what that person has left to do.

When to use it
before sending new work to someone, or to feed a report of pending forms per technician.
Watch out
as a search, it can return zero, one or many bundles, and each bundle runs the modules after it once.
FastField8

List Global Lists

Search

In Make“Returns the list of Global Lists associated with the account of the authenticated user.”

Pulls the Global Lists attached to the account you connected. That way, the rest of the scenario knows exactly which lists already exist before anything gets created or edited downstream.

When to use it
as the step that finds a list by name ahead of Update a Global List.
Watch out
several bundles come back at once, so add a filter when only one list should move on to the next module.
FastField9

List Lookup Lists

Search

In Make“Returns the list of Lookup Lists associated with the account of the authenticated user.”

Retrieves all the Lookup Lists linked to your connected account, so your scenario can check what is already there instead of guessing.

When to use it
ahead of Update a Lookup List, or to decide whether Create a Lookup List is needed at all.
Watch out
an empty result means zero bundles, and the modules after it simply do not run for that pass.
Need help

Need help automating FastField with Make?

A person reads every message.

FAQ

FastField and Make: common questions

01Is the FastField Make integration free?
Yes, FastField is a standard app in Make, so it works on the Free plan. That plan allows 2 active scenarios, a minimum of 15 minutes between scheduled runs, 5 minutes of execution per run, files up to 5 MB and 512 MB of data transfer. Paid plans (Core, Pro, Teams and Enterprise) lower the interval to 1 minute and remove the cap on active scenarios. Your FastField subscription is separate: you need an active developer account on the FastField side.
02What do you need to connect FastField to Make?
You need an active FastField developer account and its API key. In the developer portal, open your name in the top right corner, choose Profile, and click Show next to the keys under Your subscriptions to copy the key. In Make, add a FastField module, click Create a connection, and paste it. The connection is then reused by every FastField module in your scenarios, so you only set it up once, whatever the number of scenarios you build around FastField.
03Does the FastField trigger in Make react in real time?
Yes. Watch Form Submissions is an instant trigger: FastField calls Make through a webhook as soon as a form is submitted, so the scenario starts right away instead of waiting for the next scheduled check. That is also why Make asks you to click Create a webhook before Create a connection when you add it. FastField has no scheduled trigger in Make, so this is the one entry point from the FastField side.
04What if the FastField module you need is missing in Make?
Use Make an API Call. It calls any endpoint of the FastField API with the connection you already set up, so you can cover actions the listed modules leave out, as long as the FastField API offers them. You write the request yourself, which takes a look at the FastField API documentation. The Make documentation for this app also notes that its content is generated from FastField's own docs and may contain mistakes, so verify important details with FastField.
05Should you use Make or n8n for FastField?
It depends on the tool your team already runs and the modules you need. On the Make side, FastField comes with 1 instant trigger, 6 actions and 3 searches, plus Make an API Call for the rest, and it runs on the Free plan. Many apps also have an n8n node, so check whether FastField is covered there before you decide. Compare the two on the actions your process requires, not on habit; the n8n vs Make comparison on this site lays out the criteria.
Same platform

Other docs you might need on this stack.

Browse all integrations