DEV Community: Agents001-code

Track new UK companies every month for lead lists

Agents001-code — Mon, 26 Oct 2026 15:15:22 +0000

Every month several tens of thousands of new companies are registered at Companies House. Each one needs a bank account, an accountant, insurance, a website, payroll, software and premises. If you sell any of those, a list of companies incorporated last month in your sector and your area is about as warm as a cold list gets.

Companies House makes all of this public. The register can be searched one company at a time on its website, and the whole register of live companies is published once a month as a free download. The download is large, though: several big CSV files with every live UK company in them. Filtering it down to "software companies in Leeds and Manchester incorporated in September" takes some work every month.

This tutorial shows how to get that filtered list automatically each month with the UK Companies House Scraper on the Apify Store, plus how to switch to a daily feed if you want companies on the day they register. I built the Actor.

Where the data comes from

The Actor has two modes, depending on whether you give it a Companies House API key.

	Without a key (default)	With your free API key
Source	Free Company Data Product, a monthly snapshot of every live UK company	Companies House Public Data API
Freshness	Updated monthly, within 5 working days of month end	Live, including companies registered today
"Last N days" counts back from	The snapshot date	Today
Filing events (accounts, charges, insolvency)	No	Yes

The monthly snapshot is enough for a monthly lead list, and it needs no account or key at all. That is the setup used in this tutorial.

Each record is company level: number, name, status, type, incorporation date, registered office address split into parts (including postcode area and district), SIC codes with descriptions, and the next accounts and confirmation statement due dates. The Actor never collects officers or persons with significant control, and it drops "care of" address lines, which can name a person.

The Actor is independent and is not affiliated with or endorsed by Companies House or the UK Government.

Step 1: Run it once in the Apify Console

Open the Store page (link at the end) and click Start with no input. You get up to 1,000 UK companies incorporated in the 30 days before the latest monthly snapshot.

Then narrow it down with these fields:

Incorporated in the last N days (incorporatedWithinDays): default 30. Without a key this counts back from the snapshot date.
SIC codes (sicCodes): SIC 2007 codes or prefixes. 62 covers all computer programming and consultancy, 62012 is business and domestic software development, 56 covers restaurants and other food service, 68 covers real estate.
Registered office postcode starts with (postcodePrefixes): postcode areas, districts or sectors, such as M, LS, EC1 or SW1A 1. EC1 also matches EC1A and EC1V, but M1 does not match M14.
Company types (companyTypes): Companies House codes such as ltd, llp and plc, plus community-interest-company.
Company status (companyStatuses): active for most lead lists.
Maximum records (maxItems): default 1,000. 0 means no limit.

For this tutorial I ran it locally with SIC 62, postcodes M and LS, and type ltd, capped at 50 records. It read the snapshot dated 1 October 2026, used an incorporation window of 2 September to 1 October, and returned 50 records in about 11 seconds. A run over the whole snapshot with no cap can take up to about 2 minutes, because it reads up to 7 large files.

Step 2: Schedule it monthly with onlyNew

The snapshot updates once a month, so a monthly run is the natural fit.

Switch on Only records not seen in previous runs (onlyNew). The Actor remembers which company numbers it has already returned for your filters, in a key-value store in your Apify account. The next run only returns companies it has not given you before, and you are only charged for those.
Set Incorporated in the last N days to 45. A rolling window is stored as the number of days, so your monthly runs keep one history, and the overlap with last month means a company that appeared late in the register is still caught once.
Set Maximum records to 0 so a large month is not cut short.
Save the input as a task. In Schedules, create a schedule with cron 0 8 10 * * and timezone Europe/London. That runs on the 10th of each month, after the snapshot has been published.

Changing a filter starts a fresh history.

If you want new companies daily, register for a free REST API key on the Companies House Developer Hub and paste it into Your Companies House API key. The field is secret, and Apify stores it encrypted. Then use incorporatedWithinDays: 2, onlyNew: true and a weekday schedule. Adding or changing the key does not reset the history.

Step 3: Pull the list with Python

Install the official client with pip install apify-client and copy your Apify API token from the Integrations section of the Console.

import csv
import os
from collections import Counter

from apify_client import ApifyClient

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

