suppress-ghost-contacts

name	suppress-ghost-contacts
description	Identify and suppress ghost contacts who received marketing emails but never opened any. These contacts destroy sender reputation and deliverability. Hybrid approach: API for discovery, manual UI for suppression.
license	MIT
metadata	{"author":"tomgranot","version":"1.1","category":"database-hygiene"}

Suppress Ghost Contacts (Delivered, Never Opened)

Purpose

Ghost contacts have received marketing emails but have never opened a single one. They are the largest threat to email deliverability because ISPs like Gmail and Microsoft track engagement at the sender level. Consistently sending to people who never open signals that the sender is producing unwanted email, causing inbox placement to deteriorate even for engaged contacts.

Prerequisites

• A HubSpot private app access token with crm.objects.contacts.read and crm.lists.read/crm.lists.write scopes
• Python 3.10+ with uv for package management
• A .env file containing HUBSPOT_ACCESS_TOKEN
• Super Admin or Marketing Hub Admin permissions for the manual UI suppression step

Scripts

Stage	Script	Run with
Before	scripts/before.py	uv run skills/suppress-ghost-contacts/scripts/before.py
After	scripts/after.py	uv run skills/suppress-ghost-contacts/scripts/after.py

There is no execute script: the marketing-status change itself must happen via a HubSpot workflow or the UI (see Key Constraint and Stage 3).

Key Constraint

hs_marketable_status is read-only via the API. Suppression must happen in the HubSpot UI.

CRITICAL: "Never Opened" Is Null, Not Zero

HubSpot stores "never opened" as a null/absent property, not as the number 0. You MUST use the NOT_HAS_PROPERTY operator to find contacts who have never opened an email. Using EQ 0 will return zero results because the property is not set at all for these contacts.

# CORRECT - finds contacts who have never opened
{"propertyName": "hs_email_open", "operator": "NOT_HAS_PROPERTY"}

# WRONG - returns nothing because the property does not exist on these contacts
{"propertyName": "hs_email_open", "operator": "EQ", "value": "0"}

The same applies to hs_email_bounce -- "never bounced" is also null.

Execution Pattern

This skill follows a 4-stage execution pattern: Plan -> Before -> Execute -> After.

Stage 1: Plan

Before writing any code, confirm with the user:

1. Graduated approach: Recommend suppressing only contacts above your delivery threshold (typically 5-15, adjust based on your email cadence) first. Contacts below that threshold may not have had enough chances to engage.
2. Overlap with previous processes: Some ghost contacts may already be non-marketing from hard-bounce or unsubscribe suppression. The Before State will measure this overlap.
3. Open tracking caveat: Some email clients block tracking pixels. However, at the scale of thousands of contacts with zero opens across multiple sends, the overwhelming majority are genuinely unengaged.
4. Apple Mail Privacy Protection: Introduced in iOS 15 / macOS Monterey, it pre-loads tracking pixels, which can create false-positive opens. Contacts who do NOT show opens despite this feature are almost certainly truly unengaged.

Stage 2: Before

Discover all ghost contacts, break down by delivery volume, and generate an audit CSV.

"""
Before State: Count and audit ghost contacts.
Definition: emails delivered > 0, emails opened = null, emails bounced = null.
"""
import os
import csv
import time
import requests
from dotenv import load_dotenv

load_dotenv()

TOKEN = os.environ["HUBSPOT_ACCESS_TOKEN"]
BASE = "https://api.hubapi.com"
headers = {
    "Authorization": f"Bearer {TOKEN}",
    "Content-Type": "application/json",
}

url = f"{BASE}/crm/v3/objects/contacts/search"

# Ghost contact filter definition
GHOST_FILTERS = [
    {"propertyName": "hs_email_delivered", "operator": "GT", "value": "0"},
    {"propertyName": "hs_email_open", "operator": "NOT_HAS_PROPERTY"},
    {"propertyName": "hs_email_bounce", "operator": "NOT_HAS_PROPERTY"},
]

# --- Step 1: Total ghost contacts ---
resp = requests.post(url, headers=headers, json={
    "filterGroups": [{"filters": GHOST_FILTERS}],
    "limit": 1,
})
resp.raise_for_status()
total_ghosts = resp.json().get("total", 0)
print(f"Total ghost contacts: {total_ghosts}")

# --- Step 2: How many are still marketing? ---
resp2 = requests.post(url, headers=headers, json={
    "filterGroups": [{"filters": GHOST_FILTERS + [
        {: , : , : },
    ]}],
    : ,
})
resp2.raise_for_status()
still_marketing = resp2.json().get(, )
already_non_marketing = total_ghosts - still_marketing
()
()


