Find Companies Using Mailchimp: API Guide (2026)

Mailchimp is where companies start doing email marketing. That makes "uses Mailchimp" one of the most versatile technographic filters there is: depending on what you sell, the same signal marks a warm prospect for your agency, a graduation candidate for your fancier ESP, or a churn risk for your retention team. This guide shows how Mailchimp is detected from the outside and how to turn that detection into a working prospect list with the DetectZeStack API. Every response shape below comes from the live API, and the worked example is a real site.

Why Find Companies Using Mailchimp?

Sales Prospecting for Email Marketing Tools and Agencies

A company running Mailchimp has told you three things without saying a word. They have an audience worth emailing. They have decided email marketing is worth doing. And they picked the entry-level generalist to do it with, which usually means no dedicated email team and a marketing operation still small enough for one platform to cover.

If you run an email marketing agency, that is your ideal client: someone already sold on the channel who lacks the hands to run it well. If you sell templates, deliverability audits, list-cleaning services, landing page builders, or CRM tooling that integrates with Mailchimp, the filter hands you an audience that has pre-qualified itself on budget and intent.

Competitive Intelligence for ESP Vendors

For anyone selling a competing email platform, Mailchimp sites are the displacement list. Mailchimp's pricing scales with contact count, and its ecommerce automation is shallower than specialist tools, so growing companies routinely outgrow it. A Mailchimp signup form on a store that also runs an ecommerce platform and an A/B testing tool is a store that has probably outgrown its ESP already: exactly the account a Klaviyo-style vendor wants to reach first, before the migration decision gets made. The detection tells you where the accounts are; the surrounding stack tells you which ones are ripe.

How Mailchimp Shows Up on a Website

Mailchimp touches a website in two places: the code the site embeds to collect subscribers and track visitors, and the DNS records the domain publishes to send authenticated email. Both are externally visible, and they fail independently, which is why checking both catches companies a single-signal check would miss.

Signup Form Embeds and chimpstatic/list-manage Scripts

The classic integration is the embedded signup form. Mailchimp generates a block of HTML the site owner pastes in, and its markup is unmistakable: a form with the mc-embedded-subscribe-form identifier that posts to the site's list-manage.com subdomain, usually accompanied by a stylesheet from cdn-images.mailchimp.com and the mc-validate.js validation script:

<!-- Begin Mailchimp Signup Form -->
<link href="//cdn-images.mailchimp.com/embedcode/classic-061523.css"
  rel="stylesheet" type="text/css">
<form action="https://example.us1.list-manage.com/subscribe/post?u=...&amp;id=..."
  method="post" id="mc-embedded-subscribe-form"
  name="mc-embedded-subscribe-form">
  ...
</form>

The second common integration is the connected-site script, which Mailchimp uses for pop-up forms and visitor tracking. It loads from Mailchimp's chimpstatic.com asset domain as an mcjs-connected bundle. DetectZeStack keys on all of these signals: the chimpstatic.com/mcjs-connected script source, the cdn-images.mailchimp.com stylesheet, the mc-validate.js script, and the signup form markup itself. There is no reason for any of them to appear on a page except a live Mailchimp integration, so a match returns a confidence of 100.

On WordPress, the integration is often a plugin rather than pasted embed code, and the API distinguishes the variants:

The plugin detections imply the core platform, so a site running MailChimp for WooCommerce also reports MailChimp itself. The distinction is useful qualification data: a store syncing WooCommerce purchase data into Mailchimp automations is a materially deeper integration, and a materially stickier account, than a blog with a pasted signup form.

Mandrill and DNS-Level Email Signals

A company can send Mailchimp campaigns from a domain whose website carries no Mailchimp code at all: think of a business whose site is a brochure but whose newsletter goes out weekly. Sending leaves traces in DNS instead. Domains that authenticate Mailchimp campaigns add servers.mcsv.net to their SPF record and provision DKIM under the k1 selector. Mandrill, Mailchimp's transactional email arm, uses the mandrill selector.

DetectZeStack's GET /dns endpoint surfaces both. It parses the domain's SPF record into an includes array where an mcsv.net entry is plainly visible, and it probes eight common DKIM selectors in parallel, including k1, mailchimp, and mandrill, reporting which one answered in dkim.selector_tested:

curl -s "https://detectzestack.p.rapidapi.com/dns?domain=example.com" \
  -H "X-RapidAPI-Key: YOUR_KEY" \
  -H "X-RapidAPI-Host: detectzestack.p.rapidapi.com" \
  | jq '{spf_includes: .spf.includes, dkim: .dkim}'