run_input = {
    "incorporatedWithinDays": 45,
    "sicCodes": ["62", "63"],
    "postcodePrefixes": ["M", "LS", "S", "B"],
    "companyTypes": ["ltd"],
    "companyStatuses": ["active"],
    "onlyNew": True,
    "maxItems": 0,
}

# Starts the run and waits for it to finish. Caps spend at $3 for this run.
run = client.actor("agents001/uk-companies-house-feed").call(
    run_input=run_input,
    max_total_charge_usd=3,
)
if run is None or run.status != "SUCCEEDED":
    raise SystemExit("Run failed to start or finish")

fields = [
    "companyNumber", "companyName", "incorporationDate", "postTown",
    "postcodeDistrict", "sicCodes", "sicDescriptions", "companyUrl",
]
by_area = Counter()

with open("new_uk_companies.csv", "w", newline="") as f:
    writer = csv.DictWriter(f, fieldnames=fields, extrasaction="ignore")
    writer.writeheader()
    for c in client.dataset(run.default_dataset_id).iterate_items():
        row = dict(c)
        row["sicCodes"] = "; ".join(c["sicCodes"])
        row["sicDescriptions"] = "; ".join(c["sicDescriptions"])
        writer.writerow(row)
        by_area[c["postcodeArea"]] += 1

for area, count in by_area.most_common():
    print(f"{area}: {count} new companies")

call() returns None if the run could not be started or followed, so the check matters. iterate_items() pages through the dataset for you. SIC codes come as a list because a company can declare up to four.

What the output looks like

Two real records from that local run, trimmed. The full record also has the registered office address lines and county.

{
  "recordType": "company",
  "companyNumber": "17486618",
  "companyName": "AVERO SAAS LIMITED",
  "companyStatus": "active",
  "companyType": "ltd",
  "companyTypeLabel": "Private Limited Company",
  "incorporationDate": "2026-09-28",
  "postTown": "MANCHESTER",
  "postcodeArea": "M",
  "postcodeDistrict": "M12",
  "sicCodes": ["62012"],
  "sicDescriptions": ["Business and domestic software development"],
  "accountsNextDueDate": "2028-06-28",
  "confirmationStatementNextDueDate": "2027-10-11",
  "companyUrl": "https://find-and-update.company-information.service.gov.uk/company/17486618",
  "dataSource": "free-company-data-product",
  "dataAsOf": "2026-10-01",
  "isNew": true
}

{
  "companyNumber": "17492640",
  "companyName": "1ST CYBER LTD",
  "incorporationDate": "2026-09-30",
  "postTown": "LEEDS",
  "postcodeArea": "LS",
  "postcodeDistrict": "LS14",
  "sicCodes": ["62020"],
  "sicDescriptions": ["Information technology consultancy activities"],
  "dataAsOf": "2026-10-01"
}

A few fields worth knowing:

dataAsOf is the snapshot date when there is no key. Records from the live API have dataSource set to companies-house-api.
postcodeArea and postcodeDistrict are ready for territory routing, so you do not need to parse postcodes yourself.
accountsNextDueDate and confirmationStatementNextDueDate are useful for accountants: a new company's first accounts deadline is already known.

What it costs

The Actor uses pay-per-event pricing with platform usage included: $3.00 per 1,000 records on the Free plan, lower on higher paid Apify plans (down to $2.00 per 1,000). You only pay for records saved to your dataset, so filters and onlyNew keep the bill small.

A monthly list of 400 new tech companies across four city areas costs $1.20 a month. A list of every new company in one postcode area across all sectors, say 2,000 a month, costs $6. Set a maximum charge per run and the Actor stops cleanly when it is reached. Check the Store page for current pricing.

What to do with the data

CRM: use the Apify app in Zapier, Make or n8n to create a company in HubSpot, Salesforce or Pipedrive when the monthly task finishes. Use companyNumber as the unique key.
Google Sheets: add the Google Sheets Import & Export Actor (lukaskrivka/google-sheets) as an Actor integration on the task, in append mode, so the team gets one growing sheet.
Email: the Gmail integration can send the month's list as an attachment.
Territory reports: count new companies by postcodeArea and SIC prefix each month to see where your market is growing.

