Resources · Make integration

Reviewly Make integrationAutomate Reviewly with Make.

Can Make pick up Reviewly projects and reviews without anyone copying them by hand? The Reviewly Make integration gives you 8 modules: 2 triggers, 3 actions and 3 searches. This guide shows how to link your account and build a first scenario, step by step.

Try the Reviewly integration on MakeSee the 8 modules

Verified Trustpilot reviews · AI, automation & growth agency

What you can automate

What does the Reviewly Make integration let you automate?

The Reviewly Make integration links your Reviewly account to Make, a no-code tool where you chain apps together. You build a scenario (the automation itself) out of modules (one brick each: a trigger, an action or a search), and Make runs it for you once it is switched on.

Candidate invites that start from another tool. When a new applicant shows up in the app where you collect them, Invite a Candidate sends the Reviewly invitation, so nobody has to retype a name.

A heads-up whenever a review is in. Watch Submitted Reviews picks up each new review and hands it to the next module, which can post it where your hiring team already works. Watch Submitted Projects does the same for projects.

A quick export of what sits in Reviewly. List Candidates, List Projects and List Reviews each return a set of items you can push into a sheet or another app.

Know the limits before you start. Make's own documentation for Reviewly is thin: it says there is not enough public information about the app to describe it in detail, so the modules come with no official description. When a module you need is missing, Make an API Call reaches the rest of the Reviewly API with the same connection. If you are still weighing tools, the n8n vs Make comparison lays out the differences, Make pricing explains how operations are counted, and the Make training covers scenarios from scratch.

Connect

How do you connect Reviewly to Make?

  1. 01

    Add a Reviewly module

    Open your scenario, click the +, search for Reviewly and pick any of its modules. In the module panel, click Create a connection. A connection is your Reviewly account linked to Make once, then reused by every Reviewly module.

  2. 02

    Name the connection

    Make offers a name field for the connection. It is optional, but a clear label such as the workspace or team it belongs to helps when you later link a second Reviewly account and need to tell them apart.

  3. 03

    Authorize and save

    Depending on what Make asks for, either approve access on the Reviewly page that opens or paste the key Reviewly gives you. Then click Save, and the module can start reading your Reviewly data.

First scenario

Your first scenario with Reviewly

GoalWhen a new applicant lands in the tool where you collect them, Make sends that person a Reviewly invitation.

  1. 01

    Create the scenario

    Go to the Scenarios page, create a new scenario and click the +. The first module comes from the app where your applicants arrive, such as a form or a spreadsheet.

  2. 02

    Set up the first module

    Pick that app's trigger, connect its account and choose the form or sheet to watch. Make lists what it can read once the connection exists, so there is nothing to type from memory.

  3. 03

    Add Invite a Candidate

    Click the + on the right of the first module, search for Reviewly and choose Invite a Candidate. Link your Reviewly connection, then map the applicant details coming from the first module into the fields Make shows.

  4. 04

    Test with Run once

    Click Run once. Make runs the scenario a single time and shows the bundles each module received (a bundle is one item passed along, here one applicant). Check that the invitation went to the right person.

  5. 05

    Schedule and switch on

    Open the clock on the first module to set the schedule: 15 minutes by default, 1 minute at best on a paid plan. Then flip the scenario on, and new applicants get their invitation without you.

Triggers

What can start a Reviewly scenario?

2 modules start a scenario when something happens in Reviewly. A scheduled trigger is checked by Make on the scenario's schedule; an instant one is called by Reviewly as soon as it happens.

Reviewly1Watch Submitted Projects

Watch Submitted Projects

triggerIn the docs only

This trigger opens your scenario each time a project reaches the submitted stage in Reviewly, so whatever comes next starts from a fresh submission instead of a manual check.

How it fires
it is a scheduled trigger, meaning Make checks the app on the scenario's schedule and collects the projects submitted since its last look.
When to use it
you want the hiring manager told, or a tracking sheet updated, when a project comes back.
Watch out
the scheduled type is inferred from the module's name and the documentation gives no detail, so check the clock badge, run it once and read the bundles to see which project data it actually returns.
Reviewly2Watch Submitted Reviews

Watch Submitted Reviews

triggerIn the docs only

Here the starting point is a review rather than a project: each review submitted in Reviewly becomes a bundle that flows into the rest of your scenario.

How it fires
scheduled, so Make checks the app on the scenario's schedule, every 15 minutes by default on a new scenario.
When to use it
reviewers finish their assessment and you want the outcome posted to your team chat or logged in your records without anyone forwarding it.
Watch out
every bundle it returns costs an operation in each module that follows (an operation is one module run on one item, the unit Make counts on your plan), so keep the chain short.
Modules

