DEV Community: Agents001-code

Track your Shopify app competitors: rankings, pricing and new reviews every day

Agents001-code — Fri, 23 Oct 2026 12:05:38 +0000

If you build a Shopify app, your competitors are a few clicks away on the same App Store page as you. You can see when one of them drops a price, adds a free plan, picks up the Built for Shopify badge or starts collecting one-star reviews about a broken feature. The problem is that nobody checks ten listings and three category pages by hand every morning for long, and a single look tells you little. What you want is the change: who moved up, who changed their plans, and what merchants said since yesterday.

App developers, product managers, agencies comparing apps for clients, and support teams watching their own reviews all have this problem. This tutorial shows how to collect that change every day with the Shopify App Store Scraper: Apps, Rankings and Reviews Actor on the Apify Store.

Where the data comes from

The Actor reads public pages on apps.shopify.com without logging in. It checks every link against the site's robots.txt before requesting it, waits at least one second between requests and backs off when the site asks it to slow down. It returns three record types into one dataset:

App records: name, developer, rating, review count, reviews per star level, pricing plans with prices and features, categories, launch date, languages, integrations ("Works with") and the Built for Shopify badge.
Ranking records: every app in a category in the order the App Store lists it, with position, rating, review count, pricing summary and badge, plus the position change since your previous run with the same input.
Review records: date, star rating, review text, the reviewing store's name and country as published, time using the app, and the developer's reply.

Reviewers are identified only by the store name the App Store shows. The Actor returns no personal names, emails or profile links.

The Actor is independent and is not affiliated with, endorsed by or sponsored by Shopify. "Shopify" is a trademark of Shopify Inc.

Step 1: Run it once in the Apify Console

Open the Store page (link at the end) and click Start with the example input. You get two app records, the 20 newest reviews of each, and the top 24 apps in the Product reviews category, in about 10 seconds.

Then fill in your own:

Apps: a handle such as judgeme or a full link such as https://apps.shopify.com/klaviyo-email-marketing. The handle is the part of the link after apps.shopify.com/.
Categories to rank: a category handle or link. Use subcategories such as marketing-and-conversion-social-trust-product-reviews. Top-level categories like marketing-and-conversion only show curated sections and have no ranked list, and the Actor tells you which subcategories to use instead.
Keywords (filter rankings): keep only ranked apps whose name, tagline or handle contains a word, for example loyalty. Positions stay the real positions in the category.
Maximum reviews per app (10 per page) and Maximum ranked apps per category (24 per page).
Only these star ratings: for example 1 and 2 to collect complaints.
Maximum records: a total cap across all three record types.

Step 2: Schedule it daily with onlyNew

Switch on Only new items since the previous run (onlyNew). The Actor remembers what it returned for this exact input in a key-value store in your account (shopify-app-store-feed-state by default). Later runs return only reviews it has not seen and apps that newly entered the tracked part of each ranking. App records are always returned, so you can compare ratings and pricing day to day.
Save the input as a task. In Schedules, create a schedule (for example cron 0 7 * * * in your timezone) and add the task.
Connect the dataset to email, Slack, Google Sheets or your own system with an Apify integration or webhook.

The first run returns everything up to your caps. Changing the apps, categories, keywords or review filters starts a fresh history, so settle the lists before you rely on the trend.

One detail matters for rankings. With onlyNew on, apps that were already in the ranking are filtered out, so you only see newcomers. If you want every app's positionChange each day, run a second task with only the category listed and onlyNew off. Keep its app list empty so it has its own history.

Step 3: A daily competitor report in Python

The official apify-client package runs the Actor and reads the results. Install it with pip install apify-client and copy your API token from the Integrations section of the Console.

This script checks three competitors, prints their rating and cheapest paid plan, lists new low-star reviews and shows apps that entered the top 48 of the category.

import os

from apify_client import ApifyClient

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

run_input = {
    "apps": ["judgeme", "loox", "okendo-reviews"],
    "categories": ["marketing-and-conversion-social-trust-product-reviews"],
    "maxReviewsPerApp": 50,
    "maxAppsPerCategory": 48,
    "onlyNew": True,
}

run = client.actor("agents001/shopify-app-store-feed").call(
    run_input=run_input,
    max_total_charge_usd=2,
)
if run is None:
    raise SystemExit("Run failed to start or finish")

apps, reviews, rankings = [], [], []
for item in client.dataset(run.default_dataset_id).iterate_items():
    {"app": apps, "review": reviews, "ranking": rankings}[item["recordType"]].append(item)

