Anytime Mailbox Scraper — Virtual Mailbox Locations + CMRA Registry

An Apify actor that crawls every Anytime Mailbox virtual mailbox location worldwide (2,077 US locations across 52 states and territories as of June 2026, plus international), extracts each street address, mail-center operator, and starting price, and verifies every address through the Smarty address-verification APIs — producing deliverability metadata (DPV, CMRA, county, geocode, …) per location.

Anytime Mailbox locations are Commercial Mail Receiving Agencies (CMRAs), so dpv_cmra: "Y" is expected for valid US addresses — the dataset is effectively a CMRA registry with deliverability analysis. USPS publishes no public CMRA list, which is what makes one scraped from the largest virtual-mailbox network useful.

Use cases

• Fraud & KYC address screening — flag sign-ups that use a virtual mailbox instead of a residential address: match against the location list, or use each record's dpv_cmra / pmb_designator fields directly.
• Compliance & risk — CMRA detection is a standard onboarding check for banks, fintechs, lenders, and insurers.
• Address intelligence & data products — county, geocode, and deliverability per address, refreshed on a schedule you control.
• Market & competitor analysis — operator names and starting prices across the whole network, by state and country.
• Lead generation — every location is an independently operated mail center with a named operator.

How it works (one actor, three phases)

1. Crawl — a CheerioCrawler walks the /locations → /l/{country} → /l/{country}/{state} directory. Each state page's location cards already carry the full address (street + city/state/zip), so every location is captured reliably from the listing (≈50 requests for the whole US). With fetchDetails on, each /s/{slug} detail page is also fetched to add the building suite + mail-center operator — the site soft-404s some of these to /locations under load, so they're retried with a fresh session, and the card address always stands.
2. Incremental enrich — only new or changed addresses are sent to Smarty (US addresses in batches of 100 via the US Street API; international addresses via the International API). Results are cached in a named Key-Value Store that persists across runs, so a weekly refresh never re-bills unchanged addresses (important: the International API costs one credit per address).
3. Snapshot — every currently-scraped location is joined with its (cached or fresh) verification and pushed to the run's dataset.

If no Smarty credentials are supplied, phase 2 is skipped and records are emitted with verification.status: "skipped-no-keys" — scraping still delivers value on its own.

Input

Field	Type	Default	Notes
startUrls	array	[{ url: ".../locations" }]	Crawl entry points. Narrow to one state (e.g. /l/usa/rhode-island) for cheap runs.
maxRequestsPerCrawl	int	0	0 = unlimited (full site).
maxConcurrency	int	10	Lower if you get blocked.
restrictToCountry	string	—	Limit the crawl to one country slug, e.g. usa. Pair with a matching startUrl like /l/usa.
fetchDetails	bool	true	Also fetch /s/ detail pages for the suite + operator. Addresses come from the listings regardless, so turn off for a fast, complete address-only crawl.
searchTerm	string	—	Free-text grep across every location — see Search & filter.
searchIsRegex	bool	false	Treat searchTerm as a case-insensitive regular expression.
searchFields	array	all	Limit the search to slug / operator / address / country / url / price.
states	array	—	US states to keep, as code (CA), name (California) or slug (new-york). Also narrows the crawl.
cities	array	—	Exact city names, case-insensitive.
countries	array	—	Country names or directory slugs.
zipcodes	array	—	Full zipcodes, or shorter prefixes (902 → all 902xx).
locationType	enum	any	us, international, or both.
minStartingPrice / maxStartingPrice	int	—	Bounds on the listed starting price in USD.
proxy	object	Apify Residential, US	Residential US recommended.
enrichWithSmarty	bool	true	Turn off to scrape addresses only.
forceReenrich	bool	false	Re-verify every address, ignoring the cache.
smartyAuthId / smartyAuthToken	secret string	—	Smarty secret-key pair. Falls back to SMARTY_AUTH_ID / SMARTY_AUTH_TOKEN env vars.
smartyMatch	enum	enhanced	US Street API match strategy.
usCandidates	int	1	Max US candidates per address.
intlGeocode	bool	true	Request lat/long for international addresses.
intlConcurrency	int	5	Parallel international (single-address) lookups.

Search & filter

Every criterion is optional, all of them combine with AND, and values within one list combine with OR. Filtering runs before Smarty enrichment, so a narrow query never spends credits on locations you won't receive.

// Every Los Angeles mailbox under $15, run from the site index
{ "startUrls": [{ "url": "https://www.anytimemailbox.com/locations" }],
  "states": ["CA"], "cities": ["Los Angeles"], "maxStartingPrice": 15 }

// Grep for an operator, an address fragment, a zipcode — anything
{ "searchTerm": "pigeon post" }
{ "searchTerm": "broadway suite", "searchFields": ["address"] }
{ "searchTerm": "\\b9\\d{4}\\b", "searchIsRegex": true }

searchTerm is the grep: every word must appear somewhere in the location's text — street, suite, city, state, zipcode, mail-center operator, country, slug, URL and starting price — case-insensitive, or as a regular expression with searchIsRegex. Restrict it with searchFields. There is no "location type" field on the site itself; the closest equivalents are locationType (US vs international), countries/states, and — once Smarty enrichment is on — the dpv_cmra flag on each record.

