# Lead Scoring with AcelleMail Automation — Score, Tag, and Route

> Add points when a subscriber opens a campaign, clicks a key link, or fills a form. Route high-score subscribers to a sales-handoff tag automatically. This guide walks the AcelleMail automation builder + custom-field scoring, with API-driven scoring patterns for ecommerce + CRM integrations in the collapsible section.

- Canonical URL: https://acellesend.com/kb/articles/lead-scoring-with-email-automation
- Author: Sofia Lindqvist, Email Marketing Editor
- Category: Automation — Triggers, workflows, welcome series, drip campaigns, behavioral flows
- Content type: tutorial · Difficulty: intermediate
- Tags: Acellemail
- Published: 2026-05-25 · Last updated: 2026-08-15
- Reading time: 7 min
- Publisher: AcelleMail Knowledge Base, https://acellesend.com/kb

---

## What lead scoring is (and isn't)

Lead scoring is a number on each subscriber that tracks how engaged they are with you. It starts at 0; you bump it up when they do something positive (opened, clicked a buy-link, submitted a form), down when they go quiet (no opens for 60 days, unsubscribed from a list).

When the score crosses a threshold, you route them — to a sales tag for a CSM to call, into a higher-frequency cadence for prospect nurture, into a re-engagement automation for a "we miss you" win-back.

The model is simple. The setup in AcelleMail is straightforward. The discipline part — picking the right point values and the right thresholds — that's the marketing call.

## Setup in three pieces

### Piece 1: Add a `lead_score` field to your list

**Audience → [your list] → Fields → New field**. Configure:

- **Tag (key)**: `lead_score`
- **Type**: Number
- **Default value**: `0`
- **Required at signup**: No

This adds a `{{ subscriber.lead_score }}` merge tag and a per-subscriber numeric value AcelleMail will track + update via automation.

### Piece 2: Build automations that bump the score

### Open the visual automation builder

In AcelleMail's left sidebar, click **Automation** → **Automations**. The index lists every automation in this account with its current state:

