DEV Community: Plain Signal

How to See Any Company's LinkedIn Ads with Python (Ad Text, Impressions and Targeting)

Plain Signal — Fri, 02 Oct 2026 09:43:33 +0000

If you sell to businesses, your competitors are almost certainly advertising on LinkedIn: webinars, whitepapers, demo offers, "thought leader" posts from their executives. LinkedIn lets you see all of it. The LinkedIn Ad Library lists every ad that ran on LinkedIn in the past year, and for ads shown in the EU it even adds run dates, impressions, the country split and the targeting the advertiser chose (the EU's Digital Services Act requires it).

The catch: it's a search page for humans. No export, no API, 24 ads at a time, and a name search that's fuzzy. Search "HubSpot" and you also get "HubSpot Platinum Partner" and every agency with HubSpot in its name.

This tutorial shows how to get a company's LinkedIn ads as clean JSON or CSV with Python: a CSV of competitors' ads with landing pages and UTM campaigns, a check of which companies in a list run LinkedIn ads at all, and a Slack alert for new ads. It uses the LinkedIn Ad Library Scraper on Apify, which I built for this. All code is in the examples repo.

What you get per ad

A real record from a run on 2026-10-02 (HubSpot, shown in Germany; country list shortened):

{
  "advertiserName": "HubSpot",
  "advertiserId": "68529",
  "paidBy": "HubSpot, Inc.",
  "format": "IMAGE",
  "headline": "Kostenlos anmelden",
  "adText": "Pipeline-Problem erkannt, Kampagne gestartet: in Minuten. Live-Demo mit HubSpot am 30. Sept.",
  "callToAction": "Mehr erfahren",
  "landingUrl": "https://hubs.la/Q04vVMsQ0?utm_campaign=EMEA&utm_source=linkedin&utm_medium=paid&utm_id=805100113&...",
  "landingDomain": "hubs.la",
  "utm": {"campaign": "EMEA", "source": "linkedin", "medium": "paid", "id": "805100113"},
  "firstShown": "2026-09-01",
  "lastShown": "2026-09-29",
  "impressions": "100k-150k",
  "impressionsMin": 100000,
  "impressionsMax": 150000,
  "impressionsByCountry": [
    {"country": "Germany", "percent": 65, "label": "65%"},
    {"country": "Switzerland", "percent": 18, "label": "18%"},
    {"country": "Austria", "percent": 17, "label": "17%"}
  ],
  "targeting": {
    "Language": {"includes": ["Deutsch"], "excludes": []},
    "Location": {"includes": ["Deutschland", "Österreich und die Schweiz"], "excludes": []}
  },
  "targetedBy": ["Audience", "Company", "Job"],
  "adUrl": "https://www.linkedin.com/ad-library/detail/1515543043"
}

Video ads also have an MP4 link (videoUrl), carousel ads list their cards, and document ads have the document title and page count. Ads a company runs through an employee's post ("thought leader ads") have the employee's name in postedBy.

Two things that make this harder than it looks

The name search is fuzzy. LinkedIn's "Search by company" returns anything that looks similar. The scraper takes a name, a website or a LinkedIn company URL, finds the advertiser whose name matches exactly (ignoring "Inc.", "GmbH" and the like; for monday.com it prefers the advertiser literally called "monday.com" over "monday group"), looks up its LinkedIn company ID and then filters the Ad Library by that ID. If nothing matches exactly, you get no ads and a log line with the similar names, not a look-alike company's ads.

LinkedIn blocks scrapers quickly. From a home connection, the Ad Library starts answering with HTTP 429 after about 15 quick requests, and it rejects cloud IPs outright. The scraper sends every request through a fresh proxy IP with a real browser's TLS fingerprint and retries on a new IP when one is blocked. A 300-ad run took two minutes.

Option 1: no code

Open the LinkedIn Ad Library Scraper and click Try for free. A free Apify account is enough.
Enter companies (HubSpot, hubspot.com or https://www.linkedin.com/company/hubspot) or keywords (webinar, crm software).
Optionally pick a country and a date range.
Click Start, then download the results as CSV, Excel or JSON.

Option 2: Python, competitors' ads as CSV

Install the Apify client and set your API token (Console → Settings → Integrations):

pip install apify-client
export APIFY_TOKEN=...

This script collects the LinkedIn ads three CRM companies ran in the last 30 days and saves them with the call to action, landing domain and UTM campaign:

import csv
import os
from collections import Counter
from decimal import Decimal

from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])

run = client.actor("plain-signal/linkedin-ad-library-scraper").call(
    run_input={
        "companies": ["HubSpot", "salesforce.com", "https://www.linkedin.com/company/pipedrive"],
        "dateRange": "last-30-days",
        "maxAdsPerSearch": 30,
    },
    max_total_charge_usd=Decimal("0.20"),  # 90 ads × $0.002
)
ads = list(client.dataset(run.default_dataset_id).iterate_items())

with open("competitor_linkedin_ads.csv", "w", newline="") as f:
    w = csv.writer(f)
    w.writerow(["advertiser", "format", "headline", "ad_text", "call_to_action", "landing_domain", "utm_campaign",
                "impressions", "first_shown", "last_shown", "ad_url"])
    for a in ads:
        w.writerow([a["advertiserName"], a["format"], a["headline"], a["adText"], a["callToAction"],
                    a["landingDomain"], a["utm"].get("campaign"), a["impressions"], a["firstShown"],
                    a["lastShown"], a["adUrl"]])