Structured filters also make the run cheaper. states, cities, countries, zipcodes, locationType and the price bounds are decidable from the listing card alone, so a location they reject never has its detail page fetched — and a states filter visits only those state directories (implying restrictToCountry: "usa", which is logged). A verified example: states: ["CA"] + cities: ["Los Angeles"] seeded from /locations crawled 30 requests (index → /l/usa → /l/usa/california → 27 detail pages) instead of the ~2,100 a full US run costs, and returned 27 records.

searchTerm is deliberately not used for pruning: it can match detail-only fields such as the operator, so a card that looks like a miss may still be a hit. It filters the finished records instead.

Misspelling every value of a filter (e.g. states: ["Califorina"]) fails the run immediately rather than quietly returning the whole site.

Pricing (pay-per-event)

One event, one price: $0.005 per location returned — $5.00 per 1,000 results. It uses the platform's built-in apify-default-dataset-item event, so every item written to the dataset is charged automatically and there is no charging code to keep in step.

Run	Locations	Price
Delaware (the prefilled trial input)	18	$0.09
One state, e.g. California	390	$1.95
Whole US registry	2,077	$10.39
Single address check (filtered)	1	$0.005

The price is declared in .actor/pay_per_event.json, but the Apify Console → Monetization page is authoritative — the platform exposes no pricing API.

It is sized for the expensive path. A listing-sourced address costs ~4 KB of proxy traffic, while its detail page costs ~165 KB and only works over residential proxy (the datacenter group returns HTTP 403 on /s/ pages), so a full US crawl with fetchDetails on runs about $3.40 of platform usage against $10.39 of revenue. Running with fetchDetails: false, or narrowing with the filters above, costs you the same per record but far less to serve.

Output record

Each dataset item wraps provenance, the address sent to Smarty, and the verification. For US addresses, verification.report is exactly the Smarty US Street API response shape.

{
  "source": {
    "provider": "anytimemailbox",
    "url": "https://www.anytimemailbox.com/s/adelanto-11328-bartlett-avenue",
    "slug": "adelanto-11328-bartlett-avenue",
    "operator": "NEXT-N-LINE TAX SERVICES",
    "country": "United States",
    "startingPrice": "US$ 11.99",
    "rawAddress": "11328 Bartlett Ave, Ste 5, Adelanto, CA 92301, United States",
    "scrapedAt": "2026-06-09T…"
  },
  "addressInput": { "street": "11328 Bartlett Ave Ste 5", "secondary": "Ste 5",
                    "city": "Adelanto", "state": "CA", "zipcode": "92301",
                    "country": "United States", "freeform": "…" },
  "verification": {
    "provider": "smarty-us",            // | "smarty-international" | null
    "status": "enriched",               // | "skipped-no-keys" | "no-candidates" | "error"
    "report": { "components": { "pmb_designator": "PMB", … },
                "metadata": { "county_name": "Marin", "latitude": 38.0, … },
                "analysis": { "dpv_cmra": "Y", "dpv_match_code": "Y", … } }
  }
}

Weekly refresh

Schedule the actor in the Apify Console → Schedules (e.g. cron 0 6 * * 1 — Mondays 06:00). The enrichment cache lives in the named Key-Value Store anytimemailbox-enrichment-cache, which is account-scoped and persists across runs, so each weekly run only spends Smarty credits on locations that are new or changed since last time.

Observability (Scraper Insight)

Every crawl request reports its outcome (URL, status, latency; terminal failures with a classified status + error message) to the fleet's [Scraper Insight] dashboard via machine auth — fire-and-forget, so an Insight outage never slows the crawl. Credentials ship in src/insight.ts (private repo; rotate + move to env before going public); override with INSIGHT_URL / INSIGHT_APP_ID / INSIGHT_APP_SECRET.

Development

npm install
npm run build         # tsc
npm run lint          # eslint
npm test              # vitest (offline unit tests)
npm run start:dev     # run locally (reads storage/key_value_stores/default/INPUT.json)

Testing with the proxy

Unit tests run offline against saved HTML fixtures in test/fixtures/. The live integration tests are opt-in via environment variables and route through the Apify proxy (credentials from ../proxy.txt or APIFY_PROXY_PASSWORD):

# Live crawl test (fetches real pages through proxy.apify.com):
APIFY_PROXY_PASSWORD=<pw> npm test

# Live Smarty verification test:
SMARTY_AUTH_ID=… SMARTY_AUTH_TOKEN=… npm test

# Re-capture HTML fixtures from the live site:
APIFY_PROXY_PASSWORD=<pw> npm run capture-fixtures

Source layout

File	Responsibility
src/main.ts	Actor lifecycle + three-phase orchestration
src/routes.ts	Crawlee router: geo + detail handlers
src/parse.ts	HTML → structured ScrapedLocation / AddressInput
src/geo.ts	Country-slug + US state resolution; US vs international
src/filter.ts	Search/filter predicate; card-decidable subset used to prune the crawl
src/smarty.ts	Smarty client (US batch + international single)
src/cache.ts	Persistent enrichment cache: keying, diff, load/save
src/insight.ts	Scraper Insight reporting: request outcomes via machine auth
src/enrich.ts	Partition, verify the diff, build output records
src/spec.ts	Shared types