![Automations index](https://acellesend.com/plugins/acelle/landing/images/help/kb/welcome-automation/01-automations-index.png)

Click **New automation** in the top-right toolbar. The trigger picker opens:

![Trigger picker — pick what starts the automation](https://acellesend.com/plugins/acelle/landing/images/help/kb/welcome-automation/02-create-trigger-picker.png)


This first automation tracks "opened a campaign":

1. **Trigger**: pick **Email opened** from the trigger picker
2. **Condition** (optional): scope to a specific campaign or "any campaign"
3. **Action**: **Update subscriber field** → `lead_score = lead_score + 5`

Save. The flow now runs every time an open is recorded:

![Automation flow — open → +5 score](https://acellesend.com/plugins/acelle/landing/images/help/kb/welcome-automation/03-flow-builder.png)

Repeat the pattern for higher-value events. Common point values:

| Event | Point bump | Trigger to use |
|---|---|---|
| Email opened | +5 | Email opened |
| Clicked any link | +10 | Link clicked (no specific link) |
| Clicked a buy/upgrade link | +25 | Link clicked with URL filter on `/pricing` or `/upgrade` |
| Submitted a form | +30 | Subscribed to list (form's target list) |
| Visited pricing page (via tracker pixel) | +15 | Custom event from your site |
| Opened from sequential campaigns 3+ times in 7 days | +10 bonus | Compound conditional (see Advanced) |

### Piece 3: Build the routing automation

Once score is being tracked, add a *routing* automation that watches for threshold crossings.

1. **Trigger**: **Field value change** on `lead_score`
2. **Condition**: `lead_score >= 100`
3. **Action**: **Add tag** → `sales-ready`

When you add `sales-ready` to someone, you can either:

- Email your sales team via a separate automation triggered on tag addition
- Webhook the lead into your CRM via the **Send webhook** action
- Add to a high-touch nurture list

### Verify in the automation index

The Automations index lists all running flows + their last-run timestamp + total runs:

![Automation list — see all flows](https://acellesend.com/plugins/acelle/landing/images/help/kb/automation-debug/01-automations-index.png)

Click any automation to see its run history + per-subscriber path:

![Per-flow run details](https://acellesend.com/plugins/acelle/landing/images/help/kb/automation-debug/02-automation-flow.png)

The settings tab shows the configuration + per-run debugging:

![Automation settings](https://acellesend.com/plugins/acelle/landing/images/help/kb/automation-debug/03-automation-settings.png)

## Score values that actually mean something

Don't over-engineer the point values. Start coarse:

| Tier | Score | Action |
|---|---|---|
| Cold | 0-25 | Default cadence, low frequency |
| Warming | 26-75 | Bumped to standard cadence + nurture sequence |
| Hot | 76-150 | Sales-ready tag + CRM handoff |
| Champion | 150+ | High-touch / CSM outreach |

Adjust quarterly based on what actually correlates with conversion in your funnel. The most useful question to ask each quarter: "of last quarter's converted customers, what was their score 30 days before they converted?" That's your real threshold; ignore the round numbers.

## Common pitfalls + fixes

| Symptom | Likely cause | UI fix |
|---|---|---|
| Scores all stuck at 0 | The "field update" automation step uses `=` not `lead_score + 5` | Open the automation step → use "Increment field" mode, not "Set field" |
| Same subscriber scored 50 times for same open | Open-tracking + automation re-fires per pixel-load (some clients fetch the pixel repeatedly) | Add a per-day rate limit in the automation conditions: "only run if last_score_update > 24h ago" |
| Score keeps growing forever even for unengaged | No decay logic | Add a daily-run scheduled automation that subtracts 1 from everyone's score |
| `sales-ready` tag never gets added despite high scores | The routing automation uses an old threshold (`>= 50`) | Edit the routing automation's condition, re-save |
| Customer-success team complains about wrong-stage leads | Threshold mis-calibrated | Audit converted customers' pre-conversion scores; adjust threshold |

<details>
<summary><strong>Advanced: API-driven scoring from ecommerce, CRM, and product analytics</strong></summary>

The AcelleMail automation builder handles the email-side events (open, click, form submit) natively. For non-email events (purchases, app logins, support tickets), you push score updates via the API.

**Increment a subscriber's score via API:**

```bash
ACELLE_TOKEN="..."
ACELLE_LIST_UID="..."

# Get current score
current=$(curl -s -H "Authorization: Bearer $ACELLE_TOKEN" \
  "https://acellemail.com/api/v1/subscribers?email=user@example.com&list_uid=$ACELLE_LIST_UID" \
  | jq -r '.data[0].fields.lead_score')

new=$((current + 25))

# Update
curl -X PATCH "https://acellemail.com/api/v1/subscribers/{subscriber_uid}" \
  -H "Authorization: Bearer $ACELLE_TOKEN" \
  -H "Content-Type: application/json" \
  -d "{\"fields\": {\"lead_score\": $new}}"
```

A simpler pattern: use AcelleMail's **Custom event** trigger + an automation step "Increment field":

```bash
# Fire a custom event with the score delta in payload
curl -X POST "https://acellemail.com/api/v1/events" \
  -H "Authorization: Bearer $ACELLE_TOKEN" \
  -d '{
    "subscriber_email": "user@example.com",
    "event": "purchase_completed",
    "value": 25
  }'
```

Then build an automation triggered by `event = purchase_completed` → step "Increment lead_score by event.value". One API call, score bumped, all logic in the automation flow.

**Shopify integration pattern:**

Shopify → Webhook → your bridge service → AcelleMail API. Common point values from Shopify webhooks:

```
cart_started:       +15
cart_abandoned:     +5  (after timeout — still engaged)
checkout_completed: +50
order_refunded:     -25
```

The bridge service can be a Cloudflare Worker, an AWS Lambda, a Vercel Edge function — anywhere that maps Shopify's webhook signature to AcelleMail's auth.

**Salesforce integration pattern:**

Use Salesforce Flow to call AcelleMail's API on Lead status changes:

```
Lead status → Marketing Qualified: AcelleMail tag "mql" + score +30
Lead status → Sales Qualified: AcelleMail tag "sql" + score +60
Lead converted to Opportunity: AcelleMail tag "opportunity" + score +100
```

When AcelleMail sees the `sales-ready` threshold crossing, it can webhook back to Salesforce to create a Task. Two-way sync, both systems agree on the score and the stage.

**HubSpot integration pattern:**

HubSpot's "contact property" sync via webhook to AcelleMail mirror — when HubSpot's native scoring changes, push the new value to AcelleMail's `lead_score` field. Single source of truth (HubSpot), AcelleMail just reads the value.

**Decay automation** (daily-run cron):

```bash
# Run via php artisan scheduler or external cron
php artisan tinker --execute='
  $subscribers = \App\Model\Subscriber::where("fields->lead_score", ">", 0)->get();
  foreach ($subscribers as $s) {
    $current = (int) ($s->fields["lead_score"] ?? 0);
    $newValue = max(0, $current - 1);
    $s->update(["fields" => array_merge($s->fields ?? [], ["lead_score" => $newValue])]);
  }
'
```

OR use AcelleMail's built-in scheduled automation: trigger "Date relative" = "every day at 03:00", action "Decrement field by 1".

**Multi-signal scoring** — score from multiple sources stays meaningful only if you can debug it. Log every score change with the reason. Store it in a custom field `lead_score_log` (JSON-encoded array) so a sales rep looking at a hot lead can see *why* they're hot:

```
{
  "lead_score": 85,
  "lead_score_log": [
    {"delta": 25, "reason": "shopify.cart_started", "at": "2026-05-10"},
    {"delta": 50, "reason": "shopify.checkout_completed", "at": "2026-05-12"},
    {"delta": 10, "reason": "email.click", "at": "2026-05-15"}
  ]
}
```

This becomes invaluable when investigating "why did this lead score 85?" — without the log, you're guessing.

</details>

## Related articles

- [Advanced automation triggers and conditions](https://acellesend.com/kb/articles/advanced-automation-triggers-and-conditions)
- [Building a welcome email series in AcelleMail](https://acellesend.com/kb/articles/building-a-welcome-email-series-in-acellemail)
- [Using API triggers for custom automation workflows](https://acellesend.com/kb/articles/using-api-triggers-for-custom-automation-workflows)
- [Re-engagement campaigns — win back inactive subscribers](https://acellesend.com/kb/articles/re-engagement-campaigns-win-back-inactive-subscribers)

---

## Related articles

- [Build a Welcome Email Series in AcelleMail (Visual Flow Builder)](https://acellesend.com/kb/articles/building-a-welcome-email-series-in-acellemail): AcelleMail's automation builder ships with 12 triggers. "Welcome new subscribers" + 5 email nodes + a WAIT + a YES/NO CONDITION gives you a working welcome series in 30 minutes. Walkthrough with the actual flow canvas.
- [Automation Triggers + Conditions: Full Reference](https://acellesend.com/kb/articles/advanced-automation-triggers-and-conditions): Complete reference for AcelleMail's 12 built-in triggers, the CONDITION node operators, and the OPERATION actions. Plus the multi-branch patterns power users actually deploy.
- [Post-Purchase Follow-Up Automation in AcelleMail — Thank, Review, Cross-Sell](https://acellesend.com/kb/articles/post-purchase-follow-up-automation): A confirmation email is just the start. Layer in a delivery-day check-in, a 7-day review request, a 30-day cross-sell, a 60-day "we miss you". This guide builds the full post-purchase flow in AcelleMail's automation builder using tags or custom events fired from your ecommerce backend.
- [Birthday & Anniversary Automations in AcelleMail — Date-Triggered Sends](https://acellesend.com/kb/articles/birthday-and-anniversary-email-automations): Send a happy-birthday discount on the day, a year-since-signup gift on the anniversary, a renewal reminder 30 days before expiry. AcelleMail's date-relative automation trigger handles all of these — this guide walks the setup with screenshots.
- [API Triggers for Custom Automations — Wiring AcelleMail to Anything](https://acellesend.com/kb/articles/using-api-triggers-for-custom-automation-workflows): Your CRM, app, or backend can fire AcelleMail automations directly — no Zapier, no manual tagging. This guide walks the UI setup (custom-event triggers + API token generation) plus a complete payload + signing reference in the collapsible developer section.