print("Competitors")
for a in apps:
    paid = [p for p in a["pricingPlans"] if p.get("priceAmount")]
    cheapest = min(paid, key=lambda p: p["priceAmount"])["priceText"] if paid else "none"
    print(f"  {a['name']}: {a['rating']} stars, {a['reviewCount']} reviews, "
          f"cheapest paid plan {cheapest}, Built for Shopify: {a['builtForShopify']}")

print(f"\n{len(reviews)} new reviews")
for r in reviews:
    if r["rating"] <= 2:
        print(f"  {r['appName']} {r['rating']}* {r['storeName']} ({r['storeCountry']}): "
              f"{r['reviewText'] or '[no text]'}")

print("\nNew in the top 48")
for r in rankings:
    print(f"  #{r['position']} {r['appName']} ({r['rating']} stars, {r['reviewCount']} reviews)")

To track movement for every ranked app, run the category on its own with onlyNew off and sort by positionChange, which is positive when an app moved up:

run = client.actor("agents001/shopify-app-store-feed").call(
    run_input={
        "apps": [],
        "categories": ["marketing-and-conversion-social-trust-product-reviews"],
        "maxAppsPerCategory": 96,
    },
    max_total_charge_usd=1,
)
if run is None:
    raise SystemExit("Run failed to start or finish")

rows = list(client.dataset(run.default_dataset_id).iterate_items())
movers = [r for r in rows if r.get("positionChange")]
for r in sorted(movers, key=lambda r: abs(r["positionChange"]), reverse=True)[:10]:
    print(f"{r['appName']}: #{r['previousPosition']} -> #{r['position']}")

previousPosition and positionChange are empty on the first run of a given input. They fill in from the second run on.

What the output looks like

An app record, trimmed:

{
  "recordType": "app",
  "appHandle": "judgeme",
  "name": "Judge.me Product Reviews App",
  "developerName": "Judge.me",
  "rating": 5.0,
  "reviewCount": 48932,
  "ratingDistribution": {"5": 47857, "4": 810, "3": 74, "2": 36, "1": 155},
  "pricingSummary": "Free plan available. Free trial available.",
  "pricingPlans": [
    {"name": "Forever Free", "priceText": "Free", "priceAmount": 0.0},
    {"name": "Awesome", "priceText": "$15/month", "priceAmount": 15.0,
     "currency": "USD", "billingPeriod": "month", "trial": "15-day free trial"}
  ],
  "launchedDate": "2015-06-25",
  "builtForShopify": true
}

A ranking record, trimmed:

{
  "recordType": "ranking",
  "categoryName": "Product review apps",
  "totalAppsInCategory": 486,
  "position": 2,
  "appName": "Entangle Google Reviews",
  "rating": 5.0,
  "reviewCount": 601,
  "pricingSummary": "Free plan available",
  "builtForShopify": true,
  "previousPosition": null,
  "positionChange": null,
  "isNew": true
}

A review record, trimmed:

{
  "recordType": "review",
  "appName": "Judge.me Product Reviews App",
  "rating": 5,
  "reviewDate": "2026-10-22",
  "reviewText": "I asked the Judge.me support team to help display star ratings on my collection pages, and it's now working perfectly. The support agent was helpful and replied quickly. Great support, thank you!",
  "storeName": "ODKcurtains",
  "storeCountry": "Hong Kong SAR",
  "usageDuration": "6 months using the app",
  "developerReply": null,
  "isNew": true
}

What it costs

The Actor uses pay-per-event pricing, with platform usage included:

$2.50 per 1,000 app records
$2 per 1,000 review records
$1.50 per 1,000 ranking records

Take the two daily tasks above. The competitor task returns 3 app records every day ($0.0075) plus whatever new reviews appear. If the three apps get 30 new reviews a day between them, that adds $0.06. The ranking task returns 96 ranking records a day ($0.144). Together that is about $0.21 a day, or about $6.40 over 30 days.

The first run of the competitor task returns up to 50 reviews per app, so up to 150 reviews ($0.30). You can set a maximum charge per run, and the Actor stops cleanly when it is reached and keeps what it returned so far. Maximum records is a second cap. Check the Store page for current pricing.

What to do with the data

Competitor tracking: store the daily app records and diff pricingPlans, rating, reviewCount, worksWith and builtForShopify to see when a competitor changes plans, adds an integration or earns the badge.
Review monitoring: set Only these star ratings to 1 and 2 on a competitor's app to collect complaints, which often point at features merchants want. Run it on your own app to catch bad reviews and check that each one has a developerReply.
Category ranking changes: post to Slack when an app enters the top 24 of your category or moves more than a few places in a day, and chart position over time in Google Sheets.

