Find Hourly and Blue-Collar Jobs on ZipRecruiter (2026)

Thirdwatch's ZipRecruiter Scraper returns hourly + blue-collar US jobs on a pay-per-record basis — title, company, location, hourly rate, job type, posted date. Built for non-tech US recruiter pipelines, hourly-jobs platforms, blue-collar talent platforms, and US labor-market research targeting trades + service segments.

Why scrape ZipRecruiter for hourly research

US hourly + blue-collar hiring operates differently from tech. According to ZipRecruiter's 2024 Job Market report, the platform serves 50%+ of US blue-collar candidate searches with 9M+ listings — much of it small/mid-market employers Indeed under-indexes. For non-tech US recruiter pipelines, hourly-jobs platforms, and blue-collar-skills research, ZipRecruiter is canonical alongside SimplyHired.

The job-to-be-done is structured. A US healthcare staffing agency monitors RN + LPN postings daily across 50 metros. A blue-collar talent platform builds per-trade per-metro lead lists for outbound. An hourly-jobs aggregator ingests warehouse + retail + restaurant postings nationally. A US labor-market research function tracks blue-collar-segment hiring trends. All reduce to category + city queries + per-record aggregation.

How does this compare to the alternatives?

Three options for hourly + blue-collar US jobs:

For comprehensive US hourly coverage, run ZipRecruiter + Indeed + SimplyHired together — typically 30-40% non-overlap.

How to find hourly jobs in 4 steps

Step 1: How do I authenticate?

export APIFY_TOKEN="apify_api_xxxxxxxxxxxxxxxx"

Step 2: Pull hourly category × metro batches

import os, requests, pandas as pd
from itertools import product

ACTOR = "thirdwatch~ziprecruiter-scraper"
TOKEN = os.environ["APIFY_TOKEN"]

CATEGORIES = ["registered nurse", "warehouse associate", "truck driver",
              "retail manager", "home health aide", "delivery driver",
              "restaurant server", "electrician", "plumber"]
METROS = ["Phoenix, AZ", "Charlotte, NC", "Memphis, TN",
          "Indianapolis, IN", "Columbus, OH", "Atlanta, GA",
          "Houston, TX", "Dallas, TX"]

queries = [{"title": c, "location": m} for c, m in product(CATEGORIES, METROS)]

resp = requests.post(
    f"https://api.apify.com/v2/acts/{ACTOR}/run-sync-get-dataset-items",
    params={"token": TOKEN},
    json={"queries": queries, "maxResults": 50},
    timeout=3600,
)
df = pd.DataFrame(resp.json())
print(f"{len(df)} hourly jobs across {df.location.nunique()} metros")

9 categories × 8 metros × 50 = up to 3,600 records — well within budget for a daily refresh.

Step 3: Parse hourly rate + filter

import re

def parse_hourly(s):
    if not isinstance(s, str): return None, None
    m = re.search(r"\$([\d.]+)\s*-\s*\$?([\d.]+)\s*an hour", s, re.I)
    if m:
        return float(m.group(1)), float(m.group(2))
    m = re.search(r"\$([\d.]+)\s*an hour", s, re.I)
    if m:
        v = float(m.group(1))
        return v, v
    return None, None

df[["rate_min", "rate_max"]] = df.salary.apply(parse_hourly).apply(pd.Series)
df["rate_mid"] = (df.rate_min + df.rate_max) / 2

per_trade = (
    df.dropna(subset=["rate_mid"])
    .groupby(["title", "location"])
    .agg(median_rate=("rate_mid", "median"),
         p25=("rate_mid", lambda x: x.quantile(0.25)),
         p75=("rate_mid", lambda x: x.quantile(0.75)),
         n=("rate_mid", "count"))
    .query("n >= 10")
)
print(per_trade.head(15))

Step 4: Track hourly-rate trends

import datetime, pathlib