A servers.mcsv.net include or a DKIM hit on k1 or mandrill is strong evidence the company sends through Mailchimp even when the homepage is silent about it. For prospecting, treat the website signal as primary and the DNS signal as the recall booster that catches senders without on-site forms. There is a full walkthrough of the DNS endpoint in the DNS intelligence guide.

Check a Single Domain with the DetectZeStack API

Before writing any code, confirm the signal by hand. The /demo endpoint needs no API key and no signup:

curl -s "https://detectzestack.com/demo?url=themarginalian.org" \
  | jq '.technologies[] | select(.name == "MailChimp")'

Which returns:

{
  "name": "MailChimp",
  "categories": [
    "Marketing automation",
    "Email"
  ],
  "confidence": 100,
  "description": "Mailchimp is a marketing automation platform and email marketing service.",
  "website": "https://mailchimp.com",
  "icon": "mailchimp.svg",
  "source": "http"
}

curl Example — GET /analyze

The demo endpoint is rate limited and meant for spot checks. For real volume, get a free API key from RapidAPI and use the authenticated /analyze endpoint, which returns the full stack:

curl -s "https://detectzestack.p.rapidapi.com/analyze?url=themarginalian.org" \
  -H "X-RapidAPI-Key: YOUR_KEY" \
  -H "X-RapidAPI-Host: detectzestack.p.rapidapi.com" | jq '.'

{
  "url": "https://themarginalian.org",
  "domain": "themarginalian.org",
  "technologies": [
    { "name": "MailChimp",  "categories": ["Marketing automation", "Email"], "confidence": 100, "source": "http" },
    { "name": "WordPress",  "categories": ["CMS", "Blogs"],                  "confidence": 100, "source": "http" },
    { "name": "WordPress Super Cache", "categories": ["Caching"],            "confidence": 100, "source": "http" },
    { "name": "Cloudflare", "categories": ["CDN"],                           "confidence": 100, "source": "http" },
    { "name": "PHP",        "categories": ["Programming languages"],         "confidence": 100, "source": "http" },
    { "name": "MySQL",      "categories": ["Databases"],                     "confidence": 100, "source": "http" }
  ],
  "categories": {
    "Marketing automation": ["MailChimp"],
    "Email": ["MailChimp"],
    "CMS": ["WordPress"],
    "CDN": ["Cloudflare"]
  },
  "meta": { "status_code": 200, "tech_count": 11, "scan_depth": "full" },
  "cached": false,
  "response_ms": 1204
}

Reading the Response: technologies, categories, confidence

Three parts of the response do the prospecting work. The technologies array is the evidence: each entry carries the canonical name, its categories, a confidence score, and a source telling you whether the detection came from the HTTP response or a DNS or TLS signal. The categories object is the fast filter: it maps category names to the technologies found in them, so checking whether a domain runs any email platform is one lookup on categories["Marketing automation"] rather than a scan of the array. That lookup catches MailChimp, Klaviyo, and HubSpot in a single pass; filtering on the name MailChimp catches Mailchimp specifically. Pick based on whether you are qualifying a category budget or a displacement target.

And meta.status_code is the honesty check. Mailchimp is detected from the HTML a site returns, so if a site answers the scan with a 403 instead of its page, there is nothing to inspect and Mailchimp will be absent even if the site runs it. Treat any non-200 status_code as inconclusive rather than negative, or you will silently drop real Mailchimp users from your list.

Scan Your Whole Prospect List with POST /analyze/batch

Batch is how you work through a list. It accepts up to 10 URLs per request and scans them concurrently:

curl -s -X POST "https://detectzestack.p.rapidapi.com/analyze/batch" \
  -H "X-RapidAPI-Key: YOUR_KEY" \
  -H "X-RapidAPI-Host: detectzestack.p.rapidapi.com" \
  -H "Content-Type: application/json" \
  -d '{"urls": ["themarginalian.org", "davidlebovitz.com", "waitbutwhy.com"]}' \
  | jq -r '.results[]
      | select(.result.technologies[]?.name == "MailChimp")
      | .result.domain'

The response wraps one result per URL with a per-item error field, so a single dead domain does not fail the batch, and the jq filter above prints only the domains where MailChimp was found. Each URL in a batch counts as one request against your monthly quota; batching saves round trips and wall-clock time, not quota. For lists past a few hundred domains, the 1,000-site batch scanning guide covers chunking, retries, and rate pacing.

Compare Mailchimp vs Klaviyo Adoption Across Competitors with POST /compare

When the question is not "who uses Mailchimp" but "which ESP does each of these companies use," POST /compare answers it in one call. It scans 2 to 10 domains and splits every detected technology into what is shared across all of them and what is unique to each:

curl -s -X POST "https://detectzestack.p.rapidapi.com/compare" \
  -H "X-RapidAPI-Key: YOUR_KEY" \
  -H "X-RapidAPI-Host: detectzestack.p.rapidapi.com" \
  -H "Content-Type: application/json" \
  -d '{"urls": ["themarginalian.org", "ridge.com"]}' | jq '{
    shared,
    esp: [.domains[] | {domain, unique}]
  }'

{
  "shared": ["Cloudflare"],
  "esp": [
    { "domain": "themarginalian.org",
      "unique": ["MailChimp", "WordPress", "WordPress Super Cache", "PHP", "MySQL"] },
    { "domain": "ridge.com",
      "unique": ["Klaviyo", "Shopify", "Intelligems", "Fondue"] }
  ]
}

Run this across a competitor set and the ESP split falls out immediately: the domains with MailChimp in their list are on the entry-level generalist, the ones with Klaviyo have graduated to the ecommerce specialist, and the pattern across five or ten competitors tells you where a market segment is in its email maturity. That is a positioning insight you would otherwise pay a technographics vendor for, and here it is one API call.

Building a Lead List Workflow from Detection Results

Putting it together: read domains from a file, scan them in batches of 10, keep the Mailchimp users, and write a CSV your CRM can ingest.

import csv
import requests

API = "https://detectzestack.p.rapidapi.com/analyze/batch"
HEADERS = {
    "X-RapidAPI-Key": "YOUR_KEY",
    "X-RapidAPI-Host": "detectzestack.p.rapidapi.com",
    "Content-Type": "application/json",
}
BATCH_SIZE = 10  # API maximum per request


def scan(domains):
    """Scan up to 10 domains, yielding (domain, tech_names, status_code)."""
    resp = requests.post(API, headers=HEADERS, json={"urls": domains}, timeout=60)
    resp.raise_for_status()
    for item in resp.json()["results"]:
        result = item.get("result")
        if not result:
            print(f"  skipped {item['url']}: {item.get('error', 'no result')}")
            continue
        names = [t["name"] for t in result.get("technologies", [])]
        status = result.get("meta", {}).get("status_code")
        yield result["domain"], names, status


def main():
    with open("domains.txt") as f:
        domains = [line.strip() for line in f if line.strip()]

    prospects = []
    for i in range(0, len(domains), BATCH_SIZE):
        chunk = domains[i:i + BATCH_SIZE]
        print(f"Scanning {i + 1}-{i + len(chunk)} of {len(domains)}...")
        for domain, techs, status in scan(chunk):
            if status != 200:
                # No page HTML means no script-based detection is possible.
                print(f"  {domain}: status {status}, inconclusive")
                continue
            if "MailChimp" in techs:
                prospects.append({
                    "domain": domain,
                    "depth": ("ecommerce-sync"
                              if "MailChimp for WooCommerce" in techs
                              else "wordpress-plugin"
                              if "MailChimp for WordPress" in techs
                              else "embed"),
                    "stack": ", ".join(techs),
                })
                print(f"  {domain}: MailChimp")

    with open("mailchimp_prospects.csv", "w", newline="") as f:
        writer = csv.DictWriter(f, fieldnames=["domain", "depth", "stack"])
        writer.writeheader()
        writer.writerows(prospects)

    print(f"\n{len(prospects)} Mailchimp sites out of {len(domains)} domains.")


if __name__ == "__main__":
    main()

Two details in that script earn their keep. The status != 200 guard keeps inconclusive scans out of your negatives, and the depth column records whether the integration is a pasted embed, the WordPress plugin, or a full WooCommerce purchase-data sync. Depth is the qualification: an embed can be abandoned in an afternoon, while a store syncing order data has automations wired to it and will hold still long enough for a sales cycle. The stack column carries the rest of the scan, which is what turns a generic opener into a specific one; the lead enrichment pipeline guide and tech stack enrichment for sales teams show how to push it into a CRM.

Get Your API Key

Plans are the standard DetectZeStack tiers, and every URL scanned counts as one request:

Results are cached for 24 hours by default; a cache hit comes back with "cached": true, so rescanning the same domain twice in a row measures the cache rather than the scanner. The free tier's 100 requests are enough to validate the whole workflow on a real slice of your prospect list before paying anything.

Conclusion

Mailchimp announces itself in embed forms, connected-site scripts, and DNS records, and each of those signals is one API call away. Start with /demo to see a detection on a site you know, use /analyze/batch to sweep your prospect list, /compare to map ESP adoption across a competitor set, and /dns to catch the senders whose websites keep quiet. Filter on the canonical MailChimp name, guard on meta.status_code, and the output is a lead list with the research already attached.