Limitations

There is no keyword search of the App Store. The site's robots.txt asks automated clients not to use the search page, so the Actor does not. Keywords filter category rankings only.
Star-only reviews have no text. reviewText is empty for them.
Rankings are the App Store's default order at the time of the run, and the order can differ slightly between visitors. Treat small moves as noise.
Speed is about one page per second. Reading every review of an app with tens of thousands of reviews takes hours, so keep Maximum reviews per app modest and use onlyNew for ongoing tracking.
Prices are as published, which the App Store states in USD.
The App Store changes its layout from time to time. If fields that should have values come back empty, report it in the Actor's Issues tab.

Try it

https://apify.com/agents001/shopify-app-store-feed

Track new South African government tenders every morning, filtered by province and category

Agents001-code — Fri, 23 Oct 2026 12:02:09 +0000

If your business supplies the South African public sector, finding the right tender in time is half the work. A cleaning company in the Western Cape, a civil contractor in KwaZulu-Natal or a bid writer working for ten clients all have the same morning routine: open the eTenders portal, scroll, search, open notices one by one and copy the details into a spreadsheet.

Missing one notice can mean missing a compulsory briefing session, and that usually rules you out of the bid.

This tutorial shows how to replace that routine with a scheduled feed that lands every morning with only the new tenders that match your province, category and keywords. It uses the South Africa Tenders Scraper on the Apify Store.

Where the data comes from

National Treasury runs the eTender Publication Portal at etenders.gov.za, the central place where public bodies advertise tenders. It carries notices from national and provincial departments, municipalities and state-owned companies such as Eskom, Transnet and SANRAL.

Treasury also publishes this data in machine-readable form through an API that follows the Open Contracting Data Standard (OCDS), an international format for public procurement data. OCDS gives each tender a stable ID (ocid), the buyer, the description, documents and dates. Some details that bidders care about, such as province, the detailed eTenders category, briefing session details and delivery location, are on the portal itself. The Actor reads the OCDS API, adds those details from the same portal and returns one record per tender with the same field names every time.

Treasury's publication policy allows reuse, including commercial use, as long as a link to the original source stays intact. Every record includes a sourceUrl and a licence note so you can keep that attribution when you share the data.

The Actor is independent and is not affiliated with or endorsed by National Treasury or any organ of state.

Step 1: Run it once in the Apify Console

Open the Actor's Store page (link at the end) and try it with the default input. You get up to 50 open tenders published in the last 3 days.

Then narrow it down with these fields:

Published in the last N days (publishedWithinDays): default 3.
Status: open by default. You can also pick closed, cancelled, awarded or all.
Provinces: any of the nine provinces, or National for national departments and state-owned companies.
Organ of state / department contains: words in the buyer name, for example Transnet, City of Cape Town or Health.
Category contains: words in the eTenders category, for example Construction, Security, Services: Professional, or the OCDS class works.
Keywords: words in the title, description or tender number, for example solar or cleaning services.
Closing on or after (closingDateFrom): set this to 7 days to skip tenders closing too soon for you to respond.
Maximum tenders (maxItems): default 50, newest first.

Click Start. The Output tab has three views: Tenders (key columns), Briefing sessions, and Documents with one row per document and its download link.

Step 2: Schedule it every weekday morning with onlyNew

Switch on Only new since last run (onlyNew). The Actor remembers the OCDS id of every tender it delivers, in a named key-value store in your Apify account, and later runs return only tenders it has not delivered before. You pay only for the new ones.
Keep Published in the last N days at 3. A Monday run then still catches Friday's notices, and the overlap is never delivered twice.
Set Maximum tenders high enough for a full day, for example 500.
Save the input as a task. In Schedules, create a schedule with cron 0 7 * * 1-5 and timezone Africa/Johannesburg, and add the task.

The memory is tied to your filters (status, provinces, organs of state, categories, keywords). Changing one starts a fresh memory. If you track tenders for several clients, give each one its own task and set State store name to something like client-abc-tenders so their histories stay separate.

Step 3: Pull the data with Python

The official apify-client package can run the Actor and read the results. Install it with pip install apify-client and copy your API token from the Integrations section of the Console.

This script fetches new Western Cape and Gauteng tenders for security and cleaning work, then prints them in closing date order with a warning for compulsory briefings.