()
brackets = [
    (, , ),
    (, , ),
    (, , ),
]

 label, gt_val, lte_val  brackets:
    resp_b = requests.post(url, headers=headers, json={
        : [{: [
            {: , : , : gt_val},
            {: , : , : lte_val},
            {: , : },
            {: , : },
        ]}],
        : ,
    })
     resp_b.status_code == :
        ()
    time.sleep()


resp_50 = requests.post(url, headers=headers, json={
    : [{: [
        {: , : , : },
        {: , : },
        {: , : },
    ]}],
    : ,
})
 resp_50.status_code == :
    ()


WORST_OFFENDER_THRESHOLD =   
resp_worst = requests.post(url, headers=headers, json={
    : [{: [
        {: , : , : (WORST_OFFENDER_THRESHOLD - )},
        {: , : },
        {: , : },
    ]}],
    : ,
})
resp_worst.raise_for_status()
worst_offenders = resp_worst.json().get(, )
()

Step 4: Export full CSV using segmented queries

The Search API caps at 10K results. For ghost contacts (often >10K), segment by delivery volume brackets to bypass the limit.

# --- Step 4: Full CSV export using segmented queries ---
PROPS = [
    "email", "firstname", "lastname", "hs_email_delivered",
    "hs_email_open", "hs_email_bounce", "hs_marketable_status",
    "lifecyclestage", "createdate",
]

# Each segment must be under 10K for full pagination
SEGMENTS = [
    ("1-5 delivered", "0", "5"),
    ("6-10 delivered", "5", "10"),
    ("11-20 delivered", "10", "20"),
    ("21-35 delivered", "20", "35"),
    ("36-50 delivered", "35", "50"),
    ("51+ delivered", "50", None),
]

all_contacts = []

for label, gt_val, lte_val in SEGMENTS:
    seg_filters = [
        {"propertyName": "hs_email_delivered", "operator": "GT", "value": gt_val},
        {"propertyName": "hs_email_open", "operator": "NOT_HAS_PROPERTY"},
        {"propertyName": "hs_email_bounce", "operator": "NOT_HAS_PROPERTY"},
    ]
    if lte_val:
        seg_filters.append(
            {"propertyName": "hs_email_delivered", "operator": , : lte_val}
        )

    after = 
    seg_count = 
     :
        payload = {
            : [{: seg_filters}],
            : PROPS,
            : ,
        }
         after:
            payload[] = after

        resp = requests.post(url, headers=headers, json=payload)
         resp.status_code != :
            

        data = resp.json()
         contact  data.get(, []):
            props = contact.get(, {})
            all_contacts.append({
                : contact[],
                : props.get(, ),
                : props.get(, ),
                : props.get(, ),
                : props.get(, ),
                : props.get(, ),
                : props.get(, ),
                : props.get(, ),
                : props.get(, ),
                : props.get(, ),
            })
            seg_count += 

        paging = data.get(, {})
        after = paging.get(, {}).get()
          after:
            
        time.sleep()

    ()

os.makedirs(, exist_ok=)
csv_path = 

 (csv_path, , newline=)  f:
    writer = csv.DictWriter(f, fieldnames=[
        , , , , ,
        , , ,
        , ,
    ])
    writer.writeheader()
    writer.writerows(all_contacts)

()

Stage 3: Execute

Step 3a: Create HubSpot active lists via API

Create two lists: a main suppression list and a worst-offender review list.

"""
Execute (API part): Create HubSpot active lists.
"""

# Main ghost list
list1_payload = {
    "name": "CLEANUP: Ghost Contacts - Never Opened",
    "objectTypeId": "0-1",
    "processingType": "DYNAMIC",
    "filterBranch": {
        "filterBranchType": "OR",
        "filterBranches": [
            {
                "filterBranchType": "AND",
                "filterBranches": [],
                "filters": [
                    {
                        "filterType": "PROPERTY",
                        "property": "hs_email_delivered",
                        "operation": {
                            "operationType": "NUMBER",
                            "operator": "IS_GREATER_THAN",
                            "value": 0,
                        },
                    },
                    {
                        "filterType": "PROPERTY",
                        "property": "hs_email_open",
                        "operation": {
                            "operationType": "ALL_PROPERTY",
                            "operator": "IS_UNKNOWN",
                        },
                    },
                    {
                        "filterType": "PROPERTY",
                        "property": "hs_email_bounce",
                        : {
                            : ,
                            : ,
                        },
                    },
                ],
            }
        ],
        : [],
    },
}

resp1 = requests.post(, headers=headers, json=list1_payload)
 resp1.status_code  (, ):
    lid1 = resp1.json().get()  resp1.json().get(, {}).get()
    ()
 resp1.status_code == :
    ()


