How to Automate Trend Monitoring in Make.com

Teams searching for make.com trend monitoring automation want live signals—rising topics, velocity spikes, or brand mentions—to trigger alerts, briefs, or actions without manual checks. Make is an AI workflow automation platform that connects 3,500+ apps, supports custom webhooks as instant triggers, includes native AI Web Search for real-time internet results, and offers an MCP server so external AI clients can run scenarios. Pairing it with a structured trend source turns those capabilities into reliable monitoring.

TrendsAGI supplies the missing layer: real-time detection of topics gaining attention, measured velocity (posts per hour from stored snapshots), growth, AI insights (summary, themes, sentiment, audience, marketing angles), and signed webhooks or a REST API that feed Make scenarios. This guide shows how to wire TrendsAGI signals into Make for alerts, history storage, and optional agent access, using only supported paths.

What you need before starting

A TrendsAGI account with an API key created in the profile, and a Make account (free plan includes credits and active scenarios sufficient to build and test). Make processes webhook data in parallel by default unless “Process data in order” is enabled. Webhook queues hold up to 667 items per 10,000 monthly credits licensed, with a hard maximum of 10,000; full queues reject incoming data. Webhooks unused for more than 5 days (120 hours) are deactivated and return 410 Gone.

Method 1: Instant delivery with TrendsAGI webhooks into Make

TrendsAGI signed outbound webhooks push trend_velocity or trend_category events. Create the subscription via the REST API, point it at a Make custom webhook URL, test, then activate.

Create the Make custom webhook

In Make, add a Custom webhook module as the trigger of a new scenario. Copy the generated HTTPS URL. This URL receives data over HTTPS and acts as an instant trigger. Keep the scenario inactive until the TrendsAGI side is ready.

Subscribe via TrendsAGI REST API

Authenticate with header X-API-Key or Authorization: Bearer. POST to create the subscription. New subscriptions start paused.

import os
import requests

api_key = os.environ["TRENDSAGI_API_KEY"]
headers = {"X-API-Key": api_key, "Content-Type": "application/json"}

payload = {
    "url": "https://hook.make.com/your-unique-path",
    "trigger_type": "trend_velocity",
    "delivery_mode": "threshold",
    "threshold_value": 50,
    "cooldown_seconds": 300
}

r = requests.post(
    "https://api.trendsagi.com/api/integrations/webhooks",
    headers=headers,
    json=payload
)
print(r.json())  # note the one-time signing_secret and webhook id

For category monitoring use trigger_type "trend_category", delivery_mode "instant_stream", and keywords set to the category names. Store the signing_secret securely; rotate later with POST /api/integrations/webhooks/{id}/rotate-secret if needed.

Test, map fields, and activate

Send POST /api/integrations/webhooks/{id}/test. Make receives a JSON body. Map only the fields that actually arrive—do not assume names. Verify the signature on every delivery: the header X-Webhook-Signature is the lowercase hex HMAC-SHA256 of the exact raw request body keyed with the signing secret. Compare with a constant-time function against the unmodified raw bytes. After a successful test, PATCH the webhook:

requests.patch(
    f"https://api.trendsagi.com/api/integrations/webhooks/{webhook_id}",
    headers=headers,
    json={"is_active": True}
)

Inspect delivery attempts with GET /api/integrations/webhooks/{id}/executions. In Make, enable the scenario. High-velocity events now arrive as instant triggers.

Method 2: Poll the TrendsAGI REST API on a schedule

When instant delivery is not required, use Make’s HTTP module or a scheduled scenario to call GET /api/trends. Supported query parameters include category, search, sort_by (velocity|growth|volume|timestamp|name), sort_dir, limit, page, and period.

import os
from trendsagi import TrendsAGIClient

client = TrendsAGIClient(api_key=os.environ["TRENDSAGI_API_KEY"])
trends = client.get_trends(category="Technology", sort_by="velocity", limit=5)
for t in trends:
    print(t["id"], t["name"], t.get("velocity"))

In Make, configure an HTTP module with the same endpoint and header. Parse the JSON response, then route items whose velocity or growth exceeds your threshold. Add AI insights with GET /api/trends/{id}/ai-insights or analytics via GET /api/trends/{id}/analytics?period=24h|7d|30d.

Enrich signals and route actions inside Make

After the webhook or HTTP module, insert Make AI Web Search to pull supporting context for any query without external scrapers or extra accounts. It is available on all plans and consumes credits based on model usage. Use it for brand or competitor mention checks, keyword monitoring, or curating results before pushing to Slack, email, or a data store.

Route high-urgency items with a Router module: one path to Slack (or email/Notion) for immediate alerts, another to a data store or Google Sheets export for sourced history. TrendsAGI also supports native Slack notifications and Google Sheets exports, so you can combine both platforms. Keep the original source links or trend IDs so every alert remains evidence-backed.

For recommendations or crisis events, call GET /api/intelligence/recommendations or GET /api/intelligence/crisis-events, then POST an action when needed. Watchlist interests are managed with GET/POST /api/user/interests using alert_condition_type volume_threshold or percentage_growth.