import os

from apify_client import ApifyClient

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

run_input = {
    "publishedWithinDays": 3,
    "status": "open",
    "provinces": ["Western Cape", "Gauteng"],
    "keywords": ["security", "cleaning"],
    "closingDateFrom": "7 days",
    "maxItems": 500,
    "onlyNew": True,
}

run = client.actor("agents001/sa-tenders-feed").call(
    run_input=run_input,
    max_total_charge_usd=2,
)
if run is None:
    raise SystemExit("Run failed to start or finish")

tenders = list(client.dataset(run.default_dataset_id).iterate_items())
tenders.sort(key=lambda t: t["closingDateTime"] or "")

for t in tenders:
    print(f"{t['tenderNumber']} | {t['buyerName']} | {t['province']}")
    print(f"  {t['title']}")
    print(f"  Closes {t['closingDateTime']} ({t['daysUntilClosing']} days)")
    briefing = t.get("briefingSession") or {}
    if briefing.get("isCompulsory"):
        print(f"  COMPULSORY briefing: {briefing.get('dateTime')} at {briefing.get('venue')}")
    print(f"  Source: {t['sourceUrl']}\n")

call() waits for the run to finish and returns None if it fails. iterate_items() reads the whole dataset page by page.

What the output looks like

One record from a sample run, trimmed (the full record lists each document with its title, format and download link):

{
  "ocid": "ocds-9t57fa-174759",
  "tenderNumber": "CCMA/2026/05/DR (B)",
  "title": "THE APPOINTMENT OF A SERVICE PROVIDER FOR THE PROVISION OF PRINTING, SUPPLY AND DELIVERY OF A4 CASE FILES WITH LABELS AND CLIPS TO VARIOUS CCMA OFFICES...",
  "tenderType": "Request for Proposal",
  "buyerName": "Commission for Conciliation Mediation & Arbitration",
  "province": "National",
  "category": "Other service activities",
  "mainProcurementCategory": "services",
  "status": "open",
  "publishedDate": "2026-10-19T00:00:00+02:00",
  "closingDateTime": "2026-11-09T11:00:00+02:00",
  "daysUntilClosing": 21,
  "briefingSession": {
    "hasBriefing": true,
    "isCompulsory": true,
    "dateTime": "2026-10-27T11:00:00+02:00",
    "venue": "Link"
  },
  "eSubmission": false,
  "documentCount": 1,
  "sourceUrl": "https://ocds-api.etenders.gov.za/api/OCDSReleases/release/ocds-9t57fa-174759",
  "contactEmail": null,
  "enriched": true
}

Things to notice:

Dates are in South African time (+02:00).
daysUntilClosing saves you doing date maths in a spreadsheet.
briefingSession.isCompulsory is the field to watch. Missing a compulsory briefing normally disqualifies a bid.
contactEmail is empty by default. A switch adds the official contact email from the notice. Contact names, phone numbers and free webmail addresses are never included, in line with POPIA data minimisation.
enriched: false means the portal could not be reached during that run, so province and category may be missing for that record.

What it costs

The Actor uses pay-per-event pricing: $3 per 1,000 tenders returned, so $0.003 per tender. Tenders your filters drop are not charged.

Examples based on that price:

A tight feed for one province and two keywords that returns 10 new tenders a day costs $0.03 a day, roughly $0.63 over 21 working days.
A broad feed of every new open tender nationally that returns 200 a day would cost $0.60 a day.

You can set a maximum cost per run and the Actor stops cleanly when it is reached. Check the Store page for current pricing.

What to do with the data

Google Sheets: send each run's dataset to a shared sheet with the Apify Google Sheets integration. Add your own columns for "Bid / No bid", owner and status.
Email or Slack alerts: use an Apify integration or a webhook to post new tenders to a channel or inbox each morning, with the compulsory briefing date in the message.
Calendar: create calendar entries for briefing sessions and closing dates from briefingSession.dateTime and closingDateTime.
Client digests: if you are a bid writer or B-BBEE consultant, run one task per client with their provinces and categories, and send each client their own short list.
Research: set status to all with a wider date window to study what different departments buy.

Before you bid, remember that most organs of state require suppliers to be registered on National Treasury's Central Supplier Database. The feed helps you find the tender. The official documents tell you what you need to submit.

Limitations