list2_payload = {
    : ,
    : ,
    : ,
    : {
        : ,
        : [
            {
                : ,
                : [],
                : [
                    {
                        : ,
                        : ,
                        : {
                            : ,
                            : ,
                            : ,  
                        },
                    },
                    {
                        : ,
                        : ,
                        : {
                            : ,
                            : ,
                        },
                    },
                    {
                        : ,
                        : ,
                        : {
                            : ,
                            : ,
                        },
                    },
                ],
            }
        ],
        : [],
    },
}

resp2 = requests.post(, headers=headers, json=list2_payload)
 resp2.status_code  (, ):
    lid2 = resp2.json().get()  resp2.json().get(, {}).get()
    ()
 resp2.status_code == :
    ()

Step 3b: Suppress contacts in HubSpot UI

Instruct the user:

1. Open the list "CLEANUP: Ghost Contacts - Never Opened" in HubSpot
2. Click the checkbox in the table header row
3. Click "Select all N contacts in this list"
4. Click More > Set marketing contact status
5. Select Set as non-marketing contact
6. Click Confirm

Graduated approach recommendation: If the user prefers a conservative approach, suppress only the "REVIEW: Ghost Contacts - High Delivery No Opens" list first. Monitor contacts below your delivery threshold separately -- they may engage with future emails.

Step 3c: Keep both lists active permanently

• The main list captures new ghost contacts over time as emails are sent
• The review list grows as contacts accumulate more delivered emails with no engagement
• Run suppression monthly; review for deletion quarterly

Stage 4: After

Re-run the Before State queries and compare.

"""
After State: Verify ghost contacts have been suppressed.
"""
# Re-check still-marketing count
resp = requests.post(url, headers=headers, json={
    "filterGroups": [{"filters": GHOST_FILTERS + [
        {"propertyName": "hs_marketable_status", "operator": "EQ", "value": "true"},
    ]}],
    "limit": 1,
})
resp.raise_for_status()
remaining = resp.json().get("total", 0)

if remaining == 0:
    print("SUCCESS: All ghost contacts are now non-marketing.")
else:
    print(f"WARNING: {remaining} ghost contacts are still marketing.")

Also check email performance: After 1-2 email sends post-suppression, open rates should improve noticeably because thousands of guaranteed-zero-open contacts have been removed from the send pool.

Safety Mechanisms

Mechanism	Detail
CSV audit trail	Full export with delivery counts, lifecycle stage, and marketing status before any action.
Graduated suppression	Recommend starting with contacts above your delivery threshold (typically 5-15). Monitor those below it separately.
Overlap detection	Before State measures how many are already non-marketing from prior processes.
Two-tier list system	Main list for all ghosts, review list for worst offenders.
Non-destructive	Suppression, not deletion. CRM records are preserved.
Confirmation prompt	Present all findings to the user before proceeding.

Technical Gotchas

1. CRITICAL: NOT_HAS_PROPERTY, not EQ 0. HubSpot stores "never opened" as a null/absent property. Using EQ 0 returns nothing. This is the most common mistake with this process.

2. Search API pagination limit is 10K. Ghost contacts often exceed 10K. Use segmented queries by delivery volume brackets (1-5, 6-10, 11-20, etc.) to export the complete set. Choose segment boundaries so each segment stays under 10K.

3. hs_email_delivered is the correct property for delivery count. Do not confuse with hs_email_sent (sent but not necessarily delivered) or num_unique_conversion_events.

4. hs_email_open counts total opens, not unique opens. But for ghost contacts, both are null because no open ever occurred.

5. List API filter for "is unknown" uses operationType: "ALL_PROPERTY" with operator: "IS_UNKNOWN". This is different from the Search API's NOT_HAS_PROPERTY.

6. hs_marketable_status is read-only via API. Same constraint as all suppression skills. Manual UI action or workflow-flag workaround required.

7. Overlap with hard-bounce and unsubscribe processes: Some ghost contacts may have already been suppressed. The Before State overlap detection prevents double-counting the billing impact.

Rollback

• Suppression is reversible: restore contacts to marketing status via the UI or a workflow.
• If ghosts were deleted rather than suppressed, deleted contacts are recoverable for 90 days via Settings > Data Management > Deleted Objects.

Setup

Create a .env file in the repo root:

HUBSPOT_ACCESS_TOKEN=pat-na1-xxxxxxxx

No package install is needed — scripts carry PEP 723 inline metadata and run with uv, which resolves dependencies automatically:

uv run skills/suppress-ghost-contacts/scripts/before.py