ts = datetime.datetime.utcnow().strftime("%Y%m%d")
out = pathlib.Path(f"snapshots/zr-hourly-{ts}.json")
out.parent.mkdir(parents=True, exist_ok=True)
out.write_text(per_trade.to_json(orient="records"))
print(f"Persisted {len(per_trade)} hourly-rate aggregates")

Weekly snapshots build the time-series for hourly-wage trend research + trade-shortage detection.

Sample output

{
  "title": "Registered Nurse - Telemetry",
  "company_name": "Banner Health",
  "location": "Phoenix, AZ 85008",
  "salary": "$38.00 - $52.00 an hour",
  "job_type": "Full-time",
  "posted_date": "1 day ago",
  "apply_url": "https://www.ziprecruiter.com/jobs/banner-health/...",
  "remote": false
}

Common pitfalls

Three things go wrong in hourly pipelines. Hourly vs annual mixing — same listing may show "$45,000-$65,000/year" instead of hourly; filter on "an hour" string-match before treating as hourly-rate. Salary-range vs single-rate variance — about 25% of disclosed listings show single rate ("$25 an hour"), 75% show range; treat single-rate as both min + max. State minimum-wage clustering — California ($16/hr min) + Washington ($16/hr min) skew distributions vs Texas ($7.25/hr min); for accurate per-trade benchmarks, segment by state-tier rather than national medians.

Thirdwatch's actor handles the anti-bot work and proxy rotation so you can focus on the data. Pair ZipRecruiter with Indeed Scraper and SimplyHired Scraper for full US hourly coverage. A fourth subtle issue worth flagging: hourly + blue-collar postings often show "Full-time + Part-time" as job_type simultaneously — don't filter by job-type strictly; many hourly roles are flexible-tier. A fifth pattern unique to skilled trades: licensure requirements vary by state (electrician journeyman license, RN state license) — for accurate cross-state research, factor in license-portability + state-specific certification requirements. A sixth and final pitfall: ZipRecruiter aggressively cross-posts from Indeed + employer ATS — about 40% of ZipRecruiter listings appear elsewhere with same apply_url. Cross-source dedup on apply_url essential.

Operational best practices for production pipelines

Tier the cadence to match signal half-life. Hourly postings turn over fast (7-21 days median); daily polling captures most signal. Tier the watchlist: Tier 1 (active recruiter targets, daily), Tier 2 (broader market research, weekly), Tier 3 (long-tail discovery, monthly). 60-80% cost reduction with negligible signal loss.

Snapshot raw payloads. Pipeline cost is dominated by scrape volume, not storage. Compress with gzip at write-time. Most production pipelines run 90 days raw + 12 months derived aggregates + indefinite metric time-series.

Schema validation. Run a daily validation suite asserting expected core fields with non-null rates above 80% (required) and 50% (optional). ZipRecruiter schema occasionally changes during platform UI revisions — catch drift early. A seventh and final operational pattern at production scale: cross-snapshot diff alerts. Beyond detecting individual changes, build alerts on cross-snapshot field-level diffs — name changes, category re-classifications, status changes. These structural changes precede or follow material events and are leading indicators of organization-level disruption. Persist a structured-diff log alongside aggregate snapshots: for each entity, persist (field, old_value, new_value) tuples per scrape. Surface high-leverage diffs to human reviewers; low-leverage diffs stay in the audit log.

An eighth pattern worth flagging for cost-controlled teams: implement an incremental-diff pipeline that only re-processes records whose hash changed since the previous snapshot. For watchlists where 90%+ of records are unchanged between snapshots, hash-comparison-driven incremental processing reduces downstream-compute by 80-90% while preserving full data fidelity. Combine with snapshot-storage compression for end-to-end pipeline-cost reductions of 70%+ at scale. This pattern is particularly important when scaling beyond 100K records per snapshot.

Related use cases

• Scrape ZipRecruiter jobs for aggregator
• Build ZipRecruiter salary database for mid-market
• Scrape SimplyHired jobs for aggregator
• The complete guide to scraping job boards
• All Thirdwatch use-case guides