print(f"{len(ads)} ads saved to competitor_linkedin_ads.csv")
print("Formats:", ", ".join(f"{n} {f.lower()}" for f, n in Counter(a["format"] for a in ads).most_common()))
print("Top landing pages:")
for domain, n in Counter(a["landingDomain"] for a in ads if a["landingDomain"]).most_common(5):
    print(f"{n:>4}  {domain}")

Output from a real run:

90 ads saved to competitor_linkedin_ads.csv
Formats: 50 image, 31 video, 7 carousel, 2 message
Top landing pages:
  23  pipedrive.com
  14  hubspot.com
   8  salesforce.com
   4  hubs.la
   1  au.linkedin.com

The UTM campaign is often the most revealing column. One HubSpot ad in this run had utm_campaign=Marketing_Registrations_EN_EMEA_VARIOUS_GROW-Europe-2026_prospecting_..., which tells you the team, the goal, the region and the funnel stage before you even open the landing page. max_total_charge_usd is a hard cap on what the run can cost.

Option 3: which companies run LinkedIn ads?

For lead generation (agencies, B2B SaaS, martech sales), the question is often just "does this company spend money on LinkedIn?". Advertiser check mode returns one row per company:

import os
from decimal import Decimal

from apify_client import ApifyClient

COMPANIES = ["hubspot.com", "pipedrive.com", "close.com", "attio.com", "monday.com",
             "asana.com", "notion.so", "airtable.com", "zendesk.com", "intercom.com"]

client = ApifyClient(os.environ["APIFY_TOKEN"])

run = client.actor("plain-signal/linkedin-ad-library-scraper").call(
    run_input={"companies": COMPANIES, "mode": "advertisers"},
    max_total_charge_usd=Decimal("0.03"),  # 10 companies × $0.003
)
rows = list(client.dataset(run.default_dataset_id).iterate_items())
rows.sort(key=lambda r: r["adsLast30Days"], reverse=True)

for r in rows:
    count = f"{r['adsLast30Days']}{'+' if r['adsLast30DaysCapped'] else ''}"
    status = f"{count:>4} ads  {', '.join(f.lower() for f in r['formats'])}" if r["isAdvertising"] else "   no ads"
    print(f"{r['input']:<16} {status}")
print(f"\n{sum(r['isAdvertising'] for r in rows)} of {len(rows)} companies ran LinkedIn ads in the last 30 days")

pipedrive.com    100+ ads  image, video
attio.com        100+ ads  document, image, message, video
hubspot.com      100+ ads  document, image, message, video
monday.com       100+ ads  carousel, document, image, video
asana.com        100+ ads  carousel, image, jobs, video
notion.so        100+ ads  document, image, video
airtable.com     100+ ads  document, follower, image, video
intercom.com     100+ ads  image
zendesk.com      100+ ads  article, document, image, message, video
close.com           no ads

9 of 10 companies ran LinkedIn ads in the last 30 days

Counts stop at 100 per company to keep the check cheap. Add "country": "DE" to see who advertises in one market: in Germany, Pipedrive had 2 ads in the last 30 days and Asana 10.

Option 4: a Slack alert for competitors' new LinkedIn ads

Monitor mode remembers what earlier runs returned. Give it a name, and each run returns only ads it hasn't seen before:

import json
import os
import urllib.request
from decimal import Decimal

from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])

run = client.actor("plain-signal/linkedin-ad-library-scraper").call(
    run_input={
        "companies": ["monday.com", "asana.com", "https://www.linkedin.com/company/notionhq"],
        "maxAdsPerSearch": 20,  # look at each competitor's 20 newest ads
        "monitorName": "pm-tools",  # remembers what earlier runs returned
    },
    max_total_charge_usd=Decimal("0.15"),
)
ads = list(client.dataset(run.default_dataset_id).iterate_items())

lines = []
for a in ads:
    what = a["headline"] or (a["adText"] or "").split("\n")[0][:120] or a["format"].lower() + " ad"
    lines.append(f"*{a['advertiserName']}* ({a['format'].lower()}): {what}\n{a['adUrl']}")
text = f"{len(ads)} new competitor LinkedIn ads\n\n" + "\n\n".join(lines) if ads else "No new competitor LinkedIn ads."

webhook = os.environ.get("SLACK_WEBHOOK_URL")
if webhook:
    req = urllib.request.Request(webhook, data=json.dumps({"text": text}).encode(),
                                 headers={"Content-Type": "application/json"})
    urllib.request.urlopen(req)
else:
    print(text)

A test run with one ad per company:

3 new competitor LinkedIn ads

*monday.com* (image): See what faster looks like on monday.
https://www.linkedin.com/ad-library/detail/1578871764

*Notion* (document): The exact decks, investor lists, and AI agents top startups used to close their first checks. Free guide, free Notion tr
https://www.linkedin.com/ad-library/detail/1619931196

*Asana* (image): Let AI Teammates coordinate campaign handoffs
https://www.linkedin.com/ad-library/detail/1563187794

