How to Use Make to Route Inbound Leads to Sales

The short answer: catch each form submission with a custom webhook, drop test entries with a filter, let a Run an agent module label the lead's fit and write a two-line summary, route strong leads to HubSpot and a Slack channel and the rest to a review sheet, store incomplete executions so nothing is lost, then switch it on and read the credits in History after a week. If someone on your team currently pastes form leads into the CRM by hand, this one scenario replaces that job, and at 5 operations a lead the Free plan's 1,000 credits a month covers 200 leads (pricing page, operations guide).

Disclosure: I may earn a commission through some links on this site. It does not change what this page says.

Lead routing is where a small delay costs the most: the form is filled in, and the lead sits in an inbox until somebody looks. A scenario does not get busy. For what Make is and how its plans work, see the Make glossary entry.

What to have ready:

1. A credit budget you have worked out. Make counts an operation each time a module handles a bundle and a trigger once per run (operations guide). For example, a lead that passes the trigger and four modules uses 5 operations, so 300 leads a month x 5 = 1,500 credits, more than the Free plan's 1,000, before the agent's tokens are added.
2. Access to the tools you already use. A form tool that can post to a webhook URL, a Slack channel for sales, and a HubSpot account whose Super Admin has pre-approved the Make app, which Make requires before the connection works (HubSpot app).
3. A written definition of a good lead. Two or three sentences on company size, role and intent, using fields your form already asks for, written as you would brief a new colleague.
4. One number to watch. Strong leads that reached HubSpot this week, against submissions in the form tool for the same week.

Step 1: Create the scenario and its webhook

Click Create scenario, then search for Webhooks > Custom webhook. Next to the Webhook dropdown click Add, give it a unique name and save; Make generates a URL and starts listening (Webhooks app). Paste that URL into your form tool's webhook setting. An instant trigger like this one sets the schedule to Immediately as data arrives, so there is no polling interval to choose (module types).

Step 2: Show Make what the form sends

Submit a test entry, or send a sample request from Postman, so Make can read the fields. Make recommends defining this data structure, and without it the later modules have no fields to map. If the form gains a field later, open the module, click Detect new values and send another sample (Webhooks app).

Step 3: Filter out entries that are not leads

Click the line between the webhook and the next module to add a filter (filtering). Bundles that fail it stop there. Drop submissions from your own email domain and entries with an empty message field. Filtering before the agent matters for cost: every bundle you stop here never reaches a module that charges for tokens.

Step 4: Let an agent label the lead

Add Make AI Agent (New) > Run an agent (agent guide). In Connection, the Free plan uses Make's AI Provider; paid plans can connect OpenAI or Anthropic Claude instead. In Instructions, paste your definition of a good lead and tell the agent what it must not do: no guessing at missing company data, no promises. In Input, map the form fields. Set Response format to Data structure with two fields, fit (high, medium or low) and summary, so the next module can read the answer instead of parsing prose.

Give this agent no tools. It labels and summarises; it does not email anyone or change records. A person on the sales team reads the summary in Slack and decides whether to call. Test the agent first with Chat with Agent, which lets you send sample leads and adjust the instructions until the labels look right. Make lists the app as an open beta whose features and pricing may change (app reference), so keep the instructions in a document you control as well.

Step 5: Route by the label

Insert a router after the agent (router). On the first route, set a filter for fit equal to high, then add HubSpot CRM > Create or Update a Contact (HubSpot app) and a Slack module that posts the summary to the sales channel (Slack app). Mark the second route as the fallback, which runs last and catches everything the first route did not, and send it to a Google Sheets row for a weekly look. Routes run one after another, not in parallel, so put the route that must not wait first.

Step 6: Catch failures before they cost a lead

Open Scenario settings with the gear icon and turn on Store incomplete executions. It is off by default; with it on, a failed run is saved so you can retry it instead of losing the lead (incomplete executions). Leads are personal data, so consider Keep data confidential, which stops Make keeping the payload in its logs at the price of fewer ways to debug (scenario settings).

Step 7: Switch it on, then read the first week

Save the scenario and activate it. After seven days, open the History tab: each run shows its status, operations completed and credits consumed (scenario history). Compare the high-fit leads in HubSpot with submissions in the form tool. A gap means a filter or a mapping is eating leads; read the run details to see which module returned the unexpected value.

What Make's documentation warns about

• The first error switches the scenario off. When a scenario starts with an instant trigger, Make ignores the errors-before-deactivation setting and deactivates it at the first error (scenario settings). Someone has to notice and switch it back on.
• A full webhook queue drops data. Each queue holds 667 items per 10,000 licensed credits, up to 10,000, and Make rejects requests over the limit; it also accepts 300 webhook requests per 10 seconds and answers anything above that with a 429 error (webhooks).
• Stored failures use storage. Incomplete executions count toward the plan's storage, and with Discard data if storage is full switched on, failed data is gone for good (scenario settings).
• Tools inflate token use. The agent guide warns that several MCP servers and tools mean high token usage, and that Anthropic's tool-use system prompt raises credit consumption (agent guide).

Make earns more when bundles multiply, so the cheapest improvement sits upstream: filter early, keep the agent to one call per lead, and let the router do the branching rather than a second agent.

FAQ

Does the agent need its own OpenAI account?

Not on the Free plan, which uses Make's AI Provider and bills tokens and operations in credits. On a paid plan you can connect your own OpenAI or Claude account; you then pay that provider for tokens and Make for operations (credits).

How many leads a month fit in the Free plan?

It depends on the modules each lead passes. For example, at 5 operations a lead, 1,000 credits / 5 = 200 leads a month, less whatever the agent spends on tokens through Make's AI Provider (credits).

Where do I see what a single run cost?

Run the scenario once and look at the bubbles above each module: the first number is operations, the coin is credits, once you toggle credits on next to the scenario name (operations guide).