Expose the scenario to AI agents via Make MCP

Make’s MCP server lets AI systems such as Claude and ChatGPT run active on-demand scenarios. Scenario-run tools are available on all plans; management tools (view/modify scenarios, connections, webhooks, data stores) require paid plans. Once your trend-monitoring scenario is stable, expose it so an agent can request current velocity for a category or trigger a brief. TrendsAGI itself supplies matching agent tools via its Python SDK (TrendsAGITools) and MCP server (pip install "trendsagi[mcp]" then trendsagi mcp), which can complement the Make side.

Practical use cases

• Marketing or SEO teams already in Make: continuous category or keyword monitoring that feeds Slack without a separate monitoring SaaS.
• Agencies: scheduled briefs that combine TrendsAGI velocity events with Make AI Web Search results and push curated dashboards to clients.
• Product and competitive-intelligence teams: replace weekly manual checks with sourced scenarios that store history and alert on growth thresholds.
• Developers building AI agents: package the finished Make scenario as an MCP tool so agents query live trend status on demand.

Troubleshooting and practical limits

• Webhook returns 410 Gone: the hook was inactive more than 5 days. Recreate or reactivate and reconnect to a scenario.
• Incoming data rejected: queue is full (667 items per 10k credits, hard max 10k). Reduce frequency, enable ordered processing only when necessary, or increase credits.
• Signature verification fails: ensure you hash the exact raw body bytes with the current signing secret and use constant-time comparison.
• Credit consumption rises: frequent AI Web Search or AI modules burn credits based on model usage. Prefer threshold webhooks over high-frequency polling, and filter noise inside the scenario before enrichment.
• Missing fields after a test delivery: map only what arrives; the delivery body schema is not published for invention.
• Rate or authentication errors on REST calls: confirm the X-API-Key or Bearer header and check GET /api/user/api-usage.

Velocity remains a measured snapshot rate, not a forecast or unique-user count. Recommendation confidence reflects evidence completeness, not probability of success. When pure Make-native sources (AI Web Search, RSS, custom webhooks) lack structured velocity and AI insights, the TrendsAGI layer supplies the difference.

Frequently asked questions

How do I set up a scheduled or webhook-triggered Make scenario to monitor search trends or brand mentions?

Create a Custom webhook in Make as the trigger, subscribe TrendsAGI to that URL with the desired trigger_type and threshold, test the delivery, map the arriving fields, then activate both sides. For scheduled monitoring use Make’s scheduler plus an HTTP module calling GET /api/trends with category or search filters.

What native Make modules (AI Web Search, RSS, webhooks) can pull trend data without external scrapers?

Custom webhooks act as instant triggers for external events. Make AI Web Search retrieves live internet results for any query on all plans without scrapers or extra accounts. RSS modules can supplement for public feeds. Structured velocity and AI insights still come from TrendsAGI via webhook or REST.

How do I turn trend signals into alerts in Slack, email, or Notion and keep a sourced history?

After the trigger, use a Router to send high-urgency items to Slack, email, or Notion modules and store every item (with original trend ID or source) in a data store or Google Sheets. TrendsAGI also offers direct Slack notifications and Google Sheets exports that can run in parallel.

What are the credit costs, queue limits, and plan differences that affect high-frequency trend monitoring?

Credits replaced operations as Make’s billing unit; most actions cost 1 credit while AI features consume more based on model usage. Webhook queues hold 667 items per 10,000 credits licensed (hard max 10,000). Free plan supports real automations; scenario-run MCP tools are available on all plans while management tools need paid plans. Exact credit cost of a single AI Web Search call is not published beyond model-based consumption.

Can I expose a trend-monitoring scenario to an AI agent via Make’s MCP server?

Yes. Make MCP server allows AI systems to run active on-demand scenarios on all plans. Once the scenario is built and active, agents can trigger it for live trend status. Management capabilities require paid plans.

What are the practical limits and failure modes (queue full, rate limits, inactive webhooks) I need to handle?

Handle full queues by reducing delivery frequency or increasing credits. Reactivate any webhook deactivated after 5 days of no scenario connection. Verify signatures on every delivery, monitor API usage, and filter inside Make before expensive AI enrichment to control credit burn and noise.

How we researched this

Prepared by TrendsAGI Research. Facts checked on 19 October 2026 against the sources listed below.

We read the official Make documentation listed below. The TrendsAGI steps and code use its documented REST API and Python SDK; confirm the Make side against its current documentation, since third-party products change.

We re-research and rewrite this page at least every four months; the updated date only changes when the facts are re-checked.

Sources

• Webhooks - Help Center (Make) — help.make.com
• AI Workflow Automation Software & Tools | Make — make.com
• Make MCP Server | MCP Server | Make Developer Hub — developers.make.com

Try it with TrendsAGI

• All TrendsAGI integration guides
• TrendsAGI API documentation
• More guides and trend analysis