Run it again straight away and it prints No new competitor LinkedIn ads. Schedule it with cron or GitHub Actions, or skip the code entirely: create a schedule in the Apify Console and connect the Slack, Google Sheets or email integration.

What does it cost?

$0.002 per ad ($2 per 1,000) with all details, $0.001 per ad if you turn details off (text preview and image only), and $0.003 per company in advertiser-check mode. There's no monthly fee. The 90-ad CSV above costs $0.18, the 10-company check $0.03, and a weekly competitor monitor usually comes to cents a month. Apify's free plan includes monthly platform credit, which is enough to try all of the above.

Good to know

Run dates, impressions and targeting exist only for ads shown in the EU. For ads shown only in the US, for example, those fields are empty; the text, creative, advertiser, payer and landing page are always there.
Landing pages: lnkd.in short links in post text are resolved to the real destination, and the utm_* parameters are parsed into a dict.
Message ads keep LinkedIn's placeholders, such as Hi %FIRSTNAME%,.
Coverage: the Ad Library keeps ads for a year after they last ran. Newest ads come first.

Wrapping up

All three examples are in the plain-signal/examples repo. It also has examples for the Google Ads Transparency Scraper, which does the same for Google Search and YouTube ads. Together they show a competitor's whole paid funnel: what they bid on in search, and what they push to buyers' LinkedIn feeds. Questions and feature requests are welcome in the comments or on the actor's Issues tab.

This article was written with AI assistance. All code was run against the live scraper before publishing, and the outputs shown are real.

How to See Any Competitor's Google Ads with Python (Headlines, Descriptions and Run Dates)

Plain Signal — Fri, 02 Oct 2026 08:16:22 +0000

Want to know what your competitors say in their Google Ads? Google will show you. Since 2023 the Google Ads Transparency Center lists every ad a verified advertiser runs on Search, YouTube, Display, Shopping and Maps, with the dates it was shown and the countries it ran in.

The catch: it's built for looking up one advertiser at a time in a browser. There's no export and no API. And for most text ads, Google doesn't store the ad as text at all. It stores a screenshot of the rendered ad, so even if you scrape the page, you get a PNG instead of a headline.

This tutorial shows how to get competitors' ads as clean JSON or CSV, with the headline, description, display URL and sitelinks as real text. There are three examples: a CSV of competitors' ads, a check of which companies in a list run Google Ads at all, and a Slack alert for new ads. It uses the Google Ads Transparency Scraper on Apify, which I built for exactly this. All code is in the examples repo.

What you get per ad

A real record from a run on 2026-10-02:

{
  "advertiserName": "Hubspot, Inc.",
  "domain": "hubspot.com",
  "format": "TEXT",
  "firstShown": "2025-10-15",
  "lastShown": "2026-10-02",
  "daysShown": 322,
  "headline": "SEO Keyword Research Tools - Track Your SEO Progress",
  "description": "HubSpot's SEO tools help you research keywords, track rankings & optimize content. Get actionable SEO...",
  "displayUrl": "www.hubspot.com/",
  "sitelinks": ["Free Website Builder", "Sign Up Free", "HubSpot SEO Tools", "Improve Your Site Rank", "Free Content Tools"],
  "adCopySource": "ocr",
  "imageUrl": "https://tpc.googlesyndication.com/archive/simgad/10713166194209069207",
  "adUrl": "https://adstransparency.google.com/advertiser/AR10072600183532683265/creative/CR03473167961525583873?region=US"
}

Video ads come with the YouTube link (videoUrl) and a thumbnail. Image ads come with the image URL.

How the ad copy is read

The Transparency Center's web app gets its data from a JSON endpoint, so listing an advertiser's ads with dates and formats is the easy part. The text is harder. For 60–99% of text ads (depending on the advertiser), the only thing Google returns is a PNG of the ad as it appeared on the search page.

The layout of that image is always the same: advertiser name and display URL at the top, then the headline in Google's blue, then the description in grey, then optional sitelinks ending in >. So the scraper runs OCR (Tesseract) on the image and uses each line's text colour to tell the headline from the description. On clean renders like these, OCR is very accurate for English and the other Latin-script languages. adCopySource tells you whether the copy came from OCR or from Google's own preview data (used for video, shopping and local ads).

Option 1: no code

Open the Google Ads Transparency Scraper and click Try for free. A free Apify account is enough.
Enter one or more advertisers: a domain (hubspot.com), a brand name (HubSpot) or a Transparency Center link.
Optionally pick a country, an ad format, and Shown in the last N days.
Click Start, then download the results as CSV, Excel or JSON.

Option 2: Python, competitors' ads as CSV

Install the Apify client and set your API token (Console → Settings → Integrations):

pip install apify-client
export APIFY_TOKEN=...

This script collects the text ads three CRM companies ran in the US in the last 30 days, sorted by how long each ad has been running. An ad that has run for months or years is one that works, which makes it the most useful thing to learn from:

import csv
import os
from decimal import Decimal

from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])

run = client.actor("plain-signal/google-ads-transparency-scraper").call(
    run_input={
        "advertisers": ["hubspot.com", "pipedrive.com", "salesforce.com"],
        "country": "US",
        "adFormat": "TEXT",
        "shownInLastDays": 30,
        "maxAdsPerAdvertiser": 50,
    },
    max_total_charge_usd=Decimal("0.30"),  # 150 ads × $0.002
)
ads = list(client.dataset(run.default_dataset_id).iterate_items())
ads.sort(key=lambda a: a["daysShown"] or 0, reverse=True)  # ads that run for months are the ones that work