What can Make do in Reviewly?

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

Reviewly1

Get a Candidate

ActionIn the docs only

You get back one candidate's record from Reviewly, ready to map into the next module. It is the module to reach for when you already know which person you mean and need their details.

When to use it
a review has just been submitted and the next step needs the candidate's profile rather than the whole list.
Watch out
the documentation describes none of its options, so open the module after connecting and check what Make offers to point it at a candidate.
Reviewly2

Invite a Candidate

ActionIn the docs only

This action sends a Reviewly invitation to a person, which spares you from adding each applicant by hand. It is the module that turns an entry from another app into an actual Reviewly candidate.

When to use it
someone applies through your careers form or lands in your recruiting sheet, and you want them invited straight away.
Watch out
test with Run once on your own address first, because a real invitation leaves Make as soon as the module runs.
Reviewly3

List Candidates

SearchIn the docs only

You receive the candidates stored in Reviewly as separate bundles, one per person. Choose this search over Get a Candidate when you need the group, not one specific profile.

When to use it
you want to copy every candidate into a spreadsheet to review the pipeline with a hiring manager.
Watch out
a search can return zero, one or many bundles, and each one triggers the modules after it, which adds operations quickly.
Reviewly4

List Projects

SearchIn the docs only

A full view of your Reviewly projects lands in the scenario, each project as its own bundle. It answers a different need than Watch Submitted Projects: it reads what exists now instead of waiting for new submissions.

When to use it
you are setting up a report and need the current projects once, before any trigger takes over.
Watch out
if nothing matches, the search returns zero bundles and the rest of the scenario simply does not run for that pass.
Reviewly5

List Reviews

SearchIn the docs only

Pulling reviews in bulk is what this search is for: every review it finds comes out as a bundle you can map into a sheet, a message or a database.

When to use it
a hiring round closes and you want all its reviews gathered in one place for the final decision meeting.
Watch out
unlike Watch Submitted Reviews, it does not remember what it already returned, so running it again brings back reviews you have already processed.
Reviewly6

Make an API Call

ActionIn the docs only

With this module you can call any endpoint of the Reviewly API while reusing the connection you already set up. It covers whatever the 7 other modules leave out.

When to use it
you need a Reviewly action that has no ready-made module, and the listed ones cannot get you there.
Watch out
you write the request yourself, so you have to know the exact endpoint and what it expects; Make builds nothing for you here. The Make troubleshooting guide helps when a call fails.
Need help

Need help automating Reviewly with Make?

A person reads every message.

FAQ

Reviewly and Make: common questions

01Is the Reviewly Make integration free?
Yes. Reviewly is a standard app in Make, so it works from the Free plan onward. The Free plan has limits you will feel quickly: 2 active scenarios, at least 15 minutes between two scheduled runs, 5 minutes of execution at most per run, files up to 5 MB and 512 MB of data transfer. Paid plans (Core, Pro, Teams and Enterprise) remove the cap on active scenarios, allow a 1-minute interval and 40 minutes of execution. Usage is counted in credits, one per operation, each month.
02What do you need to connect Reviewly to Make?
A Reviewly account and a Make account. The Make documentation lists no prerequisite and no dedicated connection steps for Reviewly, so the usual Make flow applies: add a Reviewly module, click Create a connection, optionally name it, then either approve access on the Reviewly page or paste the key Reviewly provides, and click Save. The connection is created once and reused by all 8 Reviewly modules in every scenario you build.
03Do Reviewly triggers in Make fire instantly?
No, as far as the names tell. Make's documentation does not state their type, but Watch Submitted Projects and Watch Submitted Reviews read as scheduled triggers, and none looks instant. Make checks Reviewly at the interval set on the first module: every 15 minutes by default on a new scenario, never less than 15 minutes on the Free plan, and down to 1 minute on a paid plan. A submission made just after a check waits for the next one. The clock badge on the module in the editor is where you confirm it.
04What if a Reviewly module is missing in Make?
Use Make an API Call. It is part of the Reviewly app in Make and can reach any endpoint of the Reviewly API with the connection you already have, so you are not stuck with the 7 ready-made modules. The catch is that you build the request yourself. Make also warns that its Reviewly documentation is limited because little public information exists about the app, so expect to test each call with Run once before relying on it.
05Should you use Make or n8n for Reviewly?
It depends on what you need and which tool your team already runs. On Make, Reviewly comes with 8 ready modules: 2 scheduled triggers, 3 actions and 3 searches, with Make an API Call among the actions for anything else. Whether n8n offers a Reviewly node is not covered by the sources behind this page, so check that before choosing. If you already build scenarios in Make, staying there keeps your connections and history in one place.
Same platform

Other docs you might need on this stack.

Browse all integrations