DEV Community: ivanpetrus

Checking hotel prices on every booking site at once (and catching rate parity problems)

ivanpetrus — Sat, 10 Oct 2026 10:40:05 +0000

If you've ever booked a hotel online, you've probably seen this. The hotel's own site says €120 a night. Some site you've never heard of says €104. Same room, same dates.

Good for the guest. Not great for the hotel. They pay commission on that booking and still lose on price to a reseller. That's a rate parity problem, and it's common.

Hotels have a whole job for this. Revenue managers check competitor and OTA prices every morning. Many do it by hand, or pay for a rate shopping tool that isn't cheap.

I built a smaller, cheaper option because the data is already public on Google Hotels. Disclosure: it's mine, the Google Hotels Rate Monitor on Apify. I'll tell you where it falls short too.

Google already did the hard part

Open any hotel on Google Hotels and you see a list: Booking.com, Expedia, Agoda, Trip.com, Hotels.com, the hotel's own website and a bunch of smaller sites. Each with a price for your dates.

That list is the gold. One page, up to 20 booking sites. You don't need to scrape 20 websites. You need to read one page, for the right dates.

"For the right dates" turned out to be the hard bit. Google likes to quietly show you its own default dates if it doesn't like your request. So the actor checks the dates Google actually priced. If they don't match, the row is dropped and you don't pay for it.

What you put in

{
  "hotels": ["Hotel Botanico Lisbon"],
  "daysAhead": 7,
  "rollingDates": 14,
  "nights": 2,
  "adults": 2,
  "currency": "EUR"
}

You can use a hotel name with the city, a Google Hotels URL, or a search like "hotels in Lisbon" (it takes the top hotels and keeps tracking the same ones on later runs).

Rolling dates are the handy part. "Next 14 check-in dates, starting a week from today" moves with each run. So a daily schedule always looks at the same window ahead. No editing dates every Monday.

What you get back

A real row from a cloud run (I cut the price list from 20 sites to 3):

{"type": "hotelDate", "hotelName": "Hotel Botânico",
 "checkIn": "2026-10-23", "checkOut": "2026-10-25", "nights": 2,
 "lowestPrice": 103.94, "lowestPriceSite": "Vio.com",
 "officialSitePrice": 120.5, "cheapestOta": "Vio.com",
 "parityGapPct": 15.93, "sitesCount": 20,
 "prices": [
   {"site": "Vio.com", "pricePerNight": 103.94, "isOfficialSite": false},
   {"site": "Trip.com", "pricePerNight": 103.98, "isOfficialSite": false},
   {"site": "Hotel Botânico", "pricePerNight": 120.5, "isOfficialSite": true}
 ]}

Look at parityGapPct. The hotel's own site is almost 16% more expensive than the cheapest OTA. That's exactly the parity problem from the start of this post, in one number.

In monitor mode, later runs only give you what moved: a site changed its price (old, new, delta), the lowest price changed, the cheapest site changed, or the stay sold out. Small changes can be filtered with minChangePct or minChangeAmount.

A tiny parity report in Python

from apify_client import ApifyClient
import pandas as pd

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("ivora/google-hotels-rate-monitor").call(run_input={
    "hotels": ["Hotel Botanico Lisbon"],
    "daysAhead": 7, "rollingDates": 14, "nights": 2, "currency": "EUR",
})

rows = client.dataset(run["defaultDatasetId"]).list_items().items
df = pd.DataFrame([r for r in rows if r.get("type") == "hotelDate"])
bad = df[df["parityGapPct"] > 5]
print(bad[["hotelName", "checkIn", "officialSitePrice", "cheapestOta", "parityGapPct"]])

Five lines of pandas and you know which dates someone is undercutting you. Send it to Slack with an Apify webhook and you're done before coffee.

Price

No subscription:

$0.005 per run start
$0.003 per hotel and date checked
$0.0005 per change row

One hotel, 14 dates, every day: about $1.50 a month. A competitor set of five hotels is around $6.50. Failed pages and wrong dates are not charged.

Limits