with open("competitor_ads.csv", "w", newline="") as f:
    w = csv.writer(f)
    w.writerow(["advertiser", "headline", "description", "display_url", "first_shown", "last_shown", "days_shown", "ad_url"])
    for a in ads:
        w.writerow([a["advertiserName"], a["headline"], a["description"], a["displayUrl"], a["firstShown"],
                    a["lastShown"], a["daysShown"], a["adUrl"]])

print(f"{len(ads)} ads saved to competitor_ads.csv")
for a in ads[:5]:
    print(f"{a['daysShown']:>4} days  {a['advertiserName']}: {a['headline']}")

Output from a run on 2026-10-02:

150 ads saved to competitor_ads.csv
1556 days  Hubspot, Inc.: HubSpot CRM Platform - Grow Better - Schedule a Demo Today
1556 days  Hubspot, Inc.: HubSpot CRM Platform - Simplify Your Processes - Grow Better
1556 days  Hubspot, Inc.: HubSpot CRM Platform
1552 days  Hubspot, Inc.: HubSpot Sales Hub - Powerful Free Sales Tools
1540 days  Hubspot, Inc.: Hubspot Service Hub - Get Started Today

HubSpot's "Grow Better - Schedule a Demo Today" headline has been running since June 2022. The run took under three minutes, most of it OCR.

Two things worth knowing:

max_total_charge_usd is a hard cap on what the run can cost. The scraper stops cleanly when it's reached.
A domain search also finds other advertisers. Searching hubspot.com returned 42 ads from HubSpot itself plus a few from small advertisers whose ads point to HubSpot-hosted pages. Filter on advertiserName, or pass the advertiser ID (from adUrl) instead of the domain to get one account only.

Option 3: which companies run Google Ads?

For lead generation (agencies, ad-tech and martech sales), the question is often just "does this company spend money on Google Ads?". Advertiser check mode returns one row per input, with Google's estimate of how many ads they have:

import os
from decimal import Decimal

from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])

domains = ["hubspot.com", "pipedrive.com", "close.com", "attio.com", "folk.app", "copper.com", "nutshell.com",
           "capsulecrm.com", "streak.com", "lessannoyingcrm.com"]

run = client.actor("plain-signal/google-ads-transparency-scraper").call(
    run_input={"advertisers": domains, "country": "US", "mode": "advertisers"},
    max_total_charge_usd=Decimal("0.05"),  # 10 checks × $0.002
)
rows = list(client.dataset(run.default_dataset_id).iterate_items())

for r in sorted(rows, key=lambda r: r["adCountMax"] or 0, reverse=True):
    if r["isAdvertising"]:
        ads = f"{r['adCountMin']:,}–{r['adCountMax']:,} ads" if r["adCountMin"] != r["adCountMax"] else f"{r['adCountMax']} ads"
        print(f"{r['input']:<22} yes  {ads:<16} last shown {r['lastShown']}  ({', '.join(r['formats'])})")
    else:
        print(f"{r['input']:<22} no")

Output (it took about a second):

hubspot.com            yes  1,000–2,000 ads  last shown 2026-10-02  (IMAGE, TEXT, VIDEO)
pipedrive.com          yes  1,000–2,000 ads  last shown 2026-10-02  (TEXT)
attio.com              yes  200–300 ads      last shown 2026-10-02  (IMAGE, TEXT, VIDEO)
nutshell.com           yes  100–200 ads      last shown 2026-10-02  (IMAGE, TEXT, VIDEO)
streak.com             yes  100–200 ads      last shown 2026-10-02  (IMAGE, TEXT, VIDEO)
close.com              yes  93 ads           last shown 2026-10-02  (IMAGE, TEXT, VIDEO)
copper.com             yes  90 ads           last shown 2026-10-02  (IMAGE, TEXT, VIDEO)
folk.app               yes  62 ads           last shown 2026-10-02  (TEXT)
capsulecrm.com         yes  21 ads           last shown 2026-10-02  (IMAGE, TEXT)
lessannoyingcrm.com    yes  16 ads           last shown 2026-10-02  (TEXT)

Google gives large counts as ranges (1,000–2,000), and exact numbers below 100. Feed in a few hundred domains from your CRM and you have a list of companies that are actively buying ads, and roughly how much.

Option 4: a Slack alert for competitors' new ads

The scraper has a monitor mode: give it a monitorName, and each run checks each competitor's newest ads and returns only the ones earlier runs with that name haven't returned. Schedule it daily or weekly:

import json
import os
import urllib.request
from decimal import Decimal

from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])

run = client.actor("plain-signal/google-ads-transparency-scraper").call(
    run_input={
        "advertisers": ["monday.com", "asana.com", "clickup.com"],
        "country": "US",
        "maxAdsPerAdvertiser": 30,  # look at each competitor's 30 newest ads
        "monitorName": "pm-tools",  # remembers what earlier runs returned
    },
    max_total_charge_usd=Decimal("0.20"),
)
ads = list(client.dataset(run.default_dataset_id).iterate_items())