Only the national eTenders portal is covered today. Some entities also advertise on their own procurement portals, and those notices may not appear.
title is the first 160 or so characters of the description, because eTenders has no separate short title. The full text is in description.
If the portal is down during a run, records still come through from OCDS but may lack province, category and briefing details.
Award details (winning bidder and value) are not included yet.
With onlyNew, a tender is delivered once. Later changes such as an extended closing date are not sent again, so check the notice before you submit.
Treasury does not guarantee that the data is complete or current. Always confirm against the official notice and documents.

Try it

https://apify.com/agents001/sa-tenders-feed

Use hiring velocity as a sales signal: track which companies are adding roles

Agents001-code — Fri, 23 Oct 2026 12:02:01 +0000

When a company opens five finance roles in a month, it is probably about to buy finance software. When it starts hiring sales staff in a new city, it is probably about to need office space, payroll in a new state and recruiting help there too. Job postings are one of the few public signals that show where a company is putting its money, and they change week to week.

Sales and business development teams know this. The problem is the effort. Checking fifty careers pages by hand every week does not last long, and a single snapshot tells you little. What you want is the trend: which accounts are adding roles faster than usual, in which departments, and what changed since last week.

This tutorial shows how to build that trend from public job boards using the Job Postings Scraper: Company Hiring Signals Actor on the Apify Store.

Where the data comes from

Many fast-growing companies run recruiting on one of three applicant tracking systems: Greenhouse, Lever or Ashby. Each one hosts a public job board for its customers (pages like boards.greenhouse.io/<company>, jobs.lever.co/<company> and jobs.ashbyhq.com/<company>) and offers public endpoints so companies can list their open roles on their own careers sites.

The Actor reads those public endpoints for the companies you list. It uses no login and reads only jobs the company has published. It returns:

One record per open job: title, department, team, locations, remote flag, employment type, posted date, apply link and the salary range when the company publishes one.
One summary per company (optional): open roles, roles by department, roles posted in the last 7, 30 and 90 days, hiring velocity, median role age, and how many roles opened or closed since your last run.

It does not return job descriptions, recruiter names or contact details.

The Actor is independent and is not affiliated with, endorsed by or sponsored by Greenhouse, Lever, Ashby or any company whose jobs it returns.

What "hiring velocity" means here

In the company summary, hiringVelocityPerWeek is the number of roles posted per week, averaged over the last 30 days. A company with 36 roles posted in the last 30 days has a velocity of 8.4.

Velocity is more useful than the open role count on its own. A company with 150 open roles might have had most of them open for months. A company with 30 open roles that posted 20 of them this month is moving. medianRoleAgeDays helps you tell the two apart: a low median age means most roles are recent.

Step 1: Run it once in the Apify Console

Open the Store page (link at the end). With an empty company list the Actor runs a small example set, which is a good way to see the output.

Then fill in your own:

Companies: one entry per company. The most reliable format is greenhouse:<board>, lever:<site>, lever-eu:<site> or ashby:<name>. You can also paste a job board URL, a careers page URL, or just a name, and the Actor will try to find the board.
Department or team contains: for example Finance, Sales, Engineering.
Job title contains and Job title does not contain: for example include Account Executive, exclude Intern.
Location contains: for example London, Germany, Remote.
Remote jobs: any, remote only, or exclude remote.
Posted in the last N days: 0 means any age.
Add a hiring summary per company: on by default.
Maximum jobs per company and Maximum job records: caps on job records. The company summary still counts every open role.

To find a company's board, open its careers page, click any job and look at the link. jobs.lever.co/acme means lever:acme.

Step 2: Schedule it daily with onlyNew

Switch on Only jobs not seen in previous runs (onlyNew). The Actor remembers which job IDs it has returned for this exact input, in a key-value store in your account (hiring-signals-feed-state by default). Later runs return only jobs that are new since then.
Leave Add a hiring summary per company on. The summary's newRolesSinceLastRun, closedRolesSinceLastRun and netChangeSinceLastRun use the same history, so each run tells you what changed.
Save the input as a task. In Schedules, create a schedule (for example cron 0 7 * * 1-5 in your timezone) and add the task.

The first run returns every matching job, and the "since last run" fields are empty. From the second run on, you get only new jobs and real change numbers. Changing the company list or filters starts a fresh history, so settle your filters before you rely on the trend.

Step 3: Rank accounts by velocity in Python

The official apify-client package runs the Actor and reads the results. Install it with pip install apify-client and copy your API token from the Integrations section of the Console.

This script runs the Actor over a list of target accounts, then ranks them by hiring velocity and flags any account with a jump in open roles since the last run.

import os

