DEV Community: Freshactors

How to scrape Redfin (US real estate) data with Node.js (no API key needed)

Freshactors — Mon, 01 Jun 2026 19:50:44 +0000

Redfin has some of the cleanest US real-estate data on the web — list prices, sold prices, beds/baths, square footage, lat/long, MLS IDs — but there's no public Redfin API you can just call. In this tutorial we'll pull structured Redfin listings as JSON using Node.js, without an API key, a login, or writing a single CSS selector.

We'll use a maintained Apify actor that handles the annoying parts (region resolution, Redfin's anti-bot "soft block" behavior, retries) so we can focus on the data.

Why not just `fetch()` Redfin yourself?

You can hit Redfin's internal GIS endpoint directly — for about a day. Two things bite you:

The soft block. Redfin's data API returns a 200 with an envelope that says errorMessage: "Success" even when it's blocking you as a bot. Your scraper "succeeds" and writes zero rows. You don't notice until your dashboard is empty.
Region IDs. Redfin doesn't take a city name — it takes an internal region_id and region_type. You have to resolve those first.

We'll offload both to the FreshActors Redfin Scraper, which parses the region straight from a Redfin URL and distinguishes a real zero-result from a block (retrying with backoff + IP rotation when it sees one).

Prerequisites

Node.js 18+
A free Apify account and your API token (Settings → Integrations)

Install the client:

npm install apify-client

Step 1 — Call the actor

The only required input is a Redfin URL. Paste a city/ZIP/county page from redfin.com and the actor reads the region from it.

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const input = {
  redfinUrls: ['https://www.redfin.com/city/30818/TX/Austin'],
  listingType: 'forSale',   // or 'sold'
  sort: 'price-desc',
  maxListings: 500,
};

// Run the actor and wait for it to finish.
const run = await client.actor('freshactors/redfin-scraper').call(input);

// Pull the results from the run's dataset.
const { items } = await client.dataset(run.defaultDatasetId).listItems();

console.log(`Got ${items.length} listings`);
console.log(items[0]);

That's the whole integration. No selectors, no proxy config, no Redfin region lookup.

Step 2 — What the output looks like

Each item is one property. A trimmed real record:

{
  "_type": "listing",
  "_schemaVersion": "1.0",
  "listingId": 216197035,
  "mlsId": "2116358131372161577",
  "mlsStatus": "Active",
  "address": "4602 Indian Wells Dr",
  "city": "Austin",
  "state": "TX",
  "zip": "78747",
  "price": 560000,
  "beds": 3,
  "baths": 2,
  "sqft": 2097,
  "pricePerSqFt": 267,
  "yearBuilt": 2019,
  "propertyType": "Single Family Residential",
  "latitude": 30.1327479,
  "longitude": -97.79,
  "daysOnMarket": 12,
  "url": "https://www.redfin.com/TX/Austin/4602-Indian-Wells-Dr-78747/home/31845362",
  "_scrapedAt": "2026-06-01T08:08:20.543Z"
}

You also get propertyId, unit, hoa, lotSize, soldDate, and listingType. The schema is versioned (_schemaVersion), so fields don't silently vanish between runs.

Step 3 — Do something useful with it

Let's find the cheapest-per-square-foot homes — a quick proxy for value hunting:

const deals = items
  .filter((h) => h.price && h.sqft)
  .map((h) => ({
    address: `${h.address}, ${h.city} ${h.state}`,
    price: h.price,
    ppsf: h.pricePerSqFt ?? Math.round(h.price / h.sqft),
    dom: h.daysOnMarket,
    url: h.url,
  }))
  .sort((a, b) => a.ppsf - b.ppsf)
  .slice(0, 10);

console.table(deals);

Combining a low pricePerSqFt with a high daysOnMarket is a classic motivated-seller filter.

Step 4 — Get sold comps (the "Redfin API" alternative people actually want)

For an AVM, a CMA tool, or a price-trend model, you want sold data. Flip one field:

const soldInput = {
  redfinUrls: ['https://www.redfin.com/zipcode/78701'],
  listingType: 'sold',           // sold homes
  sort: 'days-on-redfin-asc',    // most recent first
  maxListings: 300,
};

const soldRun = await client.actor('freshactors/redfin-scraper').call(soldInput);
const { items: sold } = await client.dataset(soldRun.defaultDatasetId).listItems();