Prices are what Google shows. Usually the cheapest standard room. US prices often exclude taxes, EU and UK usually include them. Member and mobile-only rates aren't visible.
Small booking sites come and go between runs. The big OTAs and the hotel's own site are stable.
Name matching takes Google's first hit. Check hotelName on the first run, or paste the URL.
Destination searches give max 20 hotels (Google's first page).

It's not a full revenue management system. It's a cheap daily answer to "who is cheaper than us, and since when?"

Details: ivora.life/products/google-hotels-rate-monitor. The actor: apify.com/ivora/google-hotels-rate-monitor.

If you work in hotels, I'd love to hear what your morning rate check looks like. Spreadsheet? Tool? Pure suffering?

I stopped checking competitor Shopify stores by hand. Here's what I use instead

ivanpetrus — Sat, 10 Oct 2026 10:39:51 +0000

If you sell on Shopify, you probably have a few competitors you keep an eye on. Maybe every Monday you open their stores in five tabs and scroll. New products? Price drop? Something sold out? Then you write it down somewhere. It's slow, it's boring, and you still miss things.

I built a tool to do this because it felt like a job a computer should do. This post is how it works, what I learned building it, and where it breaks. Fair warning: the tool at the end is mine (Shopify Store Monitor on Apify). You can also just use the trick below with plain curl.

The trick: products.json

Most Shopify stores publish their whole catalog as JSON. No login, no API key. Try it:

curl -s "https://allbirds.com/products.json?limit=250&page=1" | head -c 600

You get titles, handles, vendors, variants, prices, compare-at prices and an available flag for each variant. That's basically everything you'd scroll for by hand.

The catch is that a snapshot is boring. Nobody cares that a shoe costs $100. You care that it cost $125 yesterday.

What "changed" actually means

When I sat down to write the diff, the list got longer than I expected:

a new product showed up
a product disappeared
the price went up or down
a sale started or ended (that's the compare-at price)
a size sold out, or came back
variants were added or removed

Sales were the sneaky one. A store often keeps the price and just sets a compare-at price, so the product page suddenly shows "~~$125~~ $99". If you only diff price, you miss half the action.

The monitor

I wrapped this into an Apify actor. You give it a list of stores. The first run saves a baseline. Every next run gives you only the changes. Put it on a daily schedule and you have a competitor feed.

Input looks like this:

{
  "stores": ["allbirds.com", "gymshark.com"],
  "changeTypes": ["priceChange", "compareAtChange", "stockChange", "newProduct"],
  "minPriceChangePct": 5
}

minPriceChangePct is there because some stores move prices by a few cents all the time. Nobody needs a ping for $0.30.

A real change row from a test run (shortened):

{"type": "change", "changeType": "priceChange", "store": "Allbirds",
 "title": "Men's Canvas Runner NZ - Deep Navy Stripes (Blizzard Sole)",
 "direction": "down", "oldPrice": 125.0, "newPrice": 100.0, "changePct": -20.0,
 "url": "https://allbirds.com/products/mens-canvas-runner-nz"}

That's the whole point. One line, one fact, one link.

Each store also gets a free summary row: catalog size, how many items are on sale or sold out, price range, newest launches. Handy for a quick "how big is this guy, really" check.

Pulling it into Python

If you want a weekly log, here's the short version with the official client:

from apify_client import ApifyClient
import pandas as pd

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("ivora/shopify-store-monitor").call(run_input={
    "stores": ["allbirds.com", "gymshark.com"],
})

rows = client.dataset(run["defaultDatasetId"]).list_items().items
df = pd.DataFrame([r for r in rows if r.get("type") == "change"])
print(df.groupby(["store", "changeType"]).size())

Add a webhook in Apify and the same rows land in Slack, email, Zapier, Make or n8n. Getting the list in Slack with your morning coffee beats scrolling five stores.

What it costs

Pay per use, no subscription:

$0.003 per run start
$0.004 per store checked
$0.0005 per change row

Five stores checked every day comes out to well under $1 a month. Stores the actor can't read get a free error row and aren't charged.

Where it breaks (honestly)

Not every store works. In my cloud test, 12 of 13 big brand stores were fine. Some stores turn off the feed or run a custom frontend. bombas.com said no even through a residential proxy.
Stock is yes or no. The public feed shows available, not "3 left".
Prices are the base currency. Market-specific prices and checkout discounts aren't visible.

That's it. No magic, just a JSON file most people don't know exists, and a diff.

If you sell on Shopify, try the curl line on your biggest competitor right now. It's a little weird how much is out there.

More details and pricing: ivora.life/products/shopify-store-monitor. The actor: apify.com/ivora/shopify-store-monitor.

Got a store where it doesn't work? Tell me in the comments. Those reports help me fix things.

Pulling Google Trends data in Python without constantly hitting 429s

ivanpetrus — Fri, 09 Oct 2026 16:37:43 +0000

If you've ever used pytrends, you know the arc. The first three requests work. You get excited, wrap it in a loop over 40 keywords, and somewhere around keyword seven Google starts answering with HTTP 429. You add time.sleep(5). Then time.sleep(30). Then you start reading Stack Overflow threads from 2019 about rotating user agents.

pytrends itself is archived now (the GitHub repo is read-only, last push in August 2024), so the duct tape is all yours. I ended up building my own Google Trends actor on Apify, and most of the work went into exactly this: not babysitting retries. This post is what I learned about why the 429s happen, and how I pull interest over time, regional data and trending searches from Python now. The actor is mine (Google Trends Scraper & API), so read this with that in mind.

Why Google Trends rate-limits you so fast

Google has no public Trends API. What everyone uses (pytrends, my actor, every other scraper) are the JSON endpoints the Trends website calls in your browser. And one keyword isn't one request. You first hit an "explore" endpoint that hands back widget tokens, then make a separate request per widget: one for the timeline, one for regions, one for related queries. So 40 keywords is well over 100 requests, all from the same IP, in a short burst. That's exactly the pattern a rate limiter is built to stop.

In my cloud tests the numbers looked like this. One keyword ("air fryer", US) on a datacenter proxy took 12 HTTP requests, and 4 of those were 429s. A 5-keyword batch through residential proxies hit 8 rate limits before finishing. Both runs succeeded, but only because every 429 got a new IP and a backoff instead of a crash.

What the actor does on a 429 is boring, which is the point. It rotates to a fresh proxy session, waits with exponential backoff and some random jitter (starting around 2 seconds, capped at a minute), and retries, up to maxRetries times (8 by default). Datacenter proxies go first because they're fast and cheap. After two blocks in a row, it switches the rest of the run to residential proxies (residentialFallback). If a query still fails, you get a row with status: "failed", an error and a hint, and you're not charged for it. I care a lot about that last part. A silent gap in a time series is much worse than a loud error.

The part nobody tells you: USER_TYPE_SCRAPER

This is the most interesting thing I found while building it, and also the most annoying.

Google tags each Trends session with a user type. Automated sessions get USER_TYPE_SCRAPER. I expected datacenter IPs to get flagged. I did not expect residential IPs to get flagged too, and I really didn't expect a real headless Chrome to get flagged. All three did, in October 2026.

The flag doesn't seem to touch the main data. Timelines, regional values, top related queries and trending searches matched what a normal browser shows. But two things change. Related topics get withheld completely. And "rising" related queries get decoys mixed in. For "air fryer" I got rising queries like "hotel booking", "coffee grinder" and "laptop stand". For "iphone" I got "iphone 6s to buy" and "iphone 3gs to buy" as Breakout terms, which would be a fun market insight if it were true.

So the actor tells you when this happened (every keyword row has googleUserType and a dataQualityWarning) and runs a decoy filter on rising queries (risingFilter, strict by default). Suspicious entries are moved into suspectedDecoys with a reason, not deleted, so you can check what was removed. In one test with three keywords, it kept 47 rising queries and moved 28. I'd still call rising queries experimental. Top queries, timelines and regions are the data I'd actually build on.

Setup

pip install "apify-client>=3" pandas
export APIFY_TOKEN=your_token_here   # Apify Console > Settings > API & Integrations

Pricing: $0.01 per run plus $1.50 per 1,000 results. A result is one keyword with its timeline, regions and related queries, or one trending search. So 100 keywords is about $0.16. Proxies are included; you don't pay for them separately.

Interest over time

Start with one keyword and look at what comes back:

import os

from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
ACTOR = "ivora/google-trends-api"

run = client.actor(ACTOR).call(run_input={
    "searchTerms": ["air fryer"],
    "geo": "US",
    "timeRange": "today 3-m",
})
row = next(client.dataset(run.default_dataset_id).iterate_items())

print(row["status"], row["googleUserType"])
print(row["interestOverTimeSummary"]["air fryer"])
print([q["query"] for q in row["relatedQueries"]["air fryer"]["top"][:4]])

From my test run:

ok USER_TYPE_SCRAPER
{'average': 54.92, 'max': 100, 'min': 37, 'latest': 42, 'peakDate': '2026-08-12', 'changePercent': -9.3, 'direction': 'stable'}
['air fryer chicken', 'chicken in air fryer', 'air fryer oven', 'ninja air fryer']

Yes, Americans search "air fryer chicken" and "chicken in air fryer" as two separate things. No, I can't explain it.

The summary block (average, peak date, latest value, % change, direction) is computed by the actor so you don't have to redo it for every term. The raw timeline is in interestOverTime, a list of {"date": ..., "values": {term: value}} points.

For a batch, here's how I turn it into one DataFrame:

import pandas as pd

terms = ["air fryer", "standing desk", "protein powder"]
run = client.actor(ACTOR).call(run_input={
    "searchTerms": terms,
    "geo": "US",
    "timeRange": "today 12-m",
    "maxRetries": 8,
})

series = {}
for it in client.dataset(run.default_dataset_id).iterate_items():
    if it.get("status") != "ok":
        print("failed:", it.get("searchTerm"), it.get("error"), it.get("hint"))
        continue
    points = it["interestOverTime"]
    for term in it["interestOverTimeSummary"]:
        series[term] = pd.Series(
            {p["date"]: p["values"][term] for p in points}, name=term
        )

df = pd.DataFrame(series)
df.index = pd.to_datetime(df.index)
print(df.tail())
print(df.idxmax())  # peak week per term

One thing that trips people up: in the default comparisonMode: "separate", each term is its own query and Google scales each one to 0-100 on its own. "Protein powder at 80" and "air fryer at 80" do not mean the same search volume. If you want them on one scale, like the compare box on the Trends website, use "comparisonMode": "compareAll". That compares up to 5 terms per query.

The results can be humbling. I compared "iphone", "samsung galaxy" and "google pixel" in the US over 12 months. iPhone averaged 62.6. Samsung Galaxy averaged 4.32. Google Pixel averaged 1.36, with a peak of 2.

run = client.actor(ACTOR).call(run_input={
    "searchTerms": ["iphone", "samsung galaxy", "google pixel"],
    "comparisonMode": "compareAll",
    "geo": "US",
    "timeRange": "today 12-m",
})
row = next(client.dataset(run.default_dataset_id).iterate_items())
summary = pd.DataFrame(row["interestOverTimeSummary"]).T
print(summary[["average", "max", "latest", "direction"]])

Interest by region

interestByRegion comes in the same row. Worldwide queries give you countries. With a country in geo, you get states or regions by default, and you can ask for cities or US metros with regionResolution (REGION, CITY, DMA). Google doesn't always have city data for smaller terms, so the actor falls back to the next level and tells you which one it used in interestByRegionResolution. That fallback exists because an empty city list looks exactly like a bug in your own code, and it usually isn't.

run = client.actor(ACTOR).call(run_input={
    "searchTerms": ["air fryer"],
    "geo": "US",
    "timeRange": "today 3-m",
    "regionResolution": "REGION",
})
row = next(client.dataset(run.default_dataset_id).iterate_items())

regions = pd.DataFrame(
    [{"code": r["geoCode"], "name": r["geoName"], "value": r["values"]["air fryer"]}
     for r in row["interestByRegion"]]
).sort_values("value", ascending=False)

print(row["interestByRegionResolution"])
print(regions.head(5).to_string(index=False))

In my run, Oklahoma came out at 100, Kentucky at 91 and Louisiana at 89. Same caveat as before: these values are relative. 100 means "highest share of searches for this term among all states", not "most searches". Small states win this a lot.

If you need low-volume regions too (Google returns them as 0), set includeLowVolumeRegions. And if you want YouTube or Google Shopping search instead of web search, there's property (youtube, froogle, and so on). Yes, Google Shopping is still called "froogle" in the API. Some things never get renamed.

A few gotchas I hit

The timezoneOffsetMinutes input maps to Google's tz parameter, and Google's sign is inverted. UTC+3 (Kyiv, where I live) is -180. It's the kind of detail that quietly shifts every hourly chart by three hours and nobody notices for a week.

Custom date ranges use customTimeRange with the format "2024-01-01 2024-12-31". Google picks the granularity (daily, weekly, monthly) based on the length of the range, not you. Long ranges give you monthly points whether you like it or not.

If you already have a Trends URL from the browser, paste it into startUrls. The actor takes its terms, geo, date, category and search type exactly as they are, which is handy when someone on the team says "can you pull this one" and sends a link.

And set a budget. maxItems stops the run after N results, and the Apify client lets you cap spend per run:

from decimal import Decimal

run = client.actor(ACTOR).call(
    run_input={"searchTerms": terms, "geo": "US"},
    max_total_charge_usd=Decimal("0.50"),
)

If you just want to keep using pytrends for a handful of keywords, that's fair. Keep requests slow, cache everything, and accept that some days Google will simply not talk to your IP. Once I needed a few hundred keywords on a schedule, maintaining my own retry and proxy logic stopped being fun, which is how this actor happened. It's on Apify Store if you want to try it on your own keywords.

Tracking which companies are hiring (Greenhouse, Lever, Ashby, Workday) as a sales signal with Python

ivanpetrus — Fri, 09 Oct 2026 16:37:19 +0000

A company that just opened four "Account Executive, DACH" roles has budget, a plan, and probably a sales stack that's about to get more complicated. A company that quietly closed half its engineering reqs is having a different kind of quarter. Neither of them will tell you this in a press release. They'll tell you on their careers page.

I think job postings are the most honest thing most companies publish. A blog post is marketing. A req for "Head of RevOps" is a line in a budget somebody already approved.

So I built a small tool that watches company job boards and tells me what changed since yesterday. This post is how I use it: a daily new-jobs alert, a quick way to enrich a lead list with hiring data, and a few lines of pandas on top. Disclosure up front: the Apify actor in this post is mine (ATS Jobs Scraper & Hiring Monitor). I'll be clear about where it falls short, because it does.

Why job boards are easier than they look

Most tech companies don't run their own careers backend. They use an ATS (applicant tracking system) like Greenhouse, Lever, Ashby or Workday, and those systems publish public job-board endpoints so companies can embed listings on their own site. No login, no personal data, just the list of open roles with titles, departments, locations and sometimes salary ranges.

The annoying part is that you don't know which ATS a company uses until you look. Figma is on Greenhouse. Notion is on Ashby. NVIDIA is on Workday. Canva turned out to be on SmartRecruiters. If you're watching 50 companies, figuring this out by hand gets old by about company number six.

The actor handles that. You give it a domain (figma.com), a careers URL, a board URL (https://jobs.lever.co/palantir) or an explicit ats:token like greenhouse:airbnb. It scans the careers pages for ATS links and embeds, and if that finds nothing it tries the domain name as a board token on each supported ATS. Those guesses get marked detectionMethod: "slug-guess" so you know to double-check them.

When I tested it with 12 domains in the Apify cloud, 11 were detected. The twelfth was shopify.com, which runs its own in-house careers system. The actor did find a Workable board called "shopify" with zero open jobs, sensibly ignored it, and returned an error row with a hint. That's the right outcome. A confident wrong answer would be worse.

All you need is the official Python client and an Apify token:

pip install "apify-client>=3" pandas requests
export APIFY_TOKEN=your_token_here   # Apify Console > Settings > API & Integrations

Pricing is pay per event: $0.003 per run, $0.003 per company checked, and $0.001 per job row. The summary rows (one per company), closed-job rows and error rows are free. That pricing shapes how I use it, as you'll see below.

A daily "who started hiring for what" alert

The idea is simple. Monitor mode (onlyNewJobs, on by default) stores each company's open jobs in a named key-value store on your Apify account. The next run compares against that and outputs only the new jobs, plus free rows for jobs that disappeared.

On the very first run you'd normally get every open job back, which for a company like Airbnb is 163 rows you'll never read. firstRunBehavior: "baselineOnly" skips that: it just remembers what's there and outputs nothing, so from day two you only get actual changes.

Here's the script for a morning run. It filters to sales and data roles (swap in whatever titles mean "budget for my product" in your world), groups new jobs by company and posts them to a Slack incoming webhook.

import os
from collections import defaultdict
from decimal import Decimal

import requests
from apify_client import ApifyClient

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

run_input = {
    "companies": [
        "notion.so",
        "figma.com",
        "monzo.com",
        "doctolib.fr",
        "greenhouse:airbnb",
        "https://jobs.lever.co/palantir",
        "https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite",
    ],
    "onlyNewJobs": True,
    "firstRunBehavior": "baselineOnly",
    "includeClosedJobs": True,
    "titleKeywords": ["sales", "account executive", "revops", "data engineer"],
    "excludeTitleKeywords": ["intern"],
    "maxJobsOutputPerCompany": 50,
    "stateStoreName": "sales-signals",
}

run = client.actor("ivora/company-hiring-monitor").call(
    run_input=run_input,
    max_total_charge_usd=Decimal("1.00"),  # hard cap per run
)
if run is None or run.status != "SUCCEEDED":
    raise SystemExit(f"Run did not succeed: {run.status if run else 'not started'}")

new_jobs = defaultdict(list)
summaries = {}
for item in client.dataset(run.default_dataset_id).iterate_items():
    kind = item["type"]
    if kind == "job" and item.get("isNew"):
        new_jobs[item["company"]].append(item)
    elif kind == "summary":
        summaries[item["company"]] = item
    elif kind == "error":
        print(f"Skipped {item['companyInput']}: {item['error']}")

lines = []
for company, jobs in sorted(new_jobs.items(), key=lambda kv: -len(kv[1])):
    s = summaries.get(company, {})
    change = s.get("openJobsChange")
    context = f" ({s['openJobs']} open, {change:+d} since last run)" if change is not None else ""
    lines.append(f"*{company}*: {len(jobs)} new matching roles{context}")
    for job in jobs[:5]:
        where = job.get("location") or "location n/a"
        lines.append(f"    â€¢ <{job['url']}|{job['title']}> ({where})")

if lines:
    requests.post(os.environ["SLACK_WEBHOOK_URL"], json={"text": "\n".join(lines)}, timeout=30)
else:
    print("Nothing new today.")

A few notes on the code, since some of this isn't obvious.

The keyword filters only apply to job and closed-job rows. The summary row always covers all of a company's jobs, so openJobs and openJobsChange in the message describe the whole company, not just the sales roles. I actually like that. "3 new sales roles, and the company is +12 overall" is a better signal than either number alone.

I check isNew even though monitor mode already filters, because if someone flips firstRunBehavior back to outputAll the first run will dump every job with isNew: false, and I don't want a 300-line Slack message at 8am.

maxJobsOutputPerCompany is a cost guard. If a company you watch suddenly posts 400 jobs (it happens after funding rounds), you pay for at most 50 rows. Jobs above the cap still get remembered as seen, so they don't show up again tomorrow.

And use a separate stateStoreName per monitor. If you run one list for client A and another for client B with the same store name, they'll step on each other's state.

You can run this from cron, or skip the script entirely: save the input as an Apify task, add a daily schedule, and point a "Run succeeded" webhook at Zapier, Make or n8n. I also made an importable n8n template that does the whole thing without Python. Honestly, a cron job on a cheap VPS works fine too.

The Workday problem

Workday deserves its own section, because it was the most annoying ATS to deal with.

Greenhouse, Lever and Ashby hand you the whole board in one response. Workday pages through results 20 at a time. In my cloud test, NVIDIA alone took about 28 seconds, while Figma's 151 jobs took 2.4 seconds.

Worse, Workday lists at most around 2,000 postings per career site. NVIDIA's summary row came back with openJobs: 2000 and listComplete: false, which means "at least 2,000", not "exactly 2,000". When the list is cut, the actor turns off closed-job detection for that company, because a job missing from a truncated list doesn't mean it was closed. New-job detection still works on the jobs it could read.

Workday also doesn't give you a department per job, so the summary falls back to Workday's own category counts (that's where NVIDIA's "Engineering: 1,719" comes from). Posted dates are approximate, parsed from strings like "Posted 3 Days Ago", and "Posted 30+ Days Ago" becomes null. I'd love to say I found a clever way around all this. I didn't. It's just what Workday exposes.

Enriching a lead list with hiring data

This is my favorite use, and it's cheap because of how the pricing works.

Summary rows are free. On a first run with baselineOnly, the actor outputs no job rows at all, just one summary per company. So you pay $0.003 per company (plus $0.003 for the run) and get open roles, top departments, top locations, remote and salary counts, and which ATS they use. A list of 500 domains costs about $1.50.

import os
from datetime import date

import pandas as pd
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
leads = pd.read_csv("leads.csv")  # needs a "domain" column

run = client.actor("ivora/company-hiring-monitor").call(run_input={
    "companies": leads["domain"].dropna().unique().tolist(),
    "onlyNewJobs": True,
    "firstRunBehavior": "baselineOnly",  # summaries only, no job rows
    "stateStoreName": f"lead-enrich-{date.today():%Y%m%d}",
    "maxConcurrency": 5,
})


def dept_count(departments, word):
    return sum(d["count"] for d in departments or [] if word in d["name"].lower())


rows = []
for it in client.dataset(run.default_dataset_id).iterate_items():
    if it["type"] == "summary":
        rows.append({
            "domain": it["companyInput"],
            "ats": it["ats"],
            "open_jobs": it["openJobs"],
            "sales_jobs": dept_count(it["topDepartments"], "sales"),
            "remote_jobs": it["remoteJobs"],
            "with_salary": it["jobsWithSalary"],
            "detection": it["detectionMethod"],
            "complete": it["listComplete"],
        })
    elif it["type"] == "error":
        rows.append({"domain": it["companyInput"], "ats": "not found"})

enriched = leads.merge(pd.DataFrame(rows), on="domain", how="left")
for col in ["open_jobs", "sales_jobs", "remote_jobs", "with_salary"]:
    enriched[col] = enriched[col].astype("Int64")  # keep counts as ints next to the NA rows
enriched.to_csv("leads_enriched.csv", index=False)

The join works because every row carries companyInput, the exact string you sent in. Here's what the 12-domain test run looked like after this step (real numbers from October 8, 2026):

       domain             ats  open_jobs  sales_jobs  remote_jobs  with_salary   detection  complete
    notion.so           Ashby        134          43            0            0  page-scan      True
    figma.com      Greenhouse        151          50            0          101  page-scan      True
   stripe.com      Greenhouse        725          27           86            0  slug-guess     False
  doctolib.fr      Greenhouse        155          45            0            0  slug-guess     True
    canva.com SmartRecruiters        125          26           20            0  slug-guess     True
    monzo.com      Greenhouse         69           0           42            0  page-scan      True
  shopify.com       not found       <NA>        <NA>         <NA>         <NA>        NaN      NaN
   nvidia.com         Workday       2000         334           14            0  page-scan      False

(I trimmed a few rows and shortened "careers-page-scan" so it fits.) Stripe shows complete: False only because that test capped reading at 500 jobs per company. The default maxJobsPerCompany is 2,000.

One thing that surprised me: sales_jobs is a rough number. topDepartments holds the top eight departments, and department names are whatever the company typed into its ATS. Notion and Figma literally have a department called "Sales". Stripe's departments look like "1185 Account Executives (EMEA)" and "1642 Product Sales - MaaS", cost-center numbers included. If you need precision, run with titleKeywords and count job rows instead of trusting department names.

The side effect I like: that dated state store is now a baseline. Reuse the same stateStoreName next week and the run gives you only jobs posted since, for every company on the list.

A little pandas for trends

If you save the summary rows from your daily run (just pd.DataFrame(summaries.values()) with a date column, appended to a CSV), after five or six weeks you can see who's actually growing:

import pandas as pd

log = pd.read_csv("hiring_summary_log.csv", parse_dates=["date"])
log = log[log["listComplete"]]  # skip truncated boards, their counts are a floor

wide = log.pivot_table(index="date", columns="company", values="openJobs", aggfunc="last")
weekly = wide.resample("W-MON").last()
change_4w = (weekly.iloc[-1] - weekly.iloc[-5]) / weekly.iloc[-5] * 100

print(change_4w.dropna().sort_values(ascending=False).round(1).head(10))

The summary row also has hiringTrend (growing, stable or shrinking) and newDepartments / newLocations, which I find more interesting than raw counts. A company posting its first role in a new country is usually a better sales trigger than a company going from 140 to 150 engineers. On a second run of my test list a minute later, everything came back stable with zero new jobs, which is what you'd hope for. Boring, but correct.

Where it doesn't work

Detection isn't 100%. Companies on iCIMS, Taleo, SuccessFactors or Jobvite, or with an in-house system like Shopify, come back as error rows (free, with a hint). A slug guess can also match a different company with the same name, so check boardUrl on any slug-guess row before you put it in front of a sales team. You can always force the right board with ats:token.

Salary data depends entirely on the company. Figma publishes pay ranges on 101 of its 151 jobs. Plenty of companies publish none.

And it's company-level data only. No candidate data, no employee data, nothing about people. That was a deliberate choice, and it also means the data is about as uncontroversial as scraped data gets: companies put these listings online because they want them seen.

If you try it and a company you care about isn't detected, open an issue on the actor page with its careers URL. Those reports are the fastest way for me to find out which careers pages I'm still reading wrong.

How to Monitor Your Competitors' Ads Automatically (Google, LinkedIn and Bing) with Apify

ivanpetrus — Thu, 08 Oct 2026 12:12:53 +0000

When a competitor launches a new offer, you usually see it in their ads first: a new headline, a new landing page, a new video, a webinar promo. You can watch for these yourself, because Google, LinkedIn and Microsoft all publish public ad libraries that show who is advertising and what they are running.

What these libraries don't give you is a way to say "tell me when something new shows up." This tutorial covers how to turn them into an automated feed of new competitor ads, delivered to Slack or email every morning, plus how to pull the same data with Python and analyze it with pandas.

What you'll build:

A daily job that checks your competitors on Google (Search, Display, YouTube), LinkedIn and Bing
Output that contains only ads that appeared since the previous run
Alerts in Slack or email, or a webhook into Zapier, Make or n8n
A small Python script that collects the results and counts new ads per competitor per week

Disclosure: I built the three Apify actors used in this guide. I've tried to be clear about what they can't do. Each section on limits comes straight from the actors' documentation.

Why ad libraries exist, and what each one shows

Ad transparency libraries exist so the public can see who is paying to show them ads. For Europe, the EU Digital Services Act (DSA) is the main driver. It's why LinkedIn and Microsoft publish run dates, reach and targeting for ads shown in the EU. For marketers, these libraries are the most reliable public source of competitor creative, because the platforms publish the data themselves.

	Google Ads Transparency Center	LinkedIn Ad Library	Microsoft Ad Library
Website	adstransparency.google.com	linkedin.com/ad-library	adlibrary.ads.microsoft.com
Coverage	Ads on Search, YouTube, Display and Shopping, any country	Ads that ran on LinkedIn in roughly the last year	Bing / Microsoft Advertising ads with impressions in the EU/EEA only
Who's behind it	Verified advertiser name and ID	Advertiser, "Paid for by"	Advertiser, "paid for by" (e.g. an agency)
Dates	First and last shown	Start/end dates for EU ads	First/last impression in the EU/EEA
Reach	Impression ranges per country (where Google shows them)	Impression range and share by country (EU ads)	Impression range and share by country
Targeting	Not shown	Language, location and which parameters were used (EU ads)	Targeting types (Location, Age, Gender, Audiences)
Spend / clicks	No	No	No

The last row matters: none of these libraries publish spend or clicks for commercial ads. If a tool claims to show competitors' exact budgets from these sources, be skeptical.

The manual way, and why it doesn't scale

You can do all of this by hand:

Open each library and search for a competitor.
Scroll through the results, newest first.
Try to remember (or screenshot) what was there last week.
Repeat for every competitor, every country and every platform.

With five competitors on three platforms you're running 15 searches, and that's before you add countries. The real problem is step 3. None of these websites tells you what's new since you last looked, so you end up eyeballing grids of creatives and comparing them from memory. Most teams do this once, maybe twice, and then stop.

Automation fixes exactly that step. A script checks every competitor on a schedule, remembers which ads it has already seen, and reports only the difference.

The tools

I'll use three actors from Apify Store. Each one wraps one library and follows the same conventions:

Google Ads Transparency Scraper & New Ads Monitor: input competitor domains, advertiser IDs (AR...) or advertiser names.
LinkedIn Ad Library Scraper & New Ads Monitor: input company names, keywords from ad copy, or payers. No LinkedIn login or cookies needed.
Bing Ads Library Scraper - Microsoft Ads Monitor (EU): input advertiser names, advertiser IDs, or search terms. It uses Microsoft's documented public Ad Library API.

What they have in common is an "Only new ads" mode (onlyNewAds). Each actor stores the IDs of ads it has seen in a named key-value store on your Apify account. On later runs it outputs only ads it hasn't seen before. Every ad row has an isNew flag, and every competitor/search gets a free summary row with a newAdsSinceLastRun count.

Step 1: Run your first check in Apify Console

Create an Apify account (the free plan includes monthly platform credit you can use to try these).
Open the actor page, e.g. Google Ads Transparency Monitor, and click Try for free.
Switch the input editor to JSON and paste an input (examples below).
Click Start. When the run finishes, open the Output tab and export as JSON, CSV or Excel.

Input JSON for each platform

Google - competitors by domain, US only, new ads only:

{
  "domains": ["zappos.com", "nike.com"],
  "regions": ["US"],
  "onlyNewAds": true
}

Useful options: regions accepts any country or "anywhere". formats filters to text, image or video. lastDays (or dateFrom/dateTo) sets a date window. extractAdContent returns ad copy and YouTube video IDs where Google exposes them. enrichDetails adds per-country dates and impression ranges.

LinkedIn - B2B competitors by company name:

{
  "companies": ["HubSpot", "Salesforce"],
  "onlyNewAds": true,
  "maxAdsPerSearch": 50
}

Add "includeDetails": true to get the full ad copy, CTA, landing page, payer and, for EU ads, run dates, impressions and targeting. Add "exactCompanyMatch": true if a name search also matches partner pages (searching "HubSpot" also returns pages like "HubSpot Platinum Partner"). "skipMemberAds": true drops ads posted from individual members' profiles.

Bing / Microsoft - advertiser by name, EU/EEA:

{
  "advertiserNames": ["Booking.com B.V."],
  "onlyNewAds": true,
  "maxAdsPerTarget": 100
}

To research a theme instead of a brand, use searchTerms, e.g. { "searchTerms": ["car insurance"], "countries": ["DE"], "lastDays": 30, "onlyNewAds": false }.

What the output looks like

Here's a real (shortened) Google ad row from an October 2026 run:

{
  "type": "ad",
  "target": "zappos.com",
  "region": "US",
  "advertiserName": "Zappos IP, Inc.",
  "creativeId": "CR11795179083397070849",
  "format": "text",
  "firstShown": "2026-04-02T18:12:14+00:00",
  "lastShown": "2026-10-07T18:48:08+00:00",
  "daysRunning": 189,
  "transparencyUrl": "https://adstransparency.google.com/advertiser/AR04821233212191670273/creative/CR11795179083397070849",
  "isNew": true
}

And a LinkedIn row with details turned on. The landingPageUrl UTM parameters often reveal the campaign name:

{
  "type": "ad",
  "searchQuery": "SAP Fioneer",
  "format": "Video Ad",
  "advertiserName": "SAP Fioneer",
  "headline": "Bring structure to broker settlements",
  "cta": "Learn more",
  "landingPageUrl": "https://www.sapfioneer.com/blog/why-broker-settlements-belong-inside-receivables-control/?utm_campaign=FS-CD+%257C+Insurance+%257C+2026&utm_source=linkedin&utm_medium=paid",
  "startDate": "2026-10-06",
  "impressions": "5k-10k",
  "targetingParameters": [{ "parameter": "Company", "targeted": true, "excluded": true }, { "parameter": "Job", "targeted": true, "excluded": false }],
  "isNew": true
}

Each competitor also gets a summary row ("type": "summary") that isn't charged. Failed checks appear as "type": "error" rows with a hint, and those aren't charged either.

Step 2: Understand "only new ads" (monitor mode)

onlyNewAds is on by default in all three actors. Here's how it works:

First run: by default ("firstRunBehavior": "outputAll"), you get everything currently in the library, and all of it is recorded as "seen."
Every later run: you get only ads whose IDs weren't seen before.

If you don't want a big first export, start silently:

{
  "domains": ["rozetka.com.ua"],
  "regions": ["UA"],
  "firstRunBehavior": "baselineOnly",
  "stateStoreName": "my-ua-monitor"
}

baselineOnly records the existing ads and outputs nothing. From the next run on, you only get changes.

Two practical tips:

Use a separate stateStoreName for each monitor (e.g. one per client). The "seen" list is stored per competitor and filter combination inside that store, so two unrelated monitors sharing one name would interfere with each other.
Spending caps don't lose ads. If a run stops at your max-ads or max-cost limit, ads that weren't delivered are not marked as seen, so they show up on the next run.

Step 3: Schedule it daily

With your input filled in, click Save as a new task. One task per client or competitor set is a good pattern. You'll end up with tasks like acme-google, acme-linkedin and acme-bing.
Go to Schedules -> Create new, pick a time (e.g. every day at 08:00 in your time zone) and add the task(s).
Turn on Apify's run-failure notifications, so a broken run shows up as an alert instead of an empty inbox.

Because monitor mode returns only new ads, every scheduled run's dataset is your alert list. A dataset with only summary rows means nothing changed.

Step 4: Send new ads to Slack or email

Open the task and go to the Integrations tab:

Slack or Gmail integration: sends you a message when a run finishes.
Webhook on the "Run succeeded" event: passes the run to Zapier, Make, n8n or your own endpoint.

For custom formatting (say, one Slack message per new ad with its headline and link), the webhook route works best. The run payload includes the dataset ID, and your workflow fetches the rows from:

https://api.apify.com/v2/datasets/{defaultDatasetId}/items

Filter to type == "ad", then post advertiserName, headline or title, and transparencyUrl / detailUrl / destinationUrl to your channel.

Step 5: Call the actors from Python

Install the official client and pandas:

pip install "apify-client>=3" pandas
export APIFY_TOKEN=your_token_here   # Console -> Settings -> API & Integrations

This script runs all three monitors, tags each ad with the platform and the date it was detected, and appends the results to a CSV log:

import os
from decimal import Decimal

import pandas as pd
from apify_client import ApifyClient

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

MONITORS = {
    "google": ("ivora/google-ads-transparency-monitor", {
        "domains": ["zappos.com", "nike.com"],
        "regions": ["US"],
        "onlyNewAds": True,
        "stateStoreName": "acme-google",
    }),
    "linkedin": ("ivora/linkedin-ad-library-monitor", {
        "companies": ["HubSpot", "Salesforce"],
        "onlyNewAds": True,
        "maxAdsPerSearch": 50,
        "stateStoreName": "acme-linkedin",
    }),
    "bing": ("ivora/microsoft-ads-library-monitor", {
        "advertiserNames": ["Booking.com B.V."],
        "onlyNewAds": True,
        "maxAdsPerTarget": 100,
        "stateStoreName": "acme-bing",
    }),
}

rows = []
for platform, (actor_id, run_input) in MONITORS.items():
    # max_total_charge_usd caps what a single run can cost (pay-per-event actors)
    run = client.actor(actor_id).call(run_input=run_input,
                                      max_total_charge_usd=Decimal("0.50"))
    if run is None or run.status != "SUCCEEDED":
        print(f"{platform}: run did not succeed")
        continue
    for item in client.dataset(run.default_dataset_id).iterate_items():
        if item.get("type") == "error":
            print(f"{platform}: {item.get('error')} ({item.get('hint')})")
        if item.get("type") != "ad":
            continue  # skip free summary rows
        rows.append({
            "detected": run.started_at.date().isoformat(),
            "platform": platform,
            # Google and Bing use `target`, LinkedIn uses `searchQuery`
            "competitor": item.get("target") or item.get("searchQuery"),
            "advertiser": item.get("advertiserName"),
            "ad_id": item.get("creativeId") or item.get("adId"),
            "text": item.get("headline") or item.get("title") or item.get("adCopy"),
            "url": item.get("transparencyUrl") or item.get("detailUrl") or item.get("destinationUrl"),
        })

log = "new_ads_log.csv"
pd.DataFrame(rows).to_csv(log, mode="a", index=False, header=not os.path.exists(log))
print(f"{len(rows)} new ads logged")

Note: apify-client v3 returns typed objects (run.default_dataset_id). On the older v1.x client, use run["defaultDatasetId"] and run["status"] instead.

Or call it with plain HTTP

Any language works with the run-sync endpoint. It starts the actor, waits for it to finish, and returns the dataset items in one request:

curl -s -X POST \
  "https://api.apify.com/v2/acts/ivora~microsoft-ads-library-monitor/run-sync-get-dataset-items" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"advertiserNames": ["Booking.com B.V."], "onlyNewAds": true, "maxAdsPerTarget": 50}'

Note the ~ in place of / in the actor ID in the URL. Synchronous requests are time-limited, so for big inputs (or slow country filters on Microsoft's side) start the run asynchronously and use a webhook or poll for the result.

Step 6: A small analysis - new ads per competitor per week

Once the script has run daily for a few weeks, new_ads_log.csv shows how actively each competitor launches creative:

import pandas as pd

df = pd.read_csv("new_ads_log.csv", parse_dates=["detected"])
df = df.drop_duplicates(subset=["platform", "ad_id"])

weekly = (
    df.groupby([pd.Grouper(key="detected", freq="W-MON"), "platform", "competitor"])
      .size()
      .unstack(["platform", "competitor"], fill_value=0)
)
print(weekly.tail(8))

# Who launched the most new creative in the last 4 weeks?
recent = df[df["detected"] >= df["detected"].max() - pd.Timedelta(weeks=4)]
print(recent.groupby(["competitor", "platform"]).size().sort_values(ascending=False).head(10))

A few things to look for:

Spikes. A jump in new ads from one competitor usually means a launch, a promotion, or a new agency testing creative.
Platform shifts. A competitor that goes quiet on Google but busy on LinkedIn may be moving budget toward B2B audiences.
Long-running ads. Ads with a high daysRunning (Google, Bing) are probably the ones that work for them. Read those closely.

Keep in mind that this counts ads detected per week. The first week of a monitor includes everything that was already live, unless you started with baselineOnly.

What it costs

All three actors are pay-per-event, with no separate proxy or compute charges. Prices and examples below come from the actors' README pages:

Actor	Price	README example
Google Ads Transparency	$0.005 per competitor checked (one domain/advertiser in one region) + $1 per 1,000 ads + $0.001 per run	20 competitors daily, ~5 new ads each: about $0.20/day
LinkedIn Ad Library	$0.005 per search + $1.50 per 1,000 ads, +$1.50 per 1,000 ads with details + $0.005 per run	10 competitors daily, ~5 new ads each, with details: about $0.21/day
Microsoft (Bing) Ad Library	$1.50 per 1,000 ads (details included) + $0.002 per run	10 competitors daily, ~5 new ads each: about $0.08/day

With "Only new ads" on, you only pay for new ads, so a quiet day costs close to nothing. Summary rows and failed checks aren't charged. To keep spending predictable, set the max-ads limit (maxAdsPerTarget for Google and Bing, maxAdsPerSearch for LinkedIn) and a maximum cost per run.

Limitations (read before you rely on it)

All platforms

No spend or clicks. None of the three libraries publish them for commercial ads. Google shows impression ranges per country (with enrichDetails), while LinkedIn and Microsoft show impression ranges for EU ads.
"New" means new to the monitor, not necessarily launched today. It's the first time the actor saw that ad ID in the library.

Google

Many Search ads are archived as rendered images, so you get an imageUrl rather than text. Ad copy is extracted only when Google provides it as text.
The monitor keeps up to 20,000 seen IDs per monitor.
Advertiser names can be ambiguous. Advertiser IDs (AR...) are the most precise input.

LinkedIn

Run dates, impressions and targeting exist only for ads shown in the EU (DSA). Other ads have only creative, advertiser and payer. Impressions by country can take up to 48 hours to appear.
About one year of history.
Company search is a name search, so use exactCompanyMatch when you need one exact advertiser.
It reads public web pages, not an official API. If LinkedIn changes its layout, runs fail with explicit error rows (not silent empty data) until the actor is updated. LinkedIn also rate-limits, so large runs take longer.
For ads posted from an individual member's profile, the actor never outputs the person's name, photo or profile URL.

Microsoft (Bing)

EU/EEA only. Ads shown only in the US or UK aren't in the library.
About 1,000 results per query. For very large advertisers, narrow the query with countries or a date range.
1-3 day delay before new impressions appear, and results aren't returned in chronological order. Daily runs with a window like "lastDays": 7 give the best coverage.
Country filters can be slow on Microsoft's side (sometimes 20-90 s per page).

FAQ

Do I need a LinkedIn or Microsoft account?
No. The LinkedIn actor uses public, logged-out pages, and the Microsoft actor uses Microsoft's public API without sign-up. You only need an Apify account.

How do I find a Google advertiser ID?
Open the advertiser on adstransparency.google.com. The AR... part of the URL is the ID. You can also just enter the domain or advertiser name.

Can I monitor Bing ads in the US?
Not with this approach. Microsoft's Ad Library only covers ads with impressions in the EU/EEA.

Can I monitor keywords instead of brands?
Yes, on LinkedIn (keywords) and Bing (searchTerms), e.g. to see who advertises on "crm" or "car insurance". Google's input is by domain, advertiser ID or advertiser name.

How do I reset a monitor and get everything again?
Use a new stateStoreName, or set onlyNewAds to false for a one-off full export.

Is this legal?
These libraries are published by the platforms for transparency, and the actors don't log in. You're still responsible for complying with each platform's terms and applicable law (e.g. GDPR) in how you use the data.

Wrapping up

Competitor ad research usually fails because nobody keeps checking, not because the data is hard to get. With a scheduled run per platform, "only new ads" mode and a Slack or email integration, the check runs every morning. The Python log then gives you a record of competitor activity over time.

Links to the actors:

Ivan Petrus builds competitor-intelligence actors on Apify Store.

Deploy a Node/TypeScript API to Railway in 15 minutes (with a worker-friendly setup)

ivanpetrus — Fri, 11 Sep 2026 19:54:48 +0000

This walkthrough deploys a simple Express API to Railway, sets env vars, and notes how to add a second service later for a queue worker.

Disclosure: Some links are affiliate links. I may earn a commission at no extra cost to you.

What you'll end up with

A deployed Node/TS HTTP service
HTTPS URL on Railway
Env-based config (PORT, DATABASE_URL, etc.)
A clear path to add a worker process (BullMQ etc.) as a second service

Companion repo

Clone or fork the starter and deploy it as-is:

github.com/ivanpetrus/railway-node-ts-api

Prerequisites

Node 20+ locally
A GitHub repo (or Railway CLI)
~15 minutes

Step 1 — Minimal API

// src/index.ts
import express from "express";

const app = express();
const port = process.env.PORT || 3000;

app.get("/health", (_req, res) => {
  res.json({ ok: true });
});

app.listen(port, () => {
  console.log(`listening on ${port}`);
});

package.json scripts:

{
  "scripts": {
    "build": "tsc",
    "start": "node dist/index.js",
    "dev": "tsx src/index.ts"
  }
}

Tip: Railway sets PORT for you — don't hardcode 3000 in production.

Step 2 — Create the Railway project

Sign up / log in via this link (includes starter credits when eligible): Railway
New Project → Deploy from GitHub (connect the repo) Or deploy the companion repo above.
Pick the repo + root directory if monorepo

Step 3 — Build & start settings

Step 4 — Environment variables

Add at least:

NODE_ENV=production
any secrets your app needs (DATABASE_URL, JWT_SECRET, …)

Never commit .env. Rotate anything you pasted into chat.

Step 5 — Public URL & health check

Generate a Railway domain (or custom domain).
Hit /health — you should see { "ok": true }.

Optional: add a worker later

For BullMQ / background jobs:

Create a second Railway service from the same repo
Same build, different start command (e.g. node dist/worker.js)
Share env vars; put Redis as a plugin/add-on or external Redis
Cap concurrency so one spike doesn't OOM the service

That's where a lot of solo apps get burned — happy to write a follow-up.

Cost mindset (solo)

Start tiny; watch the usage dashboard after 24h
Separate web vs worker so a stuck job doesn't take down HTTP
Set memory limits / restart policy before you "optimize code"

When Railway is a fit

Solo/small team, Node/TS API + optional worker
Want GitHub → deploy without babysitting VMs
Not a fit if you need multi-region edge at Google scale on day one

Wrap-up

Ship the healthcheck first. Add the worker second. Keep env vars boring.

Deploy link (affiliate): Railway

If you want the same app on a classic VPS/PaaS instead, next post compares Railway vs DigitalOcean for a solo Node API.

Questions / stuck on build commands? Drop an error log snippet in the comments.
In the service settings:

Build command: npm run build (or pnpm/yarn)
Start command: npm run start
Watch the first deploy logs for listening on …

If the build fails on TypeScript, ensure typescript is in dependencies/devDependencies and tsconfig emits to dist/.

DEV Community: ivanpetrus

Checking hotel prices on every booking site at once (and catching rate parity problems)

Google already did the hard part

What you put in

What you get back

A tiny parity report in Python

Price

Limits

I stopped checking competitor Shopify stores by hand. Here's what I use instead

The trick: products.json

What "changed" actually means

The monitor

Pulling it into Python

What it costs

Where it breaks (honestly)

Pulling Google Trends data in Python without constantly hitting 429s

Why Google Trends rate-limits you so fast

The part nobody tells you: USER_TYPE_SCRAPER

Setup

Interest over time

Interest by region

Trending searches

A few gotchas I hit

Tracking which companies are hiring (Greenhouse, Lever, Ashby, Workday) as a sales signal with Python

Why job boards are easier than they look

A daily "who started hiring for what" alert

The Workday problem

Enriching a lead list with hiring data

A little pandas for trends

Where it doesn't work

How to Monitor Your Competitors' Ads Automatically (Google, LinkedIn and Bing) with Apify

Why ad libraries exist, and what each one shows

The manual way, and why it doesn't scale

The tools

Step 1: Run your first check in Apify Console

Input JSON for each platform

What the output looks like

Step 2: Understand "only new ads" (monitor mode)

Step 3: Schedule it daily

Step 4: Send new ads to Slack or email

Step 5: Call the actors from Python

Or call it with plain HTTP

Step 6: A small analysis - new ads per competitor per week

What it costs

Limitations (read before you rely on it)

FAQ

Wrapping up

Deploy a Node/TypeScript API to Railway in 15 minutes (with a worker-friendly setup)

What you'll end up with

Companion repo

Prerequisites

Step 1 — Minimal API

Step 2 — Create the Railway project

Step 3 — Build & start settings

Step 4 — Environment variables

Step 5 — Public URL & health check

Optional: add a worker later

Cost mindset (solo)

When Railway is a fit

Wrap-up