Limitations

Without a key the data is monthly, so a company registered on the 2nd of the month appears in the snapshot published early the next month. Use a key for daily data.
The snapshot holds live companies only. Dissolved companies need the API.
SIC codes are what the company declared at registration. Many new companies pick a broad or wrong code, so expect some noise.
Some small companies use a home address as their registered office. That address is on the public register, but treat it with care. If you use the data for marketing you remain responsible for complying with UK GDPR and PECR.
The Actor does not return directors or shareholders, and has no email addresses or phone numbers.

Try it

https://apify.com/agents001/uk-companies-house-feed

Turn 8-K filings into sales trigger alerts

Agents001-code — Mon, 26 Oct 2026 15:14:48 +0000

Most sales teams already know what a good trigger event looks like. A new chief executive reviews suppliers in the first few months. A company that has just bought another one has to merge two sets of systems, contracts and teams. A company that has signed a large customer agreement is about to scale up. The trouble is hearing about it in time, for the accounts you care about, without reading the news all day.

US public companies have to report these events to the Securities and Exchange Commission on Form 8-K, usually within four business days. The filings are public and free. What they lack is a format a sales team can use: each 8-K lists numbered "items" such as 5.02 or 2.01, and EDGAR shows them one filing at a time.

This tutorial shows how to turn those filings into a daily list of trigger events with plain-English labels and yes or no flags, filter it to your industries and accounts, and send alerts to Slack or email. It uses the 8-K Filings Scraper on the Apify Store, which I built.

What an 8-K item tells you

Every 8-K reports one or more numbered items. The Actor adds a short plain label and a category to each one. These are the items that matter most for sales:

Item	Plain label	Why it matters
1.01	Signed a major agreement	New customers, suppliers, partnerships, credit deals
2.01	Completed an acquisition or sale of assets	New owners, integration projects, system changes
5.01	Change in control of the company	The company has new owners
5.02	Officer or director change	A new executive often reviews vendors
1.03	Bankruptcy or receivership	Distress signal for advisory and credit teams
2.05	Restructuring, exit or layoff costs	Cost cutting, often a change in priorities
3.01	Delisting notice or listing rule problem	Distress signal
2.02	Reported financial results	Routine, usually filtered out for alerts
9.01	Financial statements and exhibits	Attached to most filings, never picked as the main event

Each record also has three flags that make filtering easy in a spreadsheet or CRM:

hasLeadershipChange is true when the filing includes item 5.02.
hasDealOrAcquisition is true when it includes 1.01, 2.01 or 5.01.
hasDistressSignal is true when any item falls in the distress category (bankruptcy, accelerated debt, impairments, delisting notices, non-reliance on earlier financial statements).

primaryEvent picks the most sales-relevant item in the filing, so a filing with items 1.01, 5.02 and 9.01 gets 1.01, Signed a major agreement, as its main event.

The Actor reports only that a leadership change happened. It never opens the filing documents and does not return the names of officers, directors or anyone else. Use filingUrl to read the filing itself. The Actor is independent and is not affiliated with or endorsed by the SEC.

Step 1: Run it once in the Apify Console

Open the Store page (link at the end) and click Start. The example input returns filings from the last 3 days that report a major agreement, a completed acquisition or an officer or director change. A run with no input finishes in a few seconds and returns up to 200 filings.

Then narrow it down:

Event types (8-K items) (itemCodes): only filings with at least one of these items, for example ["1.01", "2.01", "5.02"].
Skip filings that only report (excludeItemCodes): for example ["2.02", "7.01"] to drop filings that only announce results or investor presentations.
Industry (SIC codes) (sicCodes): a code or prefix, such as 7372 for prepackaged software or 28 for chemicals and pharma.
Business address state (states) and State of incorporation (incorporationStates).
Companies (tickers or CIKs) (companies): your named accounts, for example AAPL or 320193.
Maximum records (maxItems): default 200. 0 means no limit.
User-Agent sent to SEC (userAgent): optional. You can put your company name and a contact email here, which the SEC fair access policy asks automated clients to send. The Actor sends its own if you leave it empty.

Step 2: Schedule it daily with onlyNew