from apify_client import ApifyClient

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

run_input = {
    "companies": [
        "greenhouse:figma",
        "greenhouse:discord",
        "lever:spotify",
        "ashby:linear",
        "ashby:ramp",
    ],
    "onlyNew": True,
    "includeCompanySummary": True,
    "includeSalary": True,
}

run = client.actor("agents001/company-hiring-signals-feed").call(
    run_input=run_input,
    max_total_charge_usd=3,
)
if run is None:
    raise SystemExit("Run failed to start or finish")

summaries, new_jobs = [], []
for item in client.dataset(run.default_dataset_id).iterate_items():
    if item["recordType"] == "companySummary":
        summaries.append(item)
    else:
        new_jobs.append(item)

summaries.sort(key=lambda s: s["hiringVelocityPerWeek"] or 0, reverse=True)

print(f"{'Company':<12}{'Open':>6}{'7d':>5}{'30d':>6}{'Per wk':>8}  Top departments")
for s in summaries:
    print(
        f"{s['company']:<12}{s['openRoles']:>6}{s['postedLast7Days']:>5}"
        f"{s['postedLast30Days']:>6}{s['hiringVelocityPerWeek'] or 0:>8}  {s['topDepartments']}"
    )
    net = s.get("netChangeSinceLastRun")
    if net is not None and net >= 10:
        print(f"  -> {s['company']} added a net {net} roles since the last run")

print(f"\n{len(new_jobs)} new job records this run")

On a sample run over those five companies, the ranking came out like this:

Company       Open   7d   30d  Per wk  Top departments
Ramp           168   15    51    11.9  Sales (67), Engineering (38), People & Talent (15), ...
Figma          142   11    36     8.4  Sales (44), Engineering (28), Early Career (11), ...
Spotify         81    5    34     7.9  Engineering (32), Markets and Subscriber Growth (9), ...
Discord         46    2    14     3.3  Product Engineering (12), Developers (7), ...
Linear          27    1     3     0.7  Product (13), GTM (12), Operations (2)

Linear has 27 open roles but a median role age of 144 days and only three roles posted in the last month. Ramp is posting about twelve roles a week, most of them in sales. Those are two very different conversations for a seller.

What the output looks like

A job record, trimmed:

{
  "recordType": "job",
  "company": "Ramp",
  "companyKey": "ashby:ramp",
  "ats": "ashby",
  "title": "Senior Backend Engineer | Token Spend Management",
  "department": "Engineering",
  "team": "Backend",
  "location": "New York, NY (HQ)",
  "locations": ["New York, NY (HQ)", "Remote (Canada)", "Remote (US)"],
  "remote": true,
  "workplaceType": "hybrid",
  "employmentType": "full-time",
  "postedAt": "2026-10-20T13:40:20Z",
  "ageDays": 0,
  "salaryText": "USD 204,000 - 280,000 per year",
  "jobUrl": "https://jobs.ashbyhq.com/ramp/b7514711-8a29-4bd2-a97a-967be14e336f",
  "isNew": true
}

A company summary, trimmed:

{
  "recordType": "companySummary",
  "company": "Figma",
  "companyKey": "greenhouse:figma",
  "openRoles": 142,
  "topDepartments": "Sales (44), Engineering (28), Early Career (11), Business Operations (10), Design (10)",
  "postedLast7Days": 11,
  "postedLast30Days": 36,
  "postedLast90Days": 75,
  "hiringVelocityPerWeek": 8.4,
  "medianRoleAgeDays": 87,
  "remoteShare": 0.0,
  "rolesWithSalary": 93,
  "newRolesSinceLastRun": null,
  "closedRolesSinceLastRun": null,
  "netChangeSinceLastRun": null
}

The null change fields are expected on a first run.

What it costs

The Actor uses pay-per-event pricing:

$3 per 1,000 job records ($0.003 each)
$0.005 per company summary

A daily onlyNew run over 50 target accounts costs $0.25 for the summaries plus $0.003 per new job. If those accounts post 60 new matching roles a day between them, that is $0.43 a day, or about $9 over 21 working days.

Watch the first run. It returns every matching open job, so 50 companies with 100 open roles each would be 5,000 records, or $15. Department, title and location filters cut that down, and Maximum jobs per company caps job records while the summary still counts every open role. You can also set a maximum cost per run. Check the Store page for current pricing.

What to do with the data