lines = []
for a in ads:
    what = a["headline"] or (f"video: {a['videoUrl']}" if a["videoUrl"] else a["format"].lower() + " ad")
    lines.append(f"*{a['advertiserName']}*: {what}\n{a['adUrl']}")
text = f"{len(ads)} new competitor ads\n\n" + "\n\n".join(lines) if ads else "No new competitor ads."

webhook = os.environ.get("SLACK_WEBHOOK_URL")
if webhook:
    req = urllib.request.Request(webhook, data=json.dumps({"text": text}).encode(),
                                 headers={"Content-Type": "application/json"})
    urllib.request.urlopen(req)
else:
    print(text)

The first run returns everything in the window (90 ads in my test). Later runs return only what's new. One a few minutes later found a single new ad:

1 new competitor ads

*Mango Technologies, Inc.*: video: https://www.youtube.com/watch?v=Ac_HTGC2Lyg

Mango Technologies is ClickUp's legal name, which is a nice side effect: the Transparency Center shows the verified company behind each brand. Schedule the script with cron or GitHub Actions. If you'd rather not run code at all, create a schedule in the Apify Console and connect the Slack, Google Sheets or email integration to the actor.

What does it cost?

The scraper charges $0.002 per ad ($2 per 1,000), with the ad copy included, and $0.002 per advertiser in advertiser-check mode. There's no monthly fee. The 150-ad CSV above costs $0.30, the 10-domain check $0.02, and a weekly competitor monitor usually comes to cents a month. Apify's free plan includes monthly platform credit, which is enough to try all of the above.

Good to know

Languages: OCR works well for Latin-script languages (English, German, French, Spanish, Italian, Portuguese, Dutch, Polish). For Japanese, Chinese or Arabic ads, the text fields may be empty or garbled; imageUrl still has the ad.
Dynamic keyword insertion: some ads use placeholders like {KeyWord:Nike Dunk}. You get the default text (Nike Dunk).
Brand names: a name like Salesforce is matched to advertisers with exactly that name (ignoring "Inc.", "Ltd" and the like). If there's no exact match, the scraper uses the matching domain and says so in the log. For full control, use a domain or an advertiser ID.
Coverage: only verified advertisers are listed, and political ads are in a separate Google report that isn't included.
Dates: firstShown and lastShown come from Google, and daysShown is Google's count of days the ad was shown.

Wrapping up

All three examples are in the plain-signal/examples repo, along with examples for the Google Jobs Scraper and the Funding Rounds Tracker. Ads, hiring and funding together make a strong lead signal: a company that just raised, is hiring marketers and has started running Google Ads is spending to grow. Questions and feature requests are welcome in the comments or on the actor's Issues tab.

This article was written with AI assistance. All code was run against the live scraper before publishing, and the outputs shown are real.

How to Find Startups That Just Raised Money with Python (SEC Form D Data)

Plain Signal — Fri, 02 Oct 2026 06:03:09 +0000

A company that just raised money has budget, and it's about to spend it on hiring, tools and agencies. For sales teams, recruiters and investors, "who raised this week?" is one of the most useful questions there is.

The usual answers are Crunchbase or PitchBook (expensive) or news-based funding trackers. Those only know about rounds a company announces, and amounts are often "undisclosed".

There's a better source that most people overlook: SEC Form D. US companies that raise money privately (most venture rounds, from pre-seed to late stage) have to file a Form D with the SEC, which is supposed to happen within 15 days of the first sale. The filing is public and includes the amount raised, the industry, the address and the executives. It often appears before any press release, and plenty of smaller rounds are never announced at all.

This tutorial shows how to turn those filings into clean JSON or CSV: without code, with a short Python script, as a CSV lead list, and as a daily Slack alert. It uses the Funding Rounds Tracker on Apify, which I built for exactly this. All code is in the examples repo.

Why not just use EDGAR directly?

You can. EDGAR is free and has a full-text search API. But there are a few catches:

Most Form D filings aren't startups. Investment funds, SPVs and real-estate vehicles make up the majority. You have to filter them out.
The useful data is in a separate XML document per filing, so one day of filings means a few hundred extra requests.
SEC fair-access rules: at most 10 requests per second and a User-Agent that identifies you, or you get blocked.
Amendments (Form D/A) repeat earlier raises, so you have to deduplicate.

The tracker does all of that and returns one clean record per raise.

What you get per raise

A real record from a run on 2026-10-02 (executives left out here):

{
  "companyName": "CScale, Inc.",
  "filingDate": "2026-10-01",
  "dateOfFirstSale": "2026-07-17",
  "totalAmountSoldUsd": 144999891,
  "totalOfferingAmountUsd": 194999885,
  "industry": "Other Technology",
  "entityType": "Corporation",
  "yearOfIncorporation": 2022,
  "incorporatedWithinFiveYears": true,
  "city": "PALO ALTO",
  "state": "CA",
  "revenueRange": "Decline to Disclose",
  "securities": ["equity"],
  "numberOfInvestors": 37,
  "exemptions": ["06b"],
  "filingUrl": "https://www.sec.gov/Archives/edgar/data/1975623/000197562326000005/0001975623-26-000005-index.htm"
}

Plus the phone number, street address, minimum investment, sales commissions, previous company names and relatedPersons: the executive officers, directors and promoters named in the filing, with their roles.