Switch on Only filings not seen in previous runs (onlyNew). The Actor remembers the accession number (the SEC's unique filing ID) of every filing it returns for your filters, in a key-value store in your Apify account. Later runs skip those, so you are never charged twice for the same filing.
Use a short window with some overlap, such as daysBack: 3. The date window is not part of the memory, so the overlap catches anything late without repeating it.
Save the input as a task, then create a schedule, for example cron 0 7 * * 1-5 with timezone America/New_York, and add the task.

Changing a filter starts a fresh history.

Step 3: Send alerts to Slack or email without code

In the task's Integrations tab:

Slack: the Slack integration posts a message to a channel you choose when a run succeeds. You can write your own message template. It works well as a "today's 8-K signals are ready" ping with a link to the run.
Email: the Gmail integration sends an email after each successful run and can attach the run's dataset.
One message per filing: use the Apify app in Zapier, Make or n8n. Trigger on a finished task run, fetch the dataset items, then post each item to Slack or create a task in your CRM.

If you would rather control the message yourself, the next two steps do it in code.

Step 4: Python, with a Slack message per signal

Install the client with pip install apify-client, copy your Apify API token from the Integrations section of the Console, and create a Slack incoming webhook for the channel you want.

import json
import os
import urllib.request

from apify_client import ApifyClient

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

run_input = {
    "daysBack": 3,
    "itemCodes": ["1.01", "2.01", "5.01", "5.02"],
    "sicCodes": ["7370", "7371", "7372", "7373", "7374", "2834"],
    "onlyNew": True,
    "maxItems": 500,
}

# Starts the run and waits for it to finish. Caps spend at $2 for this run.
run = client.actor("agents001/form-8k-company-events").call(
    run_input=run_input,
    max_total_charge_usd=2,
)
if run is None or run.status != "SUCCEEDED":
    raise SystemExit("Run failed to start or finish")

lines = []
for f in client.dataset(run.default_dataset_id).iterate_items():
    if not (f["hasLeadershipChange"] or f["hasDealOrAcquisition"]):
        continue
    ticker = f" ({f['ticker']})" if f.get("ticker") else ""
    lines.append(
        f"*{f['companyName']}*{ticker}, {f.get('businessLocation') or 'US'}: "
        f"{f['primaryEvent']} (filed {f['filedDate']}) <{f['filingUrl']}|filing>"
    )

if lines:
    text = "New 8-K sales triggers:\n" + "\n".join(lines[:40])
    req = urllib.request.Request(
        SLACK_WEBHOOK_URL,
        data=json.dumps({"text": text}).encode(),
        headers={"Content-Type": "application/json"},
    )
    with urllib.request.urlopen(req) as resp:
        print(f"Posted {len(lines)} signals to Slack, status {resp.status}")
else:
    print("No new signals today")

call() returns None if the run could not be started or followed, so the check matters. The message is capped at 40 lines to keep it readable.

Step 5: The same in JavaScript

With Node.js 18 or later, install the client with npm install apify-client and save this as signals.mjs:

import { ApifyClient } from 'apify-client';

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

const input = {
    daysBack: 3,
    itemCodes: ['1.01', '2.01', '5.01', '5.02'],
    companies: ['ORCL', 'CRM', 'WDAY', 'ADBE'],
    onlyNew: true,
};

// Starts the run and waits for it to finish. Caps spend at $1 for this run.
const run = await client
    .actor('agents001/form-8k-company-events')
    .call(input, { maxTotalChargeUsd: 1 });

if (run.status !== 'SUCCEEDED') {
    throw new Error(`Run finished with status ${run.status}`);
}

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

for (const f of items) {
    const flags = [
        f.hasLeadershipChange && 'leadership change',
        f.hasDealOrAcquisition && 'deal or acquisition',
        f.hasDistressSignal && 'distress',
    ].filter(Boolean);
    console.log(`${f.filedDate} ${f.companyName} (${f.ticker ?? f.cik}): ${f.eventSummary}`);
    console.log(`  flags: ${flags.join(', ') || 'none'}  ${f.filingUrl}`);
}

Run it with node signals.mjs. Here the companies filter watches a named account list. listItems() returns the dataset items in one call. For very large datasets, pass offset and limit to page through them.

What the output looks like

Here is a real record from a sample run on 23 October 2026, trimmed. It is a filing that reports a completed acquisition alongside a leadership change:

{
  "companyName": "Bolt Biotherapeutics, Inc.",
  "cik": "0001641281",
  "ticker": "BOLT",
  "primaryEvent": "Completed an acquisition or sale of assets",
  "primaryEventCode": "2.01",
  "eventItemCodes": ["1.01", "1.02", "2.01", "3.02", "5.02", "5.03", "7.01", "8.01", "9.01"],
  "eventCategories": ["agreement", "acquisition", "financing", "leadership-change", "governance", "investor-communication", "other-event", "exhibits"],
  "hasLeadershipChange": true,
  "hasDealOrAcquisition": true,
  "hasDistressSignal": false,
  "industry": "Pharmaceutical Preparations",
  "sicCode": "2834",
  "stateOfIncorporation": "DE",
  "businessLocation": "Redwood City, CA",
  "formType": "8-K",
  "filedDate": "2026-10-23",
  "periodOfReport": "2026-10-23",
  "accessionNumber": "0001193125-26-429647",
  "filingUrl": "https://www.sec.gov/Archives/edgar/data/1641281/000119312526429647/0001193125-26-429647-index.htm"
}

And a simpler leadership change, where eventSummary gives a readable line:

{
  "companyName": "Limitless X Holdings Inc.",
  "ticker": "LIMX",
  "primaryEvent": "Officer or director change",
  "primaryEventCode": "5.02",
  "eventSummary": "5.02 Officer or director change; 5.03 Changed articles, bylaws or fiscal year; 9.01 Financial statements and exhibits",
  "hasLeadershipChange": true,
  "hasDealOrAcquisition": false,
  "industry": "Services: Miscellaneous Amusement & Recreation",
  "businessLocation": "Beverly Hills, CA",
  "filedDate": "2026-10-23",
  "periodOfReport": "2026-06-03"
}

Note periodOfReport against filedDate. The period of report is the date of the event, and some companies file months later, so check it before you write "congratulations on the new role".

In that sample of 200 filings, 22 had a leadership change, 24 had a deal or acquisition flag and 4 had a distress signal. The most common items were 9.01, 2.02 and 7.01, which is why excludeItemCodes is worth setting.

What it costs

The Actor uses pay-per-event pricing with platform usage included: $2.00 per 1,000 filings on the Free plan, lower on paid Apify plans (down to $1.40 per 1,000). You only pay for filings saved to your dataset.

All US companies together file roughly 250 to 350 Form 8-Ks on a normal business day. An unfiltered daily feed of 300 filings is $0.60 a day. A feed filtered to deals and leadership changes in a few industries is usually a few dozen filings, well under $0.10 a day. Set a maximum charge per run and the Actor stops cleanly when it is reached. Check the Store page for current pricing.

Limitations

8-Ks are filed after the event, usually within four business days, so a large deal may already be in the news.
Only companies that file with the SEC are covered, which leaves out most private companies.
Tickers are empty for companies without listed securities. Every record has a CIK, which identifies the company exactly.
The Actor classifies filings by their item codes. It does not read the filing text, so it cannot tell you who the new executive is or what was acquired. Open filingUrl for that.
Amendments (8-K/A) are off by default. Switch on Include amended filings if you want them.
This is not investment advice. Check the original filing before acting on it.

Try it

https://apify.com/agents001/form-8k-company-events

Find companies that just won government contracts (US, UK, EU, Australia)

Agents001-code — Mon, 26 Oct 2026 15:14:39 +0000

A company that has just won a public contract is about to spend money. It has a delivery deadline, and it often needs to hire, subcontract and buy equipment, software and services. For a B2B sales team, a recruiter or a subcontractor looking for a prime, that is a strong buying signal.

The data is public. The US, the UK and the EU all publish who won which contract, for how much and from which buyer. The problem is that each one publishes it in its own format, on its own portal, with its own codes, and none of them sends you a tidy list of yesterday's winners in your market.

This tutorial shows how to get that list every morning from three Actors on the Apify Store, filter it by industry code, and send it to a CRM or a Google Sheet. I built these Actors, so I will also point out where the source data has gaps.

The three sources

Market	Actor	Source	Industry codes
United States	`agents001/us-federal-contract-awards`	USAspending.gov API (US Treasury)	NAICS and PSC
United Kingdom	`agents001/uk-public-contracts-feed`	Find a Tender and Contracts Finder (Cabinet Office)	CPV
European Union	`agents001/eu-ted-tenders-feed`	TED Search API (EU Publications Office)	CPV
Australia	AusTender feed, coming soon	AusTender	UNSPSC

All three return company-level records only. Awards to private individuals, such as sole traders listed under their own name, are dropped, and no contact names, emails or phone numbers are collected. Each Actor is independent and is not affiliated with or endorsed by the governments or agencies that publish the data.

The record shape differs a little per market, because the sources differ, but each record tells you the same four things: who won, who bought, how much, and what it was for.

Step 1: Run each one once in the Apify Console

Open each Actor's Store page (links at the end) and start it with the example input. Then narrow it to your market.

US federal awards. The fields that matter:

Award types: contracts by default. idvs (contract vehicles such as IDIQs and GSA schedules) and grants are optional.
Awarded in the last N days (daysBack): default 7.
NAICS codes (naicsCodes): codes or prefixes, so 5415 covers all of computer systems design.
Product or service codes (pscCodes): for example D or R425.
US states with Match states against set to the recipient address or the place of performance.
Minimum award amount (USD) and Businesses only, which leaves out universities, nonprofits and government bodies.

UK contracts. Set What to return to awards, then use CPV codes (cpvCodes). Trailing zeros mean "everything below", so 72000000 matches all IT services. You can add Regions, Minimum value (GBP) and Winning supplier size (sme or large). Each award record carries the supplier's Companies House number when the notice includes one, which makes CRM matching much easier.

EU contracts. Set What to return to awards, pick Buyer countries (DE, DEU or Germany all work) and CPV codes. Winner countries filters by where the winning company is based, which is useful if you only sell in one territory.

Step 2: Schedule a daily onlyNew feed

Scheduled, the same inputs give you a list every morning with only the winners you have not seen yet.

Switch on onlyNew on each Actor. In the US Actor it is labelled Only awards not seen in previous runs, and the UK and EU Actors have the same option for records. The Actor keeps a list of the records it has already returned for your filters in a named key-value store in your Apify account. The next run skips them, and you are only charged for new records.
Keep a short rolling window with some overlap: daysBack 3 for the US, 2 for the UK, 3 for the EU (TED counts publishing days, Monday to Friday). The date window is not part of the memory, so the overlap catches late notices without sending anything twice.
Set the maximum records field (maxItems) to 0 (no limit) so a busy day is not cut short.
Save each input as a task. In Schedules, create one schedule, for example cron 0 7 * * 1-5 with timezone Europe/London, and add all three tasks to it.

Changing a filter starts a fresh history, so the first run after a change returns everything that matches again.

Step 3: Pull all three into one table with Python

If you would rather work from code, the official apify-client package can run the three tasks and merge the results into one CSV with the same columns. 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"])

FEEDS = {
    "agents001/us-federal-contract-awards": {
        "awardTypes": ["contracts"],
        "daysBack": 3,
        "naicsCodes": ["5415", "518210"],
        "minAwardAmount": 100000,
        "businessesOnly": True,
        "onlyNew": True,
        "maxItems": 0,
    },
    "agents001/uk-public-contracts-feed": {
        "mode": "awards",
        "daysBack": 2,
        "cpvCodes": ["72000000", "48000000"],
        "minValue": 50000,
        "onlyNew": True,
        "maxItems": 0,
    },
    "agents001/eu-ted-tenders-feed": {
        "mode": "awards",
        "daysBack": 3,
        "countries": ["DE", "FR", "NL", "IE"],
        "cpvCodes": ["72000000", "48000000"],
        "minValueEur": 100000,
        "onlyNew": True,
        "maxItems": 0,
    },
}


def to_row(actor_id, r):
    """Map each market's fields onto one set of columns."""
    if actor_id.endswith("us-federal-contract-awards"):
        return {
            "market": "US", "company": r["recipientName"], "companyId": r["recipientUei"],
            "country": r.get("recipientCountry"), "buyer": r.get("awardingSubAgency"),
            "value": r["awardAmount"], "currency": "USD", "code": r["naicsCode"],
            "date": r["actionDate"], "url": r["awardUrl"],
        }
    if actor_id.endswith("uk-public-contracts-feed"):
        return {
            "market": "UK", "company": r["supplierName"],
            "companyId": r.get("supplierCompaniesHouseNumber"),
            "country": r.get("supplierCountry"), "buyer": r["buyerName"],
            "value": r.get("value"), "currency": r.get("currency"), "code": r.get("mainCpvCode"),
            "date": r.get("awardDate"), "url": r["noticeUrl"],
        }
    return {
        "market": "EU", "company": r["winnerName"], "companyId": r.get("winnerIdentifier"),
        "country": r.get("winnerCountry"), "buyer": r["buyerName"],
        "value": r.get("valueEur"), "currency": "EUR", "code": r.get("mainCpv"),
        "date": r.get("awardDecisionDate") or r.get("publicationDate"), "url": r["noticeUrl"],
    }


rows = []
for actor_id, run_input in FEEDS.items():
    # Starts the run and waits for it to finish. Caps spend at $2 for this run.
    run = client.actor(actor_id).call(run_input=run_input, max_total_charge_usd=2)
    if run is None or run.status != "SUCCEEDED":
        print(f"{actor_id}: run did not succeed, skipping")
        continue
    for item in client.dataset(run.default_dataset_id).iterate_items():
        rows.append(to_row(actor_id, item))

with open("new_contract_winners.csv", "w", newline="") as f:
    writer = csv.DictWriter(f, fieldnames=list(rows[0]) if rows else ["market"])
    writer.writeheader()
    writer.writerows(rows)

print(f"{len(rows)} new winners saved")

call() returns None if the run could not be started or followed, so the check matters. iterate_items() pages through the dataset for you.

What the output looks like

These are real records from sample runs in October 2026, trimmed to the most useful fields.

A US award (NAICS 541519, other computer related services):

{
  "awardId": "1232SA27F0002",
  "awardType": "DELIVERY ORDER",
  "recipientName": "DSFEDERAL, INC",
  "recipientUei": "WHLSDNWNCGJ5",
  "recipientCity": "ROCKVILLE",
  "recipientState": "MD",
  "awardAmount": 2715265.2,
  "actionDate": "2026-10-21",
  "awardingAgency": "Department of Agriculture",
  "awardingSubAgency": "Agricultural Research Service",
  "naicsCode": "541519",
  "pscCode": "R499",
  "description": "GRANTS MANAGEMENT REPORTING SYSTEM (GMRS) APPLICATIONS DEVELOPMENT AND ENHANCEMENT SUPPORT",
  "awardUrl": "https://www.usaspending.gov/award/CONT_AWD_1232SA27F0002_12H2_47QTCA25D00DU_4732"
}

A UK award published under the Procurement Act 2023:

{
  "recordType": "award",
  "source": "findATender",
  "noticeId": "100750-2026",
  "noticeType": "UK7",
  "noticeTypeName": "Contract details notice",
  "legalFramework": "Procurement Act 2023",
  "title": "Lifts Servicing and Maintenance",
  "supplierName": "CALANDINE LIFTS LIMITED",
  "supplierCompaniesHouseNumber": "05541807",
  "supplierRegion": "East Midlands",
  "supplierSize": "sme",
  "buyerName": "NOTTINGHAM COMMUNITY HOUSING ASSOCIATION LIMITED",
  "mainCpvCode": "42416000",
  "mainCpvDescription": "Lifts, skip hoists, hoists, escalators and moving walkways",
  "value": 900000.0,
  "currency": "GBP",
  "awardDate": "2026-10-01",
  "noticeUrl": "https://www.find-tender.service.gov.uk/Notice/100750-2026"
}

An EU award, with the value converted to euros at the ECB reference rate:

{
  "recordType": "award",
  "noticeId": "736814-2026",
  "publicationDate": "2026-10-23",
  "cpvDescription": "Software programming and consultancy services",
  "mainCpv": "72200000",
  "buyerName": "Ministerstvo práce a sociálních věcí",
  "buyerCountry": "CZE",
  "value": 4620000,
  "currency": "CZK",
  "valueEur": 189912.44,
  "winnerName": "Aricoma Systems a.s.",
  "winnerCountry": "CZE",
  "winnerSize": "large",
  "winnersInNotice": 1,
  "awardDecisionDate": "2026-09-08",
  "noticeUrl": "https://ted.europa.eu/en/notice/-/detail/736814-2026"
}

A note on the UK Procurement Act 2023

The Procurement Act 2023 has been in force since 24 February 2025. Procurements started since then are published on Find a Tender with new notice types (UK6 for contract award notices, UK7 for contract details notices and so on) and a different legal basis from notices under the old regulations. Older procurements that are still running are published under the old rules, so for some years you will see both.

If you build your own client on the Find a Tender API, check the stages parameter. When it was tested on 23 October 2026, stages=award, stages=tender and stages=planning only returned notices under the old regulations and left out every Procurement Act 2023 notice. In a sample run of 500 recent UK award records, 317 came from Procurement Act notices, so that filter would have dropped most of them.

The Actor does not use that filter. It reads all stages and classifies each notice itself, and every record has a legalFramework field so you can see which regime it falls under. It also returns a win reported first in a contract award notice (UK6) and later in a contract details notice (UK7) only once.

What it costs

All three use pay-per-event pricing with platform usage included. You pay per record saved to your dataset. Records your filters drop are not charged. Prices below are per 1,000 records on the Free plan, and lower on paid Apify plans:

US awards: $3.00 per 1,000 award records, down to $1.50 on higher plans.
UK awards: $2.50 per 1,000 contract award records, down to $1.50. Open tenders, if you ask for them, are $2.00 per 1,000.
EU awards: $2.50 per 1,000 award records, down to $1.75. Open tenders are $1.50 per 1,000.

A filtered daily feed of 30 new US winners, 20 UK winners and 20 EU winners costs about $0.09 + $0.05 + $0.05, so roughly $0.19 a day or $4 over 21 working days on the Free plan prices. Set a maximum charge per run and the Actor stops cleanly when it is reached. Check each Store page for current pricing.

Send it to a CRM or a Google Sheet

You can connect each task in its Integrations tab.

Google Sheets: add the Google Sheets Import & Export Actor (lukaskrivka/google-sheets) as an Actor integration on the task, in append mode, so each morning's winners land under yesterday's.
CRM: use the Apify app in Zapier, Make or n8n. Trigger on a finished task run, fetch the dataset items, then create or update a company in HubSpot, Salesforce or Pipedrive. Use a stable key so you never create duplicates: recipientUei for US awards, supplierCompaniesHouseNumber for UK awards where it is filled, and noticeId plus winnerName for EU awards.
Email: the Gmail integration can send each run's dataset as an attachment.
Webhook: point a webhook at your own endpoint on the "run succeeded" event and fetch the dataset from there.

Limitations

Delays at source. Most US civilian contracts appear within a few days. Department of Defense contracts are published with a delay, so recent weeks show few DoD awards. Grants appear weeks after signing.
Values mean different things. US contract amounts are the amount obligated so far and can grow. UK and EU framework awards often state a ceiling shared by every supplier on the framework (valueShared in the UK, winnersInNotice in the EU).
Missing identifiers. Companies House numbers are present when the notice includes them. TED only ties a company number, country and size to a winner when the match is unambiguous, and roughly 1 EU award notice in 10 names no winner.
Coverage. The UK feed covers Find a Tender and Contracts Finder. Public Contracts Scotland, Sell2Wales and eTendersNI carry some notices that are not on those two services.
Privacy filters err on the side of removal, so a few small businesses with person-like names are left out.

Always check the official notice before acting on a record.

Try it

US federal contract awards: https://apify.com/agents001/us-federal-contract-awards
UK public contracts: https://apify.com/agents001/uk-public-contracts-feed
EU TED tenders and awards: https://apify.com/agents001/eu-ted-tenders-feed
Australian Government contracts (AusTender): coming soon

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