CRM: write hiringVelocityPerWeek, postedLast30Days and topDepartments onto the account record in your CRM through Zapier, Make or a webhook, and sort your territory by them.
Google Sheets: send the Company summaries view to a sheet each morning and chart velocity per account over time.
Alerts: post to Slack when an account's netChangeSinceLastRun crosses a threshold, or when a new role appears in the department you sell into.
Territory planning: use topLocations and new locations in job records to spot accounts expanding into your region.

Limitations

Only Greenhouse, Lever and Ashby boards are supported. Companies on Workday, SmartRecruiters, iCIMS and other systems are not covered yet.
You supply the company list. The Actor does not discover companies for you.
A posting is an intent to hire, which is different from a hire. Some roles stay open for months and some are evergreen listings.
Department names are whatever each company uses, so "GTM" at one company may be "Sales" at another.
Employment type and department are only filled when the company fills them. Salary appears only where the company publishes it, which is more common for US roles.
Job descriptions are not included.

Try it

https://apify.com/agents001/company-hiring-signals-feed

How to get a daily list of newly funded US startups from Form D filings

Agents001-code — Fri, 23 Oct 2026 12:02:00 +0000

If you sell to startups, invest in them or recruit for them, timing matters. A company that has just closed a round has fresh budget, new hiring plans and a board asking how the money will be spent. The hard part is knowing who raised, and knowing it soon.

Press releases cover a small share of rounds. Paid funding databases cover more, but they cost a lot and often lag behind. There is a free, official source most teams overlook: SEC Form D.

This tutorial shows how to turn Form D filings into a daily list of newly funded US companies, filtered by state, industry and size, using the Form D Scraper on the Apify Store.

What Form D is

When a US company sells securities privately under Regulation D (the exemption most startup rounds use), it files a short notice with the Securities and Exchange Commission called Form D. The filing is due within 15 days after the first sale of securities. Amendments are filed as Form D/A, for example when an offering runs longer than a year or its details change.

Each filing is public on EDGAR, the SEC's filing system, and includes:

the company name and business address
industry group (for example Biotechnology or Other Technology)
the total offering amount, the amount already sold and the amount remaining
the date of first sale
the type of security (equity, debt, options, SAFEs described in a free text field)
the exemption claimed, such as Rule 506(b)
the number of investors so far

The catch is format. EDGAR shows one filing at a time, and the useful fields sit inside XML. The Actor reads EDGAR full-text search and the daily index, opens each filing and returns one tidy row per filing with the same columns every time.

The tool is independent and is not affiliated with or endorsed by the SEC.

Step 1: Run it once in the Apify Console

Open the Actor's Store page (link at the end), click to try it, and you will see the input form. The fields that matter for a startup prospect list:

Days back: how many calendar days of filings to fetch. Default 3.
Form types: D and D/A by default. You can add 8-K and 8-K/A if you also want trigger events from listed companies.
US states: two-letter codes for the business address, such as CA, NY, TX. Empty means all.
Industry groups: words to match, such as Technology or Health Care.
Exclude pooled investment funds: switch this on. A large share of Form D filings come from hedge funds, venture funds and other fund vehicles. Excluding them leaves operating companies.
Minimum offering amount: for example 1000000 to skip very small raises.
Max records: a cap on saved filings. Each saved filing is one billable event.
SEC User-Agent: put your company name and a contact email here, for example Acme Growth Ltd sales-ops@acme.com. The SEC fair access policy asks every automated client to identify itself.

Click Start. A default run of 50 records takes roughly 15 seconds. You can download the results as CSV, Excel or JSON from the Output tab, which has ready-made views for Fundraises, Trigger events and Company contacts.

Step 2: Schedule it daily with onlyNew

A one-off list goes stale fast. The useful version is a list that arrives every morning with only the companies you have not seen yet.