const medianSoldPrice = (() => {
  const prices = sold.map((h) => h.price).filter(Boolean).sort((a, b) => a - b);
  const mid = Math.floor(prices.length / 2);
  return prices.length % 2 ? prices[mid] : (prices[mid - 1] + prices[mid]) / 2;
})();

console.log(`Median sold price in 78701: $${medianSoldPrice.toLocaleString()}`);

Sold records carry a soldDate, so you can bucket by month and chart how a ZIP's median price moves over time.

Step 5 — Scale it up (or down)

Pricing is pay-per-result: $0.002 per listing. So 100 listings cost $0.20 and a 1,000-row run is $2.00. Use maxListings to keep any run within budget, and pass several URLs in redfinUrls to cover multiple cities in one call (the cap applies across all of them).

For ongoing data, schedule the actor (Apify → Schedules) to run daily and append to a dataset — that's your always-fresh Redfin feed.

A note on reliability

The reason I reach for this actor over a hand-rolled script is the daily canary: it runs the scraper against live Redfin every day and flags field drift or block-pattern changes, so it gets patched before your pipeline returns garbage. With a DIY scraper, you're the canary — and you usually find out when a report is already empty.

Wrap-up

With ~15 lines of Node you can pull structured Redfin listings — for-sale or sold — without an API key, region lookups, or anti-bot wrestling. Point it at a URL, get clean JSON, and build your analysis on top.

Actor reference and full input docs: apify.com/freshactors/redfin-scraper.

Happy scraping. If Redfin changes something, open an issue on the actor — that's what keeps it fresh.

How to scrape Google Play data with Node.js (no API key needed)

Freshactors — Mon, 01 Jun 2026 19:31:35 +0000

Google Play has no official public API for app listings or reviews. So if you want app details, ratings, the ratings histogram, or customer reviews as clean JSON — for ASO tracking, review monitoring, an ML dataset, or market research — you either parse Google's deeply-nested, undocumented page payloads yourself, or you call something that already does.

This tutorial does the second thing. We'll pull Google Play data with Node.js in a few lines, without an API key, without proxies, and without writing a single HTML parser, by calling a hosted scraper actor on Apify. At the end I'll show the same thing for one-off runs you don't even need code for.

Why not just `fetch()` the Play Store?

You can fetch('https://play.google.com/store/apps/details?id=com.spotify.music') — but the useful data isn't in clean HTML. Google embeds it in AF_initDataCallback blocks as positional arrays with no field names, e.g. the exact rating lives at roughly data[1][2][51][0][1] and the ratings histogram at data[1][2][51][1]. Reviews come from a separate batchexecute RPC that returns a )]}'-prefixed blob and throttles aggressively. Those index paths also shift when Google reshapes the page, which is why hand-rolled scrapers quietly break.

Offloading the parsing + rate-limit handling to a maintained actor means you get stable, named fields like rating, ratingHistogram, installs, and developerResponse instead.

Setup

You'll need a free Apify account and your API token (Settings → Integrations). Then install the official client:

npm install apify-client

Set your token as an env var so it isn't hard-coded:

export APIFY_TOKEN="your_token_here"

1. Scrape app details

Here we fetch full details for two apps. The actor's input takes a mode, an array of appIds (package names — the id= part of a Play Store URL), and an optional country.

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const run = await client.actor('freshactors/google-play-scraper').call({
  mode: 'details',
  appIds: ['com.spotify.music', 'com.whatsapp'],
  country: 'us',
  lang: 'en',
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();

for (const app of items) {
  console.log(`${app.title} — ${app.rating}★ (${app.ratingCount.toLocaleString()} ratings), ${app.installs}`);
}

Each item is a clean object. An abridged record looks like this:

{
  "_type": "app_details",
  "appId": "com.spotify.music",
  "title": "Spotify: Music and Podcasts",
  "developer": "Spotify AB",
  "rating": 4.33,
  "ratingCount": 35677435,
  "ratingHistogram": { "1": 3695081, "2": 1079953, "3": 1332269, "4": 3058122, "5": 26511993 },
  "installs": "1,000,000,000+",
  "free": true,
  "currency": "USD",
  "genre": "Music & Audio",
  "contentRating": "Teen",
  "containsAds": true,
  "updated": "2026-05-26T14:23:49.000Z",
  "url": "https://play.google.com/store/apps/details?id=com.spotify.music"
}

Note the ratingHistogram — the per-star breakdown that's painful to extract by hand but is exactly what you need to compute, say, the share of 1★ reviews over time.

2. Scrape reviews (with pagination handled for you)

Switch mode to reviews and set maxReviewsPerApp. The actor paginates the reviews RPC, de-duplicates, and retries on throttling under the hood — you just say how many you want and how to sort them.

const reviewsRun = await client.actor('freshactors/google-play-scraper').call({
  mode: 'reviews',
  appIds: ['com.spotify.music'],
  maxReviewsPerApp: 500,
  reviewsSort: 'newest', // or 'mostHelpful' | 'rating'
  country: 'us',
});

const { items: reviews } = await client.dataset(reviewsRun.defaultDatasetId).listItems();

// Quick sentiment-ish slice: how many recent reviews are 1–2 stars?
const negative = reviews.filter((r) => r.rating <= 2);
console.log(`${negative.length}/${reviews.length} recent reviews are 1–2★`);

console.log(reviews[0]);

A review record:

{
  "_type": "review",
  "appId": "com.spotify.music",
  "reviewId": "7e1815f2-36d1-4187-a936-12f969747892",
  "userName": "Catherine Hempel",
  "rating": 5,
  "body": "The paid version is excellent but very expensive...",
  "thumbsUp": 14,
  "date": "2026-04-21T11:35:57.000Z",
  "appVersion": "9.1.40.1486",
  "developerResponse": null
}

The appVersion and developerResponse fields are handy: you can track whether complaints cluster around a specific release, and whether the developer actually replied.

3. Search the Play Store by keyword

If you don't know the package names yet — say you're researching a niche — use search mode. It searches Google Play for each term and returns full details for every matching app, tagged with the _searchTerm that surfaced it.

const searchRun = await client.actor('freshactors/google-play-scraper').call({
  mode: 'search',
  searchTerms: ['habit tracker', 'budget app'],
  maxSearchResults: 20,
  country: 'us',
});

const { items: found } = await client.dataset(searchRun.defaultDatasetId).listItems();

// Rank a niche by rating
found
  .sort((a, b) => (b.rating ?? 0) - (a.rating ?? 0))
  .slice(0, 5)
  .forEach((a) => console.log(`[${a._searchTerm}] ${a.title} — ${a.rating}★`));

That's an entire competitive map of a category — names, developers, ratings, install buckets, whether they're ad-supported — in one call.

Streaming large datasets

For big review pulls, don't load everything into memory. Iterate the dataset:

const dataset = client.dataset(reviewsRun.defaultDatasetId);
let offset = 0;
const limit = 1000;

while (true) {
  const { items } = await dataset.listItems({ offset, limit });
  if (items.length === 0) break;
  // process this page (write to DB, file, etc.)
  offset += items.length;
}

What does this cost?

Pricing is pay-per-event, so you pay for data returned, not server time:

App details: $0.002 per app → 100 apps = $0.20.
Reviews: $0.0001 per review → a 1,000-review pull = $0.10.

No subscription, no proxy bill. A daily competitor-tracking job over a few dozen apps costs cents.

No code? Run it from the UI

You don't strictly need the client. On the actor's page you can paste the same JSON input, click Start, and export the dataset as JSON, CSV, or Excel — or hit the dataset via its REST URL. The Node snippets above are just the programmable version of that.

Wrapping up

With one hosted actor you can pull Google Play app details, the ratings histogram, paginated reviews, and keyword search results as named JSON fields — no API key, no proxy setup, no positional-array archaeology. The actor is monitored by a daily canary and patched when Google changes its layout, so the pipeline you build today keeps returning data next month.

If you build something with it, or hit a package that behaves oddly, the Issues tab is the fastest way to reach a human.

How to scrape Greenhouse & Lever ATS jobs data with Python (no API key needed)

Freshactors — Mon, 01 Jun 2026 19:30:47 +0000

If you need live job-posting data — for sales intelligence, a niche job board, or labor-market research — two ATS platforms cover a huge slice of the market: Greenhouse and Lever. The good news: both expose public JSON boards, so you don't need an API key, an account, or a headless browser.

The annoying part: Greenhouse and Lever return completely different JSON shapes. Scrape both yourself and you end up maintaining two parsers that break independently. In this tutorial we'll skip that tax by calling a ready-made actor that normalizes both ATS into one schema — and you'll run it from Python in a few lines.

The problem with rolling your own

Let's be concrete. A raw Greenhouse board lives at:

https://boards-api.greenhouse.io/v1/boards/{token}/jobs

A Lever board lives at:

https://api.lever.co/v0/postings/{token}?mode=json

Different hosts, different field names, different location/department conventions, and different ways of expressing "remote". You can write adapters for both — but then you own them forever, including the day one of them quietly changes a field name and your pipeline silently goes empty.

A cleaner path: hand a list of company tokens to an actor that already maps both into a single record, and just consume the output. Here's how with the Greenhouse & Lever Jobs Scraper.

Step 1 — Install the Apify client

pip install apify-client

Grab your Apify API token from Settings → Integrations in the Apify Console. We'll read it from an environment variable so it never lands in source control:

export APIFY_TOKEN="apify_api_xxx"

Step 2 — Run the actor with a list of companies

The actor takes a companies array of bare tokens (gitlab) or full board URLs (https://jobs.lever.co/spotify). With ats: "auto", bare tokens are tried against Greenhouse first, then Lever; URLs are detected automatically.

import os
from apify_client import ApifyClient

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

run_input = {
    "companies": [
        "gitlab",                              # bare token (auto-detected)
        "https://jobs.lever.co/spotify",       # Lever URL
        "https://boards.greenhouse.io/airbnb", # Greenhouse URL
    ],
    "ats": "auto",
    "includeDescription": True,
    "maxJobsPerCompany": 500,
}

# Blocks until the run finishes, then returns run metadata.
run = client.actor("freshactors/greenhouse-lever-jobs-scraper").call(run_input=run_input)

print("Run status:", run["status"])
print("Dataset id:", run["defaultDatasetId"])

.call() is synchronous — it waits for the run to complete and hands you the run object, including the defaultDatasetId where results land.

Step 3 — Read the normalized output

Every record — Greenhouse or Lever — comes back in the same shape. ATS-specific gaps are null, never missing keys, so your downstream code can rely on the schema:

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(
        f'[{item["_source"]:<10}] '
        f'{item["company"]:<10} '
        f'{item["title"]}  '
        f'({item.get("workplaceType") or "n/a"}, {item.get("location") or "n/a"})'
    )

A single record looks like this:

{
  "_type": "job",
  "_schemaVersion": "1.0",
  "_source": "lever",
  "company": "spotify",
  "jobId": "1ff4a4e3-...",
  "title": "Account Executive - Backstage",
  "department": "Operations and Business Support",
  "team": "Platform",
  "location": "Toronto",
  "allLocations": ["Toronto"],
  "workplaceType": "hybrid",
  "commitment": "Permanent",
  "country": "CA",
  "url": "https://jobs.lever.co/spotify/1ff4a4e3-...",
  "applyUrl": "https://jobs.lever.co/spotify/1ff4a4e3-.../apply",
  "postedAt": "2026-03-12T17:10:21.350Z",
  "updatedAt": null,
  "descriptionText": "About the role...",
  "_scrapedAt": "2026-06-01T09:14:02.118Z"
}

Because both ATS share this schema, you never branch on _source to read a field — you only read it if you want to know where the record came from.

Step 4 — A practical filter (remote roles, posted recently)

Say you only care about remote engineering roles. With one schema, the filter is trivial:

from datetime import datetime, timedelta, timezone

cutoff = datetime.now(timezone.utc) - timedelta(days=14)
remote_recent = []

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    if item.get("workplaceType") != "remote":
        continue
    posted = item.get("postedAt")
    if posted and datetime.fromisoformat(posted.replace("Z", "+00:00")) >= cutoff:
        remote_recent.append(item)

print(f"{len(remote_recent)} remote roles posted in the last 14 days")

No Greenhouse-vs-Lever special-casing — workplaceType and postedAt mean the same thing in every record.

Step 5 — Lighter, faster runs

Two knobs control cost and speed:

includeDescription: false skips fetching full descriptionText — much faster when you only need titles, departments, and locations for, say, a hiring-signal dashboard.
maxJobsPerCompany caps postings per company (1–5000) so a 3,000-role employer doesn't dominate your run.

run_input = {
    "companies": ["gitlab", "spotify", "netflix", "airbnb"],
    "ats": "auto",
    "includeDescription": False,   # metadata only
    "maxJobsPerCompany": 200,
}

Prefer Node.js?

Same actor, same input, the JavaScript client:

npm install apify-client

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const run = await client.actor('freshactors/greenhouse-lever-jobs-scraper').call({
    companies: ['gitlab', 'https://jobs.lever.co/spotify'],
    ats: 'auto',
    includeDescription: true,
    maxJobsPerCompany: 500,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
for (const job of items) {
    console.log(`[${job._source}] ${job.company} — ${job.title}`);
}

What about cost?

It's pay-per-event: $0.02 per company board fetched and $0.0005 per job posting returned. So 5 companies returning 100 postings total is 5 × $0.02 + 100 × $0.0005 = $0.15. No subscription — you pay for what you pull.

Why use the actor instead of hitting the boards directly?

You can curl those public endpoints yourself. The reason to use the actor is maintenance: it normalizes both ATS into one schema, auto-detects Greenhouse vs Lever, isolates per-company failures, and is monitored by a daily canary so a silent ATS field change doesn't quietly empty your pipeline. That operational reliability is the whole point.

If you want to skip the two-parser tax, the actor is here: Greenhouse & Lever Jobs Scraper on Apify. Run it on a schedule, point it at your target companies, and consume one clean JSON feed.

Happy scraping.

How to scrape Shopify App Store data with Python (no API key needed)

Freshactors — Mon, 01 Jun 2026 19:28:30 +0000

If you build for the Shopify ecosystem — or just research it — you eventually want the App Store as data: app ratings, review counts, pricing, and the actual review text. The problem is there's no official public Shopify App Store API, and the listing pages are a moving target. Roll your own scraper and you'll spend more time chasing layout changes than analyzing data.

In this tutorial we'll pull Shopify App Store data three ways — app details, reviews, and catalog discovery — using a hosted actor and a few lines of Python. No API key for Shopify, no login, no headless-browser babysitting.

What we'll build

Fetch full details for a list of apps (rating, review count, pricing, developer).
Pull reviews for an app, including the reviewing store's country and the developer's reply.
Discover apps across the whole catalog by keyword — handy for competitor research.

We'll call the Shopify App Store Scraper actor on Apify via the official apify-client. The actor handles pagination, retries, and the brittle parts; you just read JSON.

Prerequisites

Python 3.8+
A free Apify account (for the API token)
The Apify client:

pip install apify-client

Grab your API token from Settings → Integrations in the Apify console. Keep it out of source control — read it from an environment variable.

export APIFY_TOKEN="apify_api_xxx"

1. Get app details

The actor's input is a small JSON object. Set mode to details and pass one or more appHandles — the handle is the slug at the end of an app URL (https://apps.shopify.com/klaviyo-email-marketing → klaviyo-email-marketing).

import os
from apify_client import ApifyClient

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

run_input = {
    "mode": "details",
    "appHandles": [
        "klaviyo-email-marketing",
        "judgeme-product-reviews",
    ],
}

# Run the actor and wait for it to finish
run = client.actor("freshactors/shopify-app-store-scraper").call(run_input=run_input)

# Read the results from the run's dataset
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"{item['title']:40}  ⭐ {item['rating']}  ({item['reviewCount']} reviews)  — {item['pricingSummary']}")

Each record looks like this:

{
  "_type": "app_details",
  "_schemaVersion": "1.0",
  "handle": "klaviyo-email-marketing",
  "url": "https://apps.shopify.com/klaviyo-email-marketing",
  "title": "Klaviyo: Email Marketing & SMS",
  "developer": "Klaviyo",
  "category": "DeveloperApplication",
  "rating": 4.6,
  "reviewCount": 2805,
  "pricingSummary": "Free to install",
  "builtForShopify": false,
  "icon": "https://cdn.shopify.com/app-store/listing_images/.../icon.png",
  "_scrapedAt": "2026-06-01T08:00:00.000Z"
}

The details come from the page's application/ld+json structured-data block, which is far more stable than scraping CSS classes — so this keeps working even when Shopify reshuffles the markup.

2. Pull reviews (with country and developer replies)

Switch mode to reviews. You can cap volume with maxReviewsPerApp and order results with reviewsSort (newest, highest_rating, or lowest_rating).

run_input = {
    "mode": "reviews",
    "appHandles": ["klaviyo-email-marketing"],
    "maxReviewsPerApp": 500,
    "reviewsSort": "lowest_rating",  # surface complaints first
}

run = client.actor("freshactors/shopify-app-store-scraper").call(run_input=run_input)

reviews = list(client.dataset(run["defaultDatasetId"]).iterate_items())
print(f"Fetched {len(reviews)} reviews")

# Quick complaint mining: show 1-star reviews and where they came from
for r in reviews:
    if r["rating"] <= 2:
        print(f"[{r['rating']}★ {r['country']}] {r['storeName']}: {r['body'][:120]}")

A review record carries the full text plus useful context:

{
  "_type": "review",
  "_schemaVersion": "1.0",
  "handle": "klaviyo-email-marketing",
  "reviewId": "2186287",
  "rating": 5,
  "storeName": "Bellaforma Jewelry",
  "country": "United States",
  "usedAppFor": "Over 1 year using the app",
  "date": "May 1, 2026",
  "body": "We've seen significant revenue growth through dialed-in flows...",
  "developerReply": null,
  "_scrapedAt": "2026-06-01T08:00:00.000Z"
}

Because the actor treats an empty-but-200 review page as a soft failure and retries with backoff, you won't get a misleading "0 reviews" when a request just hiccuped.

3. Discover apps across the catalog

Doing competitor research? discover mode walks Shopify's official catalog sitemap and returns full details for apps matching a keyword. Use maxApps to cap how many to enrich.

import pandas as pd

run_input = {
    "mode": "discover",
    "query": "email marketing",
    "maxApps": 50,
}

run = client.actor("freshactors/shopify-app-store-scraper").call(run_input=run_input)
apps = list(client.dataset(run["defaultDatasetId"]).iterate_items())

# Build a competitive landscape table, sorted by rating
df = pd.DataFrame(apps)[["title", "developer", "rating", "reviewCount", "pricingSummary"]]
df = df.sort_values("reviewCount", ascending=False)
print(df.head(10).to_string(index=False))

In a few seconds you have a ranked table of email-marketing apps — rating, review count, developer, and pricing — ready for a spreadsheet or a notebook. Leave query empty to enumerate the catalog from the top.

Tip: don't block on the run

.call() waits for the run to finish, which is fine for small jobs. For big pulls, start the run and stream results as they land:

# Fire and forget; poll later
started = client.actor("freshactors/shopify-app-store-scraper").start(run_input=run_input)
print("Run id:", started["id"])

You can also export the dataset directly to CSV/Excel/JSON from the Apify console, or schedule recurring runs (e.g. a daily review pull) with Apify Schedules.

What about cost?

The actor is pay-per-result, so a quick estimate: app details are $0.002 each, discovery results $0.001 each, and reviews $0.0001 each. Pulling details for 100 apps is about $0.20; 20,000 reviews is about $2.00. (Apify platform usage is billed separately.)

Wrapping up

With one hosted actor and the apify-client, you can turn the Shopify App Store into structured JSON — details, reviews, or a whole-catalog competitor map — without an API key or a brittle homegrown scraper. The actor is monitored by a daily canary, so when Shopify changes its pages it gets patched fast instead of silently dying on you.

If you want to try it, the actor lives here: Shopify App Store Scraper on Apify. Have a Shopify-data question or hit an edge case? Drop it in the comments — happy to help.

DEV Community: Freshactors

How to scrape Redfin (US real estate) data with Node.js (no API key needed)

Why not just fetch() Redfin yourself?

Prerequisites

Step 1 — Call the actor

Step 2 — What the output looks like

Step 3 — Do something useful with it

Step 4 — Get sold comps (the "Redfin API" alternative people actually want)

Step 5 — Scale it up (or down)

A note on reliability

Wrap-up

How to scrape Google Play data with Node.js (no API key needed)

Why not just fetch() the Play Store?

Setup

1. Scrape app details

2. Scrape reviews (with pagination handled for you)

3. Search the Play Store by keyword

Streaming large datasets

What does this cost?

No code? Run it from the UI

Wrapping up

How to scrape Greenhouse & Lever ATS jobs data with Python (no API key needed)

The problem with rolling your own

Step 1 — Install the Apify client

Step 2 — Run the actor with a list of companies

Step 3 — Read the normalized output

Step 4 — A practical filter (remote roles, posted recently)

Step 5 — Lighter, faster runs

Prefer Node.js?

What about cost?

Why use the actor instead of hitting the boards directly?

How to scrape Shopify App Store data with Python (no API key needed)

What we'll build

Prerequisites

1. Get app details

2. Pull reviews (with country and developer replies)

3. Discover apps across the catalog

Tip: don't block on the run

What about cost?

Wrapping up

Why not just `fetch()` Redfin yourself?

Why not just `fetch()` the Play Store?