You've already seen how events trigger flows in the Events & Flows Overview lesson.
Now let's zoom in on the specific behaviors you can react to - the things your subscribers do that can kick off automations, send emails, update their data, or change what they receive from you.
There are five main categories of behavior triggers in Bento:
- Someone clicks a link in your email
- Someone performs an action in your app, website, or course
- A third-party tool fires (Zapier, Make, N8N, webhooks)
- A direct integration sends events automatically (e.g. Shopify, Stripe, WooCommerce, LearnDash, etc.)
- Someone visits a specific page on your website
For the full reference on how events work, see the Events documentation.
Let's walk through each.
How To Find Out What Data an Event Carries
Before we start, quick note:
Across all of these trigger types, you'll run into the same question: "What details actually come through with this event?"
Here's a quick way to find out:
- Trigger the event - submit a form, make a test purchase, click a link, or fire it manually via the API
- Go to the subscriber's profile in Bento
- Find the event in their activity timeline and expand it
You'll see the full details payload right there - every key-value pair the event carried.
Even better: you can tap on a detail field to copy the Liquid tag for it.
So if you see a field called plan in the event details, tapping it gives you {{ event.details.plan }} - ready to paste into an email template or a magic split.
There's also a Build Flow button on the subscriber's profile page that loads Tanuki with context about that subscriber's events and data.
This is handy when you want Tanuki to scaffold a flow based on a real event that already fired - it'll have the actual event names and detail fields available, instead of you describing them from memory.
When Someone Clicks a Link in Your Email
Bento automatically tracks a $click event every time a subscriber clicks a link in one of your emails.
You don't need to set anything up for this. It happens out of the box.
What makes it useful: each $click event includes the destination URL in event.details.url, so you can build flows that react differently depending on which link was clicked.
Example use cases:
- Someone clicks a pricing link → tag them as
Flag - Interested - Pricingand fire a follow-up email the next day - Someone clicks a specific product link → add them to a product-specific nurture sequence
- Someone clicks a resource download link → set a field tracking which resources they've engaged with
This is one of the easiest behavior triggers to start with because the data is already there.
You just need to build a flow that listens for it.
How URL matching works in flow triggers
When you set up a flow trigger that filters by URL, Bento uses contains matching - it checks whether the URL string you specify appears anywhere inside the full destination URL.
This means you don't need to include the protocol (https://).
Just the path or domain is enough.
It also means that if one URL path is a prefix of another, a broad filter will match both.
For example, if your emails contain links to mysite.com/thanks/course-a and mysite.com/thanks/course-b, and you set your trigger to filter for URLs containing mysite.com/thanks, both link clicks will fire that flow.
That can be useful when you want a single flow to handle all "thank you" page clicks.
But if you only want to catch clicks to one specific page, make your filter specific enough to avoid overlap - e.g., mysite.com/thanks/course-a instead of just mysite.com/thanks.
The same logic applies to $view event triggers for page visits (covered below).
When Someone Does Something in Your App
This is where things get exciting for SaaS companies, course platforms, and anyone with a product that has user accounts.
The pattern: your app sends a custom event to Bento whenever a user does something meaningful.
Bento receives that event, and a flow reacts to it.
Events can be sent to Bento through the API, an SDK, or the Bento.js tracking script.
Example: SaaS onboarding
Say you have a project management tool and want to send different emails based on how far someone has gotten through onboarding.
Your app fires events as users complete steps:
$onboarding.created_projectwhen they create their first project$onboarding.invited_teammatewhen they add a team member$onboarding.completed_tutorialwhen they finish the walkthrough
Each event triggers a flow that tags the subscriber, updates an onboarding_status field, and sends the appropriate next email.
When they've completed all steps, the flow marks them as onboarded and moves them into your post-onboarding sequence.
The enterprise version of this
If you work at a larger company where the marketing team doesn't write the code, the process is:
- Decide what user actions you want to react to
- Spec out the event for your engineering team: the event name, what goes in
details, and what goes infields - Have your engineers send that event to Bento whenever the action occurs
- Build your flow around it in Bento
The spec doesn't need to be complicated. A few bullets is enough:
- Event name:
$onboarding.completed_tutorial - Details:
{ "tutorial_name": "Getting Started" } - Fields:
{ "onboarding_status": "tutorial_complete" }
One thing worth knowing: when Bento receives an event, it automatically creates the subscriber if they don't already exist and updates any custom fields included in the event payload.
So you don't need to make separate API calls to create the user and then update their fields. One event does both.
When a Third-Party Tool Fires (Zapier, Make, N8N, Webhooks)
Not every behavior trigger needs to come from your own code.
Plenty of tools can fire events into Bento through Zapier, Make, N8N, or direct webhooks.
The pattern is always the same: something happens in Tool X → Zapier/Make/N8N sends an event to Bento → a flow reacts to it.
Example: Cart abandonment
Someone adds items to their cart in ThriveCart (or Shopify, or any e-commerce platform) but doesn't complete checkout.
ThriveCart fires a webhook to Zapier.
Zapier sends an $abandoned_cart event to Bento with the product details.
Your flow kicks in: wait an hour, send a reminder email, wait another day, send a second nudge with an incentive.
Example: Demo scheduling
Someone books a demo through Calendly.
Calendly fires to Zapier.
Zapier sends a $demo_scheduled event to Bento with the meeting details.
Your flow tags them, updates their status, and fires a pre-call prep email.
The integrations directory lists all the platforms Bento connects with directly.
For anything not on the list, Zapier, Make, N8N, or a direct API call will get you there.
Bento also has an inbound webhook trigger you can add directly to a flow - this lets external tools fire data straight into a specific flow without needing Zapier as a middleman.
We cover this more in the Flow Tips & Performance Optimizations lesson.
When a Direct Integration Sends Events Automatically
Some platforms connect to Bento directly, without needing Zapier etc. as a middleman.
These integrations send events into Bento automatically when things happen on the connected platform.
You'll see them as dedicated trigger types in the flow builder - separate from the generic "New Event" trigger.
The WordPress plugin covers the most ground. Once installed, it automatically tracks events from:
- WooCommerce -
$OrderPlaced,$OrderRefunded,$OrderCancelled,$OrderShipped(plus subscription events like$SubscriptionCreated,$SubscriptionCancelled,$SubscriptionRenewed) - LearnDash -
$CourseCompleted,$LessonCompleted,$QuizCompleted,$UserEnrolledInCourse, and many more - Easy Digital Downloads -
$DownloadPurchased,$DownloadDownloaded,$DownloadRefunded - Form plugins (Elementor Forms, WPForms, ThriveLeads) - custom events on form submission
For the full event list, see the WordPress integration docs.
Shopify and Stripe each have their own direct connections:
- Shopify forwards purchase events and updates subscriber LTV
- Stripe sends
$ChargeSucceededevents with payment amount, currency, and customer details
The big advantage of direct integrations over Zapier/Make/N8N is reliability.
There's no middleware to break, no zap to go stale, and no extra subscription to pay for.
If your e-commerce platform or LMS has a direct Bento integration, use it instead of routing through Zapier.
The full list of supported platforms is on the integrations directory.
When Someone Visits a Page on Your Website
If you install the Bento.js tracking script on your website, Bento can track which pages your subscribers visit.
This gives you $view events with the page URL attached.
The key requirement: identification.
Bento.js starts by tracking visitors anonymously.
It only connects pageview data to a subscriber's profile once the visitor has been identified, meaning Bento knows who they are.
Identification happens when:
- They click a link in one of your Bento emails (Bento cookies them at that point)
- They log in and your app calls Bento's identify function
- They fill out a Bento-powered form on your site
Once identified, all their pageview history - including past anonymous visits from that device - gets associated with their subscriber profile.
Example use cases:
- Someone visits your pricing page → trigger a flow that tags them as interested and sends a follow-up
- Someone visits a specific product page multiple times → flag them for your sales team
- Someone reads three blog posts in a topic category → add them to a topic-specific nurture sequence
URL matching works the same way here as with link clicks - Bento uses contains matching on the page URL, so mysite.com/pricing will match mysite.com/pricing, mysite.com/pricing/enterprise, and anything else with that string in the URL.
Be specific with your filters if you need to target one exact page.
Worth noting: this only works for identified visitors.
If someone has never clicked a Bento email link, logged in, or filled out a form, their page visits stay anonymous and won't trigger subscriber-specific automations.
For most email-first businesses, this isn't a problem - your subscribers have already clicked a link from you at some point, which means they're already identified.
For the full setup details, see the Bento.js (Web Tracking) documentation.
How These Fit Together
These five trigger types cover most of the behavior-based automations you'll want to build:
- Link clicks - the easiest starting point, already tracked automatically
- App events - the most powerful, for product-driven businesses
- Third-party tools - for connecting external platforms via Zapier, Make, N8N, or webhooks
- Direct integrations - for platforms with built-in Bento connectors (e-commerce, LMS, payments)
- Page visits - for website engagement tracking
They all follow the same fundamental pattern you learned in the Events & Flows Overview: something happens (event) → Bento reacts (flow).
The difference is just where that "something" originates.
In the real-life examples section later, you'll see several of these trigger types working together in production setups - including cart abandonment sequences and event-driven lead magnet delivery.