Switch on Only new since last run (onlyNew). The Actor then remembers the accession number (the SEC's unique filing ID) of every filing it delivers, in a named key-value store in your Apify account. Later runs skip those filings, and you are only charged for new ones.
Keep Days back at 3. The overlap with earlier runs is deliberate: late filings and weekend gaps are still caught, and nothing is delivered twice.
Set Max records high enough for a full day of new filings, for example 1000. It counts new records only.
Save the input as a task, then go to Schedules, create a schedule with cron 0 7 * * 1-5 and timezone America/New_York, and add the task.

One detail worth knowing: the memory is tied to your filters (form types, states, industries, minimum amount, fund exclusion, 8-K items). If you change a filter you get a fresh memory. If you want to name it yourself, set State store name.

Step 3: Pull the data with Python

If you would rather work from code, the official apify-client package can start the run and read the results. Install it with pip install apify-client and copy your API token from the Integrations section of the Console.

import csv
import os

from apify_client import ApifyClient

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

run_input = {
    "daysBack": 3,
    "formTypes": ["D"],
    "states": ["CA", "NY", "TX", "MA"],
    "industryGroups": ["Technology", "Health Care"],
    "excludePooledInvestmentFunds": True,
    "minOfferingAmount": 1_000_000,
    "maxItems": 1000,
    "onlyNew": True,
    "userAgent": "Acme Growth Ltd sales-ops@acme.com",
}

# Starts the run and waits for it to finish. Caps spend at $5 for this run.
run = client.actor("agents001/form-d-funding-feed").call(
    run_input=run_input,
    max_total_charge_usd=5,
)
if run is None:
    raise SystemExit("Run failed to start or finish")

fields = [
    "companyName", "state", "industryGroup", "totalOfferingAmount",
    "totalAmountSold", "dateOfFirstSale", "filingDate", "filingUrl",
]

with open("new_raises.csv", "w", newline="") as f:
    writer = csv.DictWriter(f, fieldnames=fields, extrasaction="ignore")
    writer.writeheader()
    for item in client.dataset(run.default_dataset_id).iterate_items():
        writer.writerow(item)
        sold = item.get("totalAmountSold") or 0
        print(f"{item['companyName']} ({item['state']}): ${sold:,.0f} sold so far")

call() returns None if the run fails, so the check matters. iterate_items() pages through the dataset for you.

What the output looks like

Here is one Form D record from a sample run, trimmed to the most useful fields. The full record also has the business address and company phone as filed.

{
  "recordType": "fundraise",
  "formType": "D",
  "isAmendment": false,
  "companyName": "Alercell Inc",
  "filingDate": "2026-10-19",
  "state": "MT",
  "industryGroup": "Biotechnology",
  "industrySector": "Health Care",
  "revenueRange": "No Revenues",
  "totalOfferingAmount": 1500000,
  "totalAmountSold": 35000,
  "totalRemaining": 1465000,
  "dateOfFirstSale": "2026-10-12",
  "securitiesOffered": ["Equity"],
  "federalExemptionLabels": ["Rule 506(b)"],
  "totalInvestors": 3,
  "filingUrl": "https://www.sec.gov/Archives/edgar/data/2160842/000216084226000001/0002160842-26-000001-index.htm"
}

A few fields worth understanding:

totalOfferingAmount is what the company plans to raise in this offering. It is null with offeringAmountIndefinite: true when the issuer filed the amount as Indefinite, which is common for funds.
totalAmountSold against totalRemaining tells you whether the round is mostly closed or still open.
isAmendment and formType: "D/A" mark amendments. An amendment can show a round that has grown.
Executive and director names are off by default. There is a switch to include them, which you should only use if you have a lawful basis to process that personal data.

What it costs

The Actor uses pay-per-event pricing: $6 per 1,000 filings saved, which is $0.006 per filing. Filings your filters drop are not charged.

Two example budgets, based on that price:

A filtered feed (a few states, technology and health care, funds excluded, $1M minimum) that returns 40 new filings a day costs $0.24 a day, or about $5 over 21 working days.
An unfiltered feed of every new Form D, which the README puts at a few hundred records on a typical day, would be around $1.80 a day at 300 records.

You can set a maximum total charge on each run, and the Actor stops cleanly when it reaches it. Check the Store page for current pricing before you budget.

What to do with the data

CRM: push new rows into HubSpot or another CRM through Zapier, Make or a webhook. Use accessionNumber as the unique key so you never create duplicates.
Google Sheets: connect the task's dataset to a sheet with the Apify Google Sheets integration and give your team a shared morning list.
Slack alerts: post each new filing above a size threshold to a channel, with the filingUrl so anyone can check the source.
Market tracking: run a longer date range (Start date and End date go back to 2009) and count raises by industry, state and size over time.

Limitations

Form D is a notice filed after money starts coming in, up to 15 days after the first sale, so you will rarely be first to hear about a round that was announced publicly.
Some companies file late, and some raise without filing Form D at all. Treat the feed as a strong source with gaps.
Form D does not list investors or valuations.
The address and phone are what the company filed. They can be out of date or belong to an office the team rarely uses.
There are no filings on weekends or US federal holidays.
US issuers only. Contact details are company level, with no personal emails.

Try it

https://apify.com/agents001/form-d-funding-feed