Option 1: no code

Open the Funding Rounds Tracker and click Try for free. A free Apify account is enough.
Pick a date range (default: the last 7 days).
Optionally filter by industry (Other Technology, Biotechnology…), state (CA, NY), minimum amount raised, or young companies only (incorporated in the last five years).
Click Start, then download the results as CSV, Excel or JSON.

Option 2: Python

Install the Apify client and set your API token (Console → Settings → Integrations):

pip install apify-client
export APIFY_TOKEN=...

This script lists US operating companies that raised $1M or more in the last 7 days, largest first:

import os
from decimal import Decimal

from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])

run = client.actor("plain-signal/form-d-funding-tracker").call(
    run_input={
        "daysBack": 7,
        "companyType": "operating",  # drops funds, SPVs and real-estate vehicles
        "minAmountSoldUsd": 1_000_000,
        "includeRelatedPersons": True,
        "maxItems": 50,
    },
    max_total_charge_usd=Decimal("1.00"),  # 50 records × $0.02
)
rounds = list(client.dataset(run.default_dataset_id).iterate_items())

for r in sorted(rounds, key=lambda r: r["totalAmountSoldUsd"] or 0, reverse=True):
    people = ", ".join(p["name"] for p in r["relatedPersons"][:2])
    print(f"${r['totalAmountSoldUsd']:>13,}  {r['companyName']} ({r['industry']}, {r['city']}, {r['state']})  {people}")

The top of the output from a run on 2026-10-02 (names cut):

$  416,188,472  Longtail Insurance Holdings Ltd. (Insurance, HAMILTON, D0)  …
$  144,999,891  CScale, Inc. (Other Technology, PALO ALTO, CA)  …
$  128,500,000  POPHOUSE AVATAR NETWORK INC. (Other, LAS VEGAS, NV)  …
$  122,649,481  Quartermaster AI, Inc (Other Technology, ARLINGTON, VA)  …
$   49,999,999  Click Therapeutics, Inc. (Other Health Care, NEW YORK, NY)  …

Two things worth knowing:

max_total_charge_usd is a hard cap on what the run can cost. When I first ran this with a $0.50 cap, it stopped cleanly at 25 records. Set the cap to maxItems × $0.02 if you want all of them.
D0 is EDGAR's code for Bermuda. Non-US companies that raise from US investors file Form D too, with EDGAR country codes in state.

Option 3: a CSV lead list of new startups

For sales or recruiting you usually want young companies in a few industries, plus a name and a phone number to start with:

import csv
import os
from collections import Counter
from decimal import Decimal

from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])

run = client.actor("plain-signal/form-d-funding-tracker").call(
    run_input={
        "daysBack": 14,
        "companyType": "operating",
        "onlyYoungCompanies": True,  # incorporated within the last five years
        "industries": ["Other Technology", "Computers", "Telecommunications"],
        "minAmountSoldUsd": 500_000,
        "includeRelatedPersons": True,
        "maxItems": 100,
    },
    max_total_charge_usd=Decimal("2.00"),
)
rounds = list(client.dataset(run.default_dataset_id).iterate_items())

with open("startups.csv", "w", newline="") as f:
    w = csv.writer(f)
    w.writerow(["company", "raised_usd", "first_sale", "city", "state", "phone", "executive", "filing"])
    for r in rounds:
        execs = [p for p in r["relatedPersons"] if "Executive Officer" in p["roles"]] or r["relatedPersons"]
        w.writerow([r["companyName"], r["totalAmountSoldUsd"], r["dateOfFirstSale"], r["city"], r["state"],
                    r["phone"], execs[0]["name"] if execs else "", r["filingUrl"]])

print(f"{len(rounds)} startups saved to startups.csv")
print("Top states:", ", ".join(f"{s} {n}" for s, n in Counter(r["state"] for r in rounds).most_common(3)))

Output from a run on 2026-10-02:

49 startups saved to startups.csv
Top states: CA 9, GA 4, VA 3

company,raised_usd,first_sale,city,state,phone,executive,filing
"Zaps Worldwide, Inc.",4055000,2026-09-08,PHOENIX,AZ,…
US Positronix Inc.,2030000,2026-09-16,OBERLIN,OH,…

The run took about a minute and a half and checked 512 filings to find those 49. Import the CSV into your CRM, or add a website/contact finder if you need emails (Form D doesn't include them).

Option 4: a daily Slack alert for new raises

The tracker has a monitor mode: give it a monitorName, and each run returns only filings that earlier runs with the same name haven't returned. Schedule it daily and you have a funding alert:

import json
import os
import urllib.request
from decimal import Decimal

from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])

run = client.actor("plain-signal/form-d-funding-tracker").call(
    run_input={
        "daysBack": 3,
        "companyType": "operating",
        "industries": ["Other Technology", "Computers"],
        "minAmountSoldUsd": 2_000_000,
        "includeRelatedPersons": False,
        "maxItems": 50,
        "monitorName": "tech-raises-2m",
    },
    max_total_charge_usd=Decimal("1.00"),
)
rounds = list(client.dataset(run.default_dataset_id).iterate_items())

lines = [f"*{r['companyName']}* raised ${r['totalAmountSoldUsd']:,} ({r['city']}, {r['state']})\n{r['filingUrl']}"
         for r in sorted(rounds, key=lambda r: r["totalAmountSoldUsd"] or 0, reverse=True)]
text = f"{len(rounds)} new raises\n\n" + "\n\n".join(lines) if rounds else "No new raises today."

webhook = os.environ.get("SLACK_WEBHOOK_URL")
if webhook:
    req = urllib.request.Request(webhook, data=json.dumps({"text": text}).encode(),
                                 headers={"Content-Type": "application/json"})
    urllib.request.urlopen(req)
else:
    print(text)

The first run in my test returned 9 raises:

9 new raises

*CScale, Inc.* raised $144,999,891 (PALO ALTO, CA)
https://www.sec.gov/Archives/edgar/data/1975623/000197562326000005/0001975623-26-000005-index.htm
...

Running it again right away returned No new raises today. Schedule it with cron or GitHub Actions. If you'd rather not run code at all, create a schedule in the Apify Console and connect the Slack, Google Sheets, HubSpot or email integration to the actor.

What does it cost?

The tracker charges $0.02 per funding record ($20 per 1,000), with no monthly fee. Filings removed by your filters are free. The 50-record run above cost $1.00 and the 49-startup lead list $0.98. A typical week has about 250 new raises by operating companies, so a daily monitor for all of them comes to about $20 a month, and with narrow filters it costs cents. Apify's free plan includes monthly platform credit, which is enough to try all of the above.

Good to know

Amount sold vs. offering amount: totalAmountSoldUsd is what was sold at filing time, totalOfferingAmountUsd the planned round size. CScale above had sold $145M of a planned $195M.
Filing dates: the 15-day deadline isn't always met. CScale's first sale was in July and the filing came in October. dateOfFirstSale tells you when the round actually started.
No round names: Form D doesn't say "Seed" or "Series A". Use the amount, yearOfIncorporation and numberOfInvestors as proxies.
Addresses: some companies list a registered agent (often in Delaware) instead of their office.
History: set Filed from / Filed to to any range since 2009 for backtesting or market research.
Personal data: Form D is public, but if you store or contact the people in relatedPersons, you're responsible for doing that lawfully (GDPR, CCPA, CAN-SPAM). Turn off includeRelatedPersons if you only need companies.

Wrapping up

All four examples are in the plain-signal/examples repo, along with examples for the Google Jobs Scraper (who's hiring, with salaries and apply links). Funding plus hiring is a strong combination for lead generation: a company that just raised and is posting jobs is about to grow. Questions and feature requests are welcome in the comments or on the actor's Issues tab.

This article was written with AI assistance. All code was run against the live tracker before publishing, and the outputs shown are real.

How to Scrape Google Jobs with Python (Salaries, Apply Links and Daily Alerts)

Plain Signal — Fri, 02 Oct 2026 05:30:13 +0000

Google Jobs is the job search built into Google. Search for "data analyst Chicago" and Google shows a box of listings pulled from LinkedIn, Indeed, Glassdoor, ZipRecruiter, company career pages and hundreds of smaller job boards. For job market research, salary benchmarks, a niche job board or lead generation ("who's hiring right now?"), it's one of the best sources there is.

There's no official API for it. Google's Cloud Talent Solution is for searching your own job postings, not Google's index. And scraping it yourself is annoying: Google blocks plain HTTP clients quickly, shows only 10 jobs per page and loads the rest with JavaScript.

This tutorial shows how to get Google Jobs results as clean JSON or CSV in three ways: without code, with a short Python script, and as a daily alert to Slack. It uses the Google Jobs Scraper on Apify, which I built for exactly this. All code is in the examples repo.

What you get per job

{
  "title": "Software Engineer I",
  "companyName": "Indeed",
  "location": "Austin, TX",
  "postedAt": "2026-09-15",
  "employmentTypes": ["FULLTIME"],
  "salary": "94K–142K a year",
  "salaryMin": 94000,
  "salaryMax": 142000,
  "salaryPeriod": "YEAR",
  "applyOptions": [
    { "publisher": "Indeed", "url": "https://www.indeed.com/viewjob?jk=177a2f345faeafd5" },
    { "publisher": "Built In", "url": "https://builtin.com/job/software-engineer-i/..." }
  ],
  "qualifications": ["Bachelor's degree in Computer Science or related field", "..."],
  "description": "About the role ..."
}

The parts that are hardest to get yourself:

Direct apply links to every board that lists the job, not Google redirect URLs. One job usually has several (LinkedIn, Indeed, the company's own site).
Parsed salaries: salaryMin, salaryMax, salaryCurrency and salaryPeriod next to the raw text.
A real posting date: Google only says "3 days ago"; postedAt turns that into a date.
Highlights and the full description: qualifications, responsibilities and benefits as lists.

Option 1: no code

Open the Google Jobs Scraper and click Try for free. A free Apify account is enough.
Enter one or more search queries (data analyst) and locations (Chicago, IL).
Optionally pick a date range (last 3 days, last week…) and an employment type.
Click Start, then download the results as CSV, Excel or JSON.

Option 2: Python

Install the Apify client and set your API token (Console → Settings → Integrations):

pip install apify-client
export APIFY_TOKEN=...

This script searches for data analyst jobs in Chicago posted in the last week, saves them as CSV and prints the median advertised salary:

import csv
import os
from decimal import Decimal
from statistics import median

from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])

run = client.actor("plain-signal/google-jobs-scraper").call(
    run_input={
        "queries": ["data analyst"],
        "locations": ["Chicago, IL"],
        "country": "us",
        "datePosted": "week",
        "maxJobsPerSearch": 30,
        "includeDescription": False,
    },
    max_total_charge_usd=Decimal("0.50"),  # hard cap on what this run can cost
)
jobs = list(client.dataset(run.default_dataset_id).iterate_items())

with open("jobs.csv", "w", newline="") as f:
    w = csv.writer(f)
    w.writerow(["title", "company", "location", "posted", "salary", "apply_url"])
    for j in jobs:
        apply_url = j["applyOptions"][0]["url"] if j["applyOptions"] else j["googleJobsUrl"]
        w.writerow([j["title"], j["companyName"], j["location"], j["postedAt"], j["salary"], apply_url])

yearly = [(j["salaryMin"] + j["salaryMax"]) / 2 for j in jobs if j["salaryPeriod"] == "YEAR" and j["salaryMin"]]
print(f"{len(jobs)} jobs saved to jobs.csv")
if yearly:
    print(f"{len(yearly)} list a yearly salary, median midpoint ${median(yearly):,.0f}")

Output from a run on 2026-10-02:

30 jobs saved to jobs.csv
6 list a yearly salary, median midpoint $78,750

title,company,location,posted,salary,apply_url
"Data Analyst, Marketing (Hybrid)",Rewards Network,"Chicago, IL",2026-10-01,,https://www.linkedin.com/jobs/view/...
"Data Analyst, Intern",Stripe,"Chicago, IL",2026-10-01,,https://www.linkedin.com/jobs/view/...

Two things worth knowing:

max_total_charge_usd caps the cost of the run. The scraper stops once it's reached, so a typo in maxJobsPerSearch can't cost you more than you planned.
Only about a third of US jobs show a salary on Google. If salary analysis is the goal, run more queries or locations to get a bigger sample.

Option 3: a daily job alert in Slack

The scraper has a monitor mode: give it a monitorName, and each run returns only jobs that earlier runs with the same name haven't returned. Run it once a day and you have a job alert:

import json
import os
import urllib.request
from decimal import Decimal

from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])

run = client.actor("plain-signal/google-jobs-scraper").call(
    run_input={
        "queries": ["product designer"],
        "locations": ["Remote"],
        "country": "us",
        "datePosted": "3days",
        "maxJobsPerSearch": 50,
        "includeDescription": False,
        "monitorName": "remote-product-design",
    },
    max_total_charge_usd=Decimal("0.50"),
)
jobs = list(client.dataset(run.default_dataset_id).iterate_items())

lines = [f"*{j['title']}* at {j['companyName']} ({j['location']}) {j['salary'] or ''}\n"
         f"{j['applyOptions'][0]['url'] if j['applyOptions'] else j['googleJobsUrl']}" for j in jobs]
text = f"{len(jobs)} new jobs\n\n" + "\n\n".join(lines) if jobs else "No new jobs today."

webhook = os.environ.get("SLACK_WEBHOOK_URL")
if webhook:
    req = urllib.request.Request(webhook, data=json.dumps({"text": text}).encode(),
                                 headers={"Content-Type": "application/json"})
    urllib.request.urlopen(req)
else:
    print(text)

The first run returns everything that matches (50 jobs in my test). Later runs return only what's new. Schedule it with cron or GitHub Actions. If you'd rather not run code at all, create a schedule in the Apify Console and connect the Slack, Google Sheets or email integration to the actor.

What does it cost?

The scraper charges $0.005 per job ($5 per 1,000), with no monthly fee. The 30-job Chicago search above cost $0.15, and a daily alert with about 30 new jobs a day comes to around $4.50 a month. Duplicates and jobs removed by your filters aren't charged. Apify's free plan includes monthly platform credit, which is enough to try all of the above.

How it gets more than 10 jobs per search

Google renders only the first 10 jobs of a search on the server. The rest come from infinite scrolling in the browser. Instead of driving a headless browser, the scraper runs your search again with Google's own filter phrases appended ("full time", "remote", "entry level", "in the last 3 days"…). Google Jobs treats these as filters, so every result still matches your query, but each variant surfaces a different set of 10. Merged and deduplicated by Google's job ID, that usually gives 50 to 150 unique jobs per search.

For broad coverage, several specific searches beat one broad one: "nurse" in five cities returns far more distinct jobs than "nurse" in one state.

Tips

Other countries: set country (gb, de, in, ca, au…) and use local place names. Keep language on en for the most complete data. In some countries (for example Germany) Google shows only a preview of the description.
Company names: for some listings Google names the job board as the company (e.g. "Indeed"). The apply links still point to the real posting.
Speed: a 30-job search takes under a minute, a 50-job search about two. Searches run in parallel, so 10 searches don't take 10 times as long.

Wrapping up

All three examples are in the plain-signal/examples repo, along with an example for the Funding Rounds Tracker (US companies that just raised money, from SEC filings). Questions and feature requests are welcome in the comments or on the actor's Issues tab.

This article was written with AI assistance. All code was run against the live scraper before publishing, and the outputs shown are real.