DEV Community: George Kioko

My Apify Promotion Filter: Scale Clean APIs, Hold Back Noisy Demand

George Kioko — Sun, 07 Jun 2026 04:05:11 +0000

I pulled a fresh read-only Apify Store check on June 6 after seeing revenue cool down from the better days earlier in the week.

The portfolio is not dead. The traffic is still moving:

63,720 total runs
2,532 total users
+426 runs since the last fresh read
+25 users since the last fresh read

The problem is not whether the actors exist. The problem is where the promotion is pointed.

When I promote the whole catalog, the message is too broad. A buyer does not wake up looking for "66 Apify actors." They wake up needing validated emails, YouTube transcripts, domain/company intelligence, local business lists, or a way to score prospects before outreach.

So today's rule is simple:

Promote the monetized actors that are reliable enough to absorb traffic.

Hold back the ones with demand but weak completion until they are repaired.

The Scale Lane

These are the actors I am comfortable putting in public today because the current 30-day Store stats show strong reliability.

Actor	Rolling 30d runs	30d success
Email Validator API	1,575	100%
Domain WHOIS Lookup	1,654	99.9%
YouTube Transcript Scraper	1,123	98.8%
Telegram Channel Scraper	861	98.6%
AI Content Detector	621	99.8%
Company Enrichment API	395	96.0%
Google News Monitor	232	100%

That list has two jobs.

First, it proves the portfolio is not just a batch of abandoned demos. These actors are getting used and completing at a level I can defend.

Second, it gives the buyer a clean entry point. A developer building an AI workflow can start with transcripts, enrichment, WHOIS, news monitoring, or validation without taking on the risk of a noisier scraper.

The Money Lane

The second lane is the buyer-outcome stack.

These actors are not the highest-volume tools in the catalog, but they map more directly to business value:

Actor	Rolling 30d result
HVAC Contractor Lead Finder	40/40 succeeded
Law Firm Lead Finder	35/35 succeeded
Dental Practice Lead Finder	31/31 succeeded
Google Maps Leads + Website Audit	29/29 succeeded
Google Maps Lead Intelligence	29/30 succeeded
Restaurant Lead Finder	33/34 succeeded

The pitch here is not "scrape a website."

The pitch is:

Find local businesses.
Score the website and digital presence.
Pull vertical-specific prospect lists.
Enrich the company data.
Validate emails before outreach.

That is a workflow an agency, consultant, or local sales team can understand.

The Hold-Back Lane

This is the part that matters if you care about revenue instead of vanity traffic.

Some actors have demand, but I do not want them as the main CTA today:

Actor	Current issue
TikTok Shop Affiliate Intelligence	84.0% 30d success
Google Scholar Scraper	80.1% 30d success
Reddit Scraper Pro	87.5% 30d success
Lead Enrichment Pipeline	65.6% 30d success
Influencer Marketing Intel	86.8% 30d success

Demand is useful. Broken demand burns trust.

If an actor has buyers but too many aborts, timeouts, or failures, the move is QA first and promotion second.

The Promotion Filter

This is the filter I am using today:

Scale anything above 95% 30-day success with meaningful use.
Use high-volume utility APIs as trust proof.
Put buyer-outcome lead actors in the main CTA.
Keep 90-95% actors in the careful lane.
Hold back anything under 90% until reliability improves.

That means the main public profile is still the best single entry point:

https://apify.com/george.the.developer

But the copy should not say "here are all my actors."

The copy should say:

Use the clean APIs for reliable data workflows.
Use the local lead stack when you need a buyer outcome.
Do not push noisy actors until the completion rate is fixed.

That is the playbook for today.

Stop Promoting a Scraper Catalog. Promote a Local Lead Research Stack.

George Kioko — Sat, 06 Jun 2026 05:41:14 +0000

I pulled a fresh read-only Apify Store check late on June 5.

The portfolio is moving:

66 public Store actors
63,294 total runs
2,507 total users
15,584 rolling 30-day runs
15,073 rolling 30-day successful runs

But the useful revenue lesson is not "post all the actors again."

The useful lesson is this:

Traffic and revenue are not the same thing. Utility actors can bring a lot of runs, but the bigger buyer intent is in the local lead stack.

The Local Lead Stack

This is the stack I am promoting harder now:

Google Maps Lead Intelligence
Google Maps Leads + Website Audit
HVAC Contractor Lead Finder
Law Firm Lead Finder
Dental Practice Lead Finder
Restaurant Lead Finder
Company Enrichment API
Email Validator API

That is a workflow, not a catalog.

For an agency, consultant, broker, or operator, the pitch is simple:

Find local businesses.
Score their websites.
Pull vertical-specific lead lists.
Enrich the companies.
Validate emails before outreach.

That is much clearer than saying "I have a bunch of scrapers."

Current Store Proof

The local lead actors are not the highest-volume actors in the portfolio, but they map to a buyer outcome.

Current Store stats from the June 5 read:

Actor	Rolling 30d runs	Success
HVAC Contractor Lead Finder	40	100%
Law Firm Lead Finder	35	100%
Dental Practice Lead Finder	31	100%
Google Maps Lead Intelligence	30	96.7%
Google Maps Leads + Website Audit	29	100%
Restaurant Lead Finder	34	97.1%

The support actors make the stack more useful:

Actor	Rolling 30d runs	Success
Email Validator API	1,507	100%
Domain WHOIS Lookup	3,054	100%
YouTube Transcript Scraper	1,100	98.7%
Telegram Channel Scraper	857	98.6%
Company Enrichment API	606	97.4%
Google News Monitor	239	100%

Why This Works Better Than a Catalog

A catalog asks the buyer to think.

A stack gives them a path.

"Here are 65 paid actors" is broad, but broad is not always helpful.

"Here is a local lead research stack for finding, scoring, enriching, and validating prospects" is specific. It tells the buyer what job the tools do.

Example Workflow

Start with a market:

dentists in Austin
law firms in Atlanta
HVAC contractors in Phoenix
restaurants in Miami

Then run the stack:

Use a vertical lead finder or Google Maps actor to find businesses.
Use the website audit actor to inspect digital presence.
Use Company Enrichment API to add firmographic details.
Use Email Validator API before sending outreach.

The buyer does not care that this is a scraper portfolio. They care that it helps build a prospecting list.

Quick Start With Apify Client

import { ApifyClient } from 'apify-client';

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

const run = await client.actor('george.the.developer/law-firm-lead-finder').call({
  searchQuery: 'personal injury law firms in Atlanta GA',
  maxResults: 100,
  enrichWebsites: true,
  validateEmails: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.slice(0, 3));

Check each actor's input schema before running at scale. The important idea is the stack: discovery, audit, enrichment, validation.

What I Am Holding Back

Some monetized actors still have demand, but I am not putting them in the main cash CTA until reliability improves:

TikTok Shop Affiliate Sales Scraper
Google Scholar Scraper
Lead Enrichment Pipeline
Reddit Scraper Pro
Influencer Marketing Intel

Demand is useful. Broken demand burns trust.

Links

Full Apify profile:

https://apify.com/george.the.developer

Local lead actors:

Quiet Apify Store Day? Promote the Actors That Complete, Not the Ones That Need Repair

George Kioko — Thu, 04 Jun 2026 07:59:18 +0000

Revenue days do not always move in a clean line.

On June 4, my public Apify Store read was flat versus June 3: 65 active pay-per-event actors, 62,169 all-time monetized runs, 2,424 all-time users, 16,945 rolling 30-day public runs, and a 96.7% rolling 30-day success rate. That does not mean the portfolio is dead. It means the promotion lane has to get narrower.

When the Store is quiet, I do not promote every actor equally. I split the portfolio into three groups:

buyer-outcome actors that solve a direct cash problem
utility APIs that run cleanly and can sit inside someone else's workflow
actors that need QA before they deserve harder promotion

That keeps the message honest and gives buyers a cleaner path to the tools that are ready today.

The buyer-outcome lane

These are the actors I promote when the goal is direct revenue. They are not abstract data tools. They map to sales, outreach, lead generation, or market research work that a buyer can monetize.

Law Firm Lead Finder

Use this when you need a repeatable list of law firms for outreach, local lead generation, or agency research.

Public Store stats from today's read:

33 rolling 30-day runs
33 successful rolling 30-day runs
100% rolling 30-day success

Store link: https://apify.com/george.the.developer/law-firm-lead-finder

Dental Practice Lead Finder

Dental offices are a good fit for local SEO, ads, review management, and appointment-setting offers. This actor is built for that kind of prospecting workflow.

Public Store stats from today's read:

30 rolling 30-day runs
30 successful rolling 30-day runs
100% rolling 30-day success

Store link: https://apify.com/george.the.developer/dental-practice-lead-finder

Google Maps Leads + Website Audit

This is useful when a raw business list is not enough. The extra website audit angle helps separate weak digital presence from stronger prospects.

Public Store stats from today's read:

29 rolling 30-day runs
29 successful rolling 30-day runs
100% rolling 30-day success

Store link: https://apify.com/george.the.developer/google-maps-leads-website-audit

Restaurant Lead Finder

Restaurants are another direct outreach lane: websites, ordering flows, local ads, review systems, delivery tooling, and marketing services.

Public Store stats from today's read:

34 rolling 30-day runs
33 successful rolling 30-day runs
97.1% rolling 30-day success

Store link: https://apify.com/george.the.developer/restaurant-lead-finder

The utility API lane

These are not always flashy, but they are exactly the kind of actors that can become embedded in other products, agents, dashboards, and internal workflows.

Email Validator API

Use this before cold outreach, CRM imports, signup checks, or enrichment workflows. It covers email validation, disposable detection, and MX-related checks in one API-style actor.

Public Store stats from today's read:

1,371 rolling 30-day runs
1,371 successful rolling 30-day runs
100% rolling 30-day success

Store link: https://apify.com/george.the.developer/email-validator-api

Domain WHOIS Lookup

Domain age, expiry, registrar, and DNS details are useful for lead scoring, fraud checks, market maps, and due diligence tools.

Public Store stats from today's read:

5,007 rolling 30-day runs
5,007 successful rolling 30-day runs
100% rolling 30-day success

Store link: https://apify.com/george.the.developer/domain-whois-lookup

YouTube Transcript Scraper

This is a strong utility actor for AI builders, content teams, research workflows, and RAG pipelines that need transcript data without managing a custom scraper.

Public Store stats from today's read:

1,085 rolling 30-day runs
98.8% rolling 30-day success
28 users in the last 7 days

Store link: https://apify.com/george.the.developer/youtube-transcript-scraper

Telegram Channel Scraper

Good fit for market monitoring, community intelligence, crypto research, and niche data feeds where Telegram content matters.

Public Store stats from today's read:

861 rolling 30-day runs
98.8% rolling 30-day success
7 users in the last 7 days

Store link: https://apify.com/george.the.developer/telegram-channel-scraper

Company Enrichment API

This one is for turning a domain or company target into a richer company profile for sales workflows, prospect research, and internal tools.

Public Store stats from today's read:

599 rolling 30-day runs
97.3% rolling 30-day success
12 users in the last 7 days

Store link: https://apify.com/george.the.developer/company-enrichment-api

Google News Monitor

This fits brand monitoring, market alerts, competitor tracking, and lightweight news intelligence.

Public Store stats from today's read:

270 rolling 30-day runs
270 successful rolling 30-day runs
100% rolling 30-day success
8 users in the last 7 days

Store link: https://apify.com/george.the.developer/google-news-monitor

The hold-back lane

Some actors are still monetized, but I do not want to push them hard until the reliability story is stronger.

Today that hold-back list includes:

TikTok Shop Affiliate Sales Scraper
Google Scholar Scraper
HVAC Contractor Lead Finder
Lead Enrichment Pipeline
Reddit Scraper Pro
Influencer Marketing Intel
Medspa Lead Discovery

That does not mean those actors are worthless. It means they should get QA, better docs, or tighter inputs before they become the main public pitch.

Quick start with any Apify actor

Here is the basic Node.js pattern:

import { ApifyClient } from 'apify-client';

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

const run = await client.actor('george.the.developer/youtube-transcript-scraper').call({
  urls: ['https://www.youtube.com/watch?v=dQw4w9WgXcQ'],
  language: 'en',
  outputFormat: 'both',
});

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

Swap the actor ID and input for the lane you are using.

My practical rule

When revenue drops, do not blast the whole catalog.

Promote the actors that already complete cleanly. Send buyer traffic to tools with a direct use case. Keep the weaker actors in a repair lane until the public numbers support a harder push.

Full Apify profile: https://apify.com/george.the.developer

Revenue Falling? Promote the Paid Apify Actors That Actually Complete

George Kioko — Wed, 03 Jun 2026 09:22:23 +0000

When revenue dips, the tempting move is to promote everything.

That is usually the wrong move. A scraper portfolio is not one product. It is a collection of separate reliability profiles, buyer intents, prices, and failure risks. If you blast the entire catalog, you send new users into actors that may not be ready for more traffic.

This morning I pulled a fresh read-only Apify Store API snapshot for my paid actor portfolio. I looked only at active PAY_PER_EVENT actors and compared the result against yesterday's snapshot.

The current snapshot:

65 active paid actors
62,169 all-time runs across those paid actors
2,424 all-time users
16,945 rolling 30-day public runs
96.7% rolling 30-day public success
+965 total runs since yesterday
+74 total users since yesterday

This is public Store and run-quality signal, not exact Console payout attribution. That distinction matters. The public API can tell me what is moving and what is completing, but it cannot replace the payout dashboard.

The Actors I Am Promoting Today

These are the actors with either clean completion rates, fresh movement, or direct buyer utility.

Email Validator API

Fresh movement: +137 runs since yesterday with 100% rolling 30-day success.

Use it before cold outreach, lead imports, CRM cleanup, or newsletter sends:

https://apify.com/george.the.developer/email-validator-api

AI Content Detector

Fresh movement: +115 runs since yesterday with 99.8% rolling 30-day success.

Use it when you need a lightweight AI-text signal for moderation, publishing workflows, or audit queues:

https://apify.com/george.the.developer/ai-content-detector

YouTube Transcript Scraper

Fresh movement: +59 runs since yesterday, 98.8% rolling 30-day success, and 28 users in the last 7 days.

Use it for RAG pipelines, content analysis, creator research, video summaries, and training-data prep:

https://apify.com/george.the.developer/youtube-transcript-scraper

Telegram Channel Scraper

Fresh movement: +58 runs since yesterday with 98.8% rolling 30-day success.

Use it for market intel, community monitoring, crypto research, public-channel tracking, and message archiving:

https://apify.com/george.the.developer/telegram-channel-scraper

Company Enrichment API

Fresh movement: +28 runs since yesterday with 97.3% rolling 30-day success.

Use it to turn domains into company records for lead routing, qualification, prospect research, or internal enrichment:

https://apify.com/george.the.developer/company-enrichment-api

Google News Monitor

Fresh movement: +19 runs since yesterday with 100% rolling 30-day success.

Use it for brand monitoring, competitor alerts, executive mentions, product-news tracking, or regulatory/news watchlists:

https://apify.com/george.the.developer/google-news-monitor

The Buyer-Outcome Lane

High-volume utilities are useful, but the revenue pressure is not solved by tiny utility events alone. The more interesting lane is completed-search work where the buyer gets a business artifact.

Today that means:

Law Firm Lead Finder: 33/33 successful rolling 30-day runs
Dental Practice Lead Finder: 30/30 successful rolling 30-day runs
Google Maps Lead Intel: 29/29 successful rolling 30-day runs
Restaurant Lead Finder: 33/34 successful rolling 30-day runs

Those actors are for buyers who want lead lists, local market research, or prospect intelligence without building a custom scraper.

Law Firm Lead Finder:

https://apify.com/george.the.developer/law-firm-lead-finder

Dental Practice Lead Finder:

https://apify.com/george.the.developer/dental-practice-lead-finder

Google Maps Lead Intel:

https://apify.com/george.the.developer/google-maps-lead-intel

Restaurant Lead Finder:

https://apify.com/george.the.developer/restaurant-lead-finder

What I Am Not Hard-Promoting Today

Some actors have demand but do not deserve extra traffic until reliability improves.

My current hold-back list:

Google Scholar Scraper
TikTok Shop Affiliate Sales Scraper
HVAC Contractor Lead Finder
Lead Enrichment Pipeline
Reddit Scraper Pro
Influencer Marketing Intel
US Tariff Lookup
MedSpa Lead Discovery PPE

The issue is not that these are bad ideas. The issue is that current rolling quality shows enough failed, aborted, or timed-out runs that promotion could create a worse buyer experience.

The Operating Rule

Do not promote the whole catalog.

Split the portfolio into three lanes:

Scale lane: reliable actors with clean completion rates and real recent movement.
Buyer-outcome lane: lower-volume actors with a clear business result.
Fix-first lane: actors with demand but too much run-quality risk.

That is how I am handling the portfolio today.

Full catalog:

https://apify.com/george.the.developer

Humanize AI Text at Scale Without Paying for Another LLM Call

George Kioko — Sat, 30 May 2026 05:33:37 +0000

LLMs are good at producing a first draft. They are also good at producing the same first draft over and over.

The problem is not that the grammar is wrong. The problem is that AI text often has a recognizable texture: uniform sentence length, too many transition phrases, overly clean structure, low burstiness, and phrasing that sounds like it came from a template.

For content teams, SEO operators, newsletter writers, agencies, and AI-agent builders, that creates a last-mile problem. You can generate the draft quickly, but you still need it to sound natural before publishing, sending, or handing it to a client.

That is where a humanization step belongs.

The Problem

Most "make this sound human" workflows call another LLM. That can work, but it adds new costs and new failure modes:

Another API call for every piece of text.
Possible meaning drift.
Slower bulk processing.
External model rate limits.
Harder cost control.
Less predictable output.

If you are building a content pipeline, those tradeoffs matter. A rewrite step should be fast, cheap, and stable enough to run automatically after the draft is generated.

The goal is not to hide bad work. The goal is to turn a robotic first draft into text that reads like a person edited it.

The Solution

AI Text Humanizer API on Apify applies a deterministic humanization pipeline instead of routing the text through another LLM.

It supports:

12 transform passes for phrase cleanup, rhythm changes, sentence variation, and final polish.
Five writing styles: casual, professional, academic, creative, and technical.
Three humanization levels: light, medium, and heavy.
Before-and-after AI detection scoring.
Bulk processing for up to 20 texts per request.
A Standby HTTP API for real-time integrations.
Standard Apify actor runs for batch workflows.

Actor link: https://apify.com/george.the.developer/ai-text-humanizer-api

Quick Start

Run it directly on Apify with this input:

{
  "text": "Furthermore, it is important to note that artificial intelligence has significantly impacted the landscape of modern technology.",
  "style": "casual",
  "aggressiveness": "medium",
  "preserveMeaning": true
}

The output includes the original text, humanized text, length changes, settings, removed AI phrases, and detection scores before and after the rewrite.

Code Example

Standby API request

const response = await fetch(
  'https://george-the-developer--ai-text-humanizer-api.apify.actor/humanize',
  {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      Authorization: `Bearer ${process.env.APIFY_TOKEN}`,
    },
    body: JSON.stringify({
      text: 'Furthermore, it is important to note that AI has revolutionized content production for modern teams.',
      style: 'professional',
      aggressiveness: 'medium',
      preserveMeaning: true,
    }),
  }
);

const result = await response.json();

console.log(result.humanized);
console.log(result.detection);

Standard Apify actor run

import { ApifyClient } from 'apify-client';

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

const run = await client.actor('george.the.developer/ai-text-humanizer-api').call({
  text: 'In conclusion, leveraging robust solutions provides a comprehensive advantage for organizations.',
  style: 'casual',
  aggressiveness: 'medium',
  preserveMeaning: true,
});

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

console.log(items[0].humanized);

Bulk processing

const response = await fetch(
  'https://george-the-developer--ai-text-humanizer-api.apify.actor/humanize/bulk',
  {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      Authorization: `Bearer ${process.env.APIFY_TOKEN}`,
    },
    body: JSON.stringify({
      texts: [
        { text: 'First AI-generated paragraph...', style: 'casual' },
        { text: 'Second AI-generated paragraph...', style: 'professional' },
        { text: 'Third AI-generated paragraph...', style: 'technical' },
      ],
      aggressiveness: 'medium',
    }),
  }
);

const { results } = await response.json();
console.log(results.map((item) => item.humanized));

What the Output Gives You

A humanization API is more useful when it returns more than rewritten text.

This actor returns a before-and-after view:

{
  "original": "Furthermore, it is important to note that...",
  "humanized": "It is worth noting that...",
  "originalLength": 142,
  "humanizedLength": 98,
  "detection": {
    "before": { "score": 87, "verdict": "ai_generated" },
    "after": { "score": 31, "verdict": "likely_human" },
    "improvement": 56
  },
  "settings": {
    "style": "casual",
    "aggressiveness": "medium",
    "preserveMeaning": true
  }
}

That makes the tool easier to automate. You can reject weak rewrites, retry with heavy, or route content to manual review when the score does not improve enough.

Use Cases

AI content pipelines

Generate a first draft with an LLM, then run the output through the humanizer as the final editing step before publishing.

SEO content operations

Turn structured outlines and AI drafts into copy with more natural sentence rhythm, fewer repeated transitions, and less template-like phrasing.

Agency deliverables

Agencies can standardize the last-mile editing step across blog posts, product descriptions, newsletters, and client reports.

Email and LinkedIn copy

Cold messages that sound like an AI template get ignored quickly. Use a lighter style pass to make generated copy less stiff before it enters an outreach workflow.

AI agent output

If an agent writes summaries, reports, or recommendations, add humanization before the final response is saved, emailed, or posted.

Pricing

AI Text Humanizer API uses Pay Per Event pricing:

$0.003 per text humanized.
100 texts cost $0.30.
1,000 texts cost $3.00.
10,000 texts cost $30.00.

Detection-only requests are free according to the actor documentation. Bulk humanization charges per text.

Style Guide

Use casual for blog posts, social copy, newsletters, and everyday writing.

Use professional for LinkedIn posts, client reports, sales copy, and business communication.

Use academic for research-adjacent writing where the tone needs to stay formal.

Use creative for storytelling, brand copy, and more expressive articles.

Use technical for documentation, API guides, and engineering writing where precision matters.

For aggressiveness:

Start with medium.
Use light when preserving structure is more important than changing tone.
Use heavy when the original draft is highly formulaic.

FAQ

Is this another GPT wrapper?

No. The actor documentation describes it as a deterministic transform pipeline with no external API calls.

Does it preserve meaning?

The input schema includes preserveMeaning, and it defaults to true. For sensitive content, still review the output before publishing.

Can I process multiple texts at once?

Yes. The bulk endpoint supports up to 20 texts per request.

Can I only run AI detection?

Yes. The actor includes detection endpoints for checking text without humanizing it.

Should I use this to misrepresent authorship?

No. Treat it like an editing tool. It is best used to improve drafts you are responsible for, not to hide dishonest or low-quality work.

Get Started

Run AI Text Humanizer API on Apify:

https://apify.com/george.the.developer/ai-text-humanizer-api

Use it as a final polish step in content pipelines, AI agents, agency workflows, and automated publishing systems.

Validate Emails Before Cold Outreach: MX, SMTP, and Disposable Checks in One API

George Kioko — Sat, 30 May 2026 05:33:12 +0000

Cold outreach fails faster when the email list is dirty.

It is not only the obvious typos. A list can be full of addresses that look valid but point to domains with no mail servers, disposable inboxes, free providers that do not match a B2B campaign, role-based inboxes like info@ or support@, and mailboxes that reject SMTP delivery.

If you send to those addresses, you pay for the mistake twice. First you waste credits in the sending tool. Then you damage the sender reputation you need for the next campaign.

The better workflow is simple: validate before you send.

The Problem

Most prospecting workflows treat email validation as a cleanup step at the end. That is backwards.

By the time a bad email reaches the final CSV, it may already be attached to a CRM record, an outreach sequence, a lead score, or an automation rule. Removing it later creates a second data-cleaning job.

The real goal is not "check if this string has an at sign." The real goal is to answer practical questions before the email ever gets used:

Is the email formatted correctly?
Does the domain have MX records?
Is the address from a disposable provider?
Is it a role-based inbox?
Is it a free provider instead of a company domain?
Does the SMTP server accept the mailbox?
Should this lead be sent, reviewed, or discarded?

That is the job of an email validation API.

The Solution

Email Validator API on Apify validates addresses with a five-layer pipeline:

Format validation.
Disposable or temporary domain detection.
Role-based inbox detection.
MX record lookup.
SMTP mailbox verification.

The actor also returns a 0-100 confidence score, domain-level flags, MX records, and the reason behind the result. That makes it useful for more than a pass/fail check. You can use the output to route leads into different follow-up paths.

For example:

valid=true and score >= 60: safe to keep.
is_disposable=true: remove before CRM import.
is_free=true: keep for consumer campaigns, review for B2B.
is_role_based=true: useful for company contact, weak for personal outreach.
mx_found=false: discard or enrich from another source.

Actor link: https://apify.com/george.the.developer/email-validator-api

Quick Start

Use the Apify Store page to run it directly:

Open the actor on Apify.
Enter one email, or pass an emails array for a batch.
Choose validate, disposable, or bulk.
Run the actor and export the dataset as JSON, CSV, Excel, or through the Apify API.

The input schema supports:

{
  "mode": "bulk",
  "emails": [
    "founder@company.com",
    "sales@gmail.com",
    "fake@mailinator.com"
  ]
}

For real-time API use, copy the actor's Standby URL from Apify and call the HTTP endpoints directly.

Code Example

Batch validation with Standby

const standbyUrl = process.env.EMAIL_VALIDATOR_STANDBY_URL;

const response = await fetch(`${standbyUrl}/validate/bulk`, {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    emails: [
      'founder@company.com',
      'sales@gmail.com',
      'fake@mailinator.com',
    ],
  }),
});

const { results } = await response.json();

const cleanList = results.filter((item) =>
  item.valid &&
  item.score >= 60 &&
  !item.is_disposable
);

console.log(cleanList);

If your Standby endpoint requires authentication, add an Apify bearer token from an environment variable:

headers: {
  'Content-Type': 'application/json',
  Authorization: `Bearer ${process.env.APIFY_TOKEN}`,
}

Standard Apify actor run

import { ApifyClient } from 'apify-client';

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

const run = await client.actor('george.the.developer/email-validator-api').call({
  mode: 'bulk',
  emails: [
    'founder@company.com',
    'sales@gmail.com',
    'fake@mailinator.com',
  ],
});

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

const sendable = items.filter((item) =>
  item.valid &&
  item.score >= 60 &&
  !item.is_disposable
);

console.log(sendable);

Example Output

{
  "email": "hello@stripe.com",
  "valid": true,
  "format_valid": true,
  "mx_found": true,
  "smtp_check": "valid",
  "is_disposable": false,
  "is_free": false,
  "is_role_based": true,
  "domain": "stripe.com",
  "score": 90,
  "reason": "Valid email address"
}

That output is structured enough to plug straight into a lead scoring workflow.

Use Cases

Clean a scraped lead list

If you scrape websites, directories, or company pages, validate emails before pushing them to a CRM. Keep valid business emails, flag free-provider emails, and remove disposable inboxes.

Protect cold email deliverability

High bounce rates are expensive. Run new prospects through validation before they enter an outreach sequence, then route risky addresses into manual review.

Block disposable signups

For SaaS forms, waitlists, and gated content, use disposable detection to block temporary inboxes before they become low-quality accounts.

Score B2B leads

An email from a company domain is usually stronger than a free-provider address for B2B outbound. The API returns is_free, is_role_based, and domain, so you can add those signals to your score.

Audit old CRM records

Old lead databases decay. Run stale records through the validator before reactivation campaigns so you do not wake up a list with avoidable bounces.

Pricing

Email Validator API uses Pay Per Event pricing:

$0.002 per email validated.
100 emails cost $0.20.
1,000 emails cost $2.00.
10,000 emails cost $20.00.

Bulk requests charge per email in the batch. The current input schema supports up to 50 emails per bulk request.

FAQ

Does this only check email syntax?

No. Syntax is just the first layer. The API also checks disposable domains, role-based inboxes, MX records, SMTP response, free-provider status, and a confidence score.

Can I use it without writing code?

Yes. Run the actor from Apify, paste one email or a JSON array, and export the dataset when the run finishes.

Can I use it in a real-time app?

Yes. The actor supports Standby mode, so you can call HTTP endpoints such as /validate, /disposable, and /validate/bulk.

Should I remove every role-based address?

Not always. info@, sales@, and support@ can still be useful for general company contact. They are weaker for personalized outbound, so the best move is to route them differently instead of treating them like personal inboxes.

What should my minimum score be?

Start with valid=true, score >= 60, mx_found=true, and is_disposable=false. Tighten the rule if you are protecting a high-value sending domain.

Get Started

Run Email Validator API on Apify:

https://apify.com/george.the.developer/email-validator-api

Use it before a campaign, before CRM import, or directly inside a lead generation pipeline.

Seven new Apify actors in two days: healthcare, AI infra, GovCon, real estate

George Kioko — Thu, 14 May 2026 01:01:06 +0000

Seven new Apify actors in two days

Two day sprint. Codex did the per-actor source code, I orchestrated and verified each one against real data. All seven live on Apify Store. Pay per event pricing activates 2026-05-26.

Each one targets a specific buyer category with a real budget. Not generic scrapers, not toy demos. Numbers on what each one does and which buyers should care.

1. Hospital Price Transparency MRF Normalizer

Store link

CMS enforcement of the hospital price transparency rule tightened in April 2026. Every US hospital publishes a machine readable file of negotiated rates by payer and procedure, but the files are gigantic and inconsistent. CMS v2 JSON, CMS v3 JSON, CSV with column drift between hospitals.

This actor wraps the parsing into one Standby API. Detects format automatically (gzip, JSON, CSV), streams the file, normalizes each row to one schema with payer, plan, billing code, code type, negotiated rate, methodology, expiration date.

Pricing: $0.50 per start, $0.002 per rate row, $0.02 per provider procedure payer bundle.

Verified live test: Cooper University Hospital CSV returned 13 normalized rows including Aetna Better Health at code 0042T (HCPCS) for $272.44 negotiated.

Buyers: health cost transparency platforms (Amino, Cedar, Healthcare Bluebook), employer benefits tools (Castlight, Garner, Transcarent), TPA and PPO operators (Zelis, MultiPlan).

2. MCP Server Registry and Security Scorer

Store link

Anthropic Model Context Protocol exploded past 22,000 servers indexed on Glama. Agent platforms admitting MCP servers do it by README and stars and hope.

This actor joins the official Anthropic registry with npm package metadata (downloads, first published date, maintainer count), GitHub repo data (stars, archived, last commit, open issues), and produces a deterministic risk score per server. Signals: missing repo, archived, stale 90 days, unknown publisher, no license, weird tool count, registered but never built, single maintainer npm, advisory match.

Score lands 0 to 100 in bands low, medium, high, critical. Same input always returns same score, no LLM in the loop.

Pricing: $0.50 per start, $0.025 per server profile, $0.15 per full security scan.

Verified live test: ac.inference.sh/mcp server flagged risk 70 (high) because no repo link, no license, unknown publisher, remote only transport.

Buyers: agent platform admission control (Docker MCP Toolkit, Cursor, Continue, Windsurf), enterprise AI governance teams, MCP marketplace ranking signals, dev tool risk dashboards.

3. FDA Warning Letter and Enforcement Monitor

Store link

FDA published warning letters on a static index page that everyone in regulated industries needs to read but nobody wants to scrape. The April 2026 GLP-1 and telehealth enforcement push made this even more urgent.

This actor pulls the full letter feed, classifies each letter by topic (GLP-1, telehealth, compounding, manufacturing, biologics, food, advertising, dietary supplement), extracts the recipient company and product line, and rolls everything up into a company level risk brief with letter count, topic mix, time since last letter, and severity signals.

Pricing: $1 per start, $0.30 per letter, $1.50 per company risk brief.

Verified live test: CareFusion 213 LLC returned risk band "high" with 4 open enforcement actions tied to manufacturing.

Buyers: FDA consultants (Redica, Greenleaf Health, ProPharma, RQM Plus, The FDA Group), pharma QA SaaS (AssurX, Sparta, Kneat), med-device legal, telehealth ops.

4. Clinical Trial Investigator and Site Intelligence

Store link

CROs and sponsors at any scale rebuild the same data join for every new study. ClinicalTrials.gov plus NPI Registry plus OpenPayments plus PubMed publication count plus geo cluster of sites. The data is public, the join is mechanical, but everyone rebuilds it in a half maintained Python script.

This actor wraps the join into one Standby API. Query by condition or NCT id, get investigator profiles with NPI, OpenPayments dollar totals by company, publication counts, trial history broken down by phase, and a deterministic site fit score for each location.

Pricing: $1 per start, $0.10 per investigator profile, $0.50 per site fit row.

Verified live test: glioblastoma phase 2 query returned Thomas J Kaley MD at Memorial Sloan Kettering with NPI 1578721858, full therapeutic area list, and complete trial history.

Buyers: top 5 CROs (IQVIA, ICON, Parexel, Medidata, Veeva), clinical site networks (Advarra, Clinitiative), patient recruitment platforms (LINEA), sponsor BD teams.

5. Federal Contract Opportunity Monitor

Store link

SAM.gov publishes federal contract opportunities hourly. USAspending publishes awarded contracts with recipient data. Joining them and tagging by topic is the daily grind for federal sales teams and GovCon advisors. Bloomberg Government and Govini do this at enterprise pricing.

This actor pulls SAM.gov internal search (no API key required) plus USAspending POST endpoint, normalizes both into one schema, tags opportunities by topic keyword (configurable per user), and produces partnership leads: which prime contractors won similar work recently and at what value.

Pricing: $1 per start, $0.10 per opportunity, $0.50 per partnership lead.

Verified live test: /leads?keyword=consulting&awarded_amount_min=100000 returned General Dynamics IT with 2 recent awards totaling $1.7 billion, lead band "priority", top buying agency Department of State.

Buyers: GovCon advisors (Govini, Deltek, EZGovOpps), federal sales teams at MSPs and consulting firms, subcontract introduction services, state and local procurement intel.

6. LLM Provider Price and Latency Monitor

Store link

LLM gateways and agent platforms route across 5 to 10 providers. Pricing changes weekly. OpenRouter aggregates in a UI but does not publish it as a clean JSON ingestion feed. Most teams maintain their own scraper.

This actor wraps OpenRouter as canonical (200+ models, no auth), falls back to scraping OpenAI, Anthropic, Together, and Groq pricing pages when a model is missing, and returns a normalized snapshot per model with prompt and completion price per 1M tokens, context length, capability flags (vision, tools, JSON mode), and provider routing list.

A second endpoint produces cross provider benchmark rows: same model family, multiple providers, cost per 1k chat pair, multiplier from cheapest to most expensive.

Pricing: $0.50 per start, $0.025 per model snapshot, $0.15 per benchmark row.

Verified live test: /models?provider=anthropic&limit=3 returned 3 Anthropic models with full pricing populated. Benchmark endpoint returned 2 cross provider rows with cheapest_provider field.

Buyers: LLM gateway operators (Portkey, Helicone, LiteLLM), agent platform model admission, FinOps cost per task budgeting, AI engineering team weekly digests.

7. Multi City Building Permit Aggregator

Store link

Each US city publishes building permit data in its own JSON shape. NYC moved their authoritative feed from the old DOB Issuance dataset to DOB NOW in 2024 and broke every scraper that hardcoded the old IDs.

This actor wraps NYC and Chicago open data portals into one schema. Per permit you get permit type, status, work type, estimated cost, address with GPS, ZIP, block lot, builder business name, builder license, property business name. A second endpoint produces a builder activity roundup for any business name.

Pricing: $1 per start, $0.05 per permit row, $0.30 per builder activity roundup.

Verified live test: COSTELLO CONSTRUCTION roundup returned 88 permits over 3 years for $3 million total value, top property businesses served (Flushing Hospital Medical Center, Jerome Avenue SM Realty LLC), top permit types, top ZIP codes, activity tier "high volume".

Buyers: construction supply distributors planning territories, contractor SaaS lead enrichment (ServiceTitan, Jobber, Buildertrend), real estate investor research, market research firms.

What activation looks like

Pricing activates 2026-05-26 for the first 5 actors and 2026-05-27 for the last 2. Until then runs are free for testers who want to validate the schema.

If any of the buyer categories above describes your work, drop a free trial test at the contact info in each Store listing. Sample data on one company or condition of your choice gets returned within the day.

If you want to follow what each actor earns at first activation, the monthly digest goes out via @ai_in_it on X and the apify-actor-portfolio repo.

George
george.the.developer on Apify

Source and verification reports: github.com/the-ai-entrepreneur-ai-hub/apify-actor-portfolio.

I built a $0.002 email validator because ZeroBounce was killing my margins on a freelance gig

George Kioko — Tue, 05 May 2026 20:47:08 +0000

A client paid me a fixed fee to clean a 47k email list. Sounded fine on paper. Then I priced the verification step.

ZeroBounce minimum is 2,000 credits for $39, so $0.0195 per email at the cheapest pay-as-you-go rate. Their subscription gets you to about $0.0099 per email at 10k volume. For my 47k list that is $462 PAYG or $235 if I commit to a monthly plan I will not need next month. The freelance fee was a flat number. The math was getting ugly.

I have an Apify account and a small list of standby actors that bill per call. So I went to check what an SMTP MX validator actually costs to run.

What is in a real validation

If you scope it tight there are five checks that catch most of the garbage:

RFC 5322 syntax (regex on the local part and domain).
Disposable domain list (Mailinator, 10MinuteMail, 1.4k entries that move slowly).
Free provider tag (Gmail, Yahoo, etc, useful for B2B scoring not deliverability).
MX record lookup via DNS.
Optional SMTP handshake that opens a TCP connection to the MX host on port 25 and reads the banner. No data sent.

The first four are local computation. Microseconds. The SMTP step is the only thing that costs a network round trip and most ISPs will give you a clean answer in under 2 seconds.

The actor

I wrote it as a standby HTTP server on Apify. One endpoint, JSON in, JSON out. Billed per email via Actor.charge. Pay only on a successful return.

curl -X POST 'https://george-the-developer--email-validator-api.apify.actor/?token=YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"email":"someone@somewhere.com"}'

Returns:

{
  "email": "someone@somewhere.com",
  "valid_syntax": true,
  "is_disposable": false,
  "is_free": false,
  "mx_records": ["mail.somewhere.com"],
  "smtp_check": "deliverable",
  "score": 0.95
}

Per call cost is $0.002. For my 47k list that came out to roughly $94 of compute, not $462. The shape of the gig changed.

Architecture

flowchart LR
  Client[Client API call] --> Standby[Apify Standby Actor]
  Standby --> Syntax[RFC 5322 check]
  Syntax --> Disposable[Disposable domain list]
  Disposable --> MX[DNS MX lookup]
  MX --> SMTP[SMTP handshake on :25]
  SMTP --> Charge[Actor.charge per email]
  Charge --> Resp[(JSON response)]

What it does not do

I want to be honest about scope. It does not do role-based detection beyond a simple list of info@, support@, sales@, etc. It does not do toxicity scoring or abuse history, that needs a paid feed. It does not catch every catch-all domain, which is a known industry problem and not solvable with public DNS alone. ZeroBounce charges more partly because they aggregate proprietary signals from their customer base. Worth it if you are validating cold lists for cold outreach. Less worth it if you are cleaning a list of people who already opted in.

Per call vs flat subscription

The shape that bugged me about SaaS validators is the cap. You pay $79 a month and you get a fixed bucket of credits. If your usage is bursty (one client every few weeks) most of that bucket evaporates. If your usage is steady the math works out. But solo and freelance work is bursty by definition. Per call billing matches the work. No cap, no commitment, just a number per email.

Numbers from the gig

47,219 emails through the actor. Run completed in 38 minutes on the lowest memory tier. About 3.1k emails came back as undeliverable, 1.2k as disposable, 41.5k as deliverable. The client took the cleaned list and ran their own send. I did not have to think about a credit pool.

When this is the wrong call

If you are running enterprise email marketing at 10M sends a month, ZeroBounce or NeverBounce or Bouncer probably fit you. They have account managers, SLA contracts, GDPR paperwork. I am one developer with an Apify account. If you need that other thing, go pay for it.

If you are a freelancer cleaning a list, or a small agency that runs verification once a month, per call billing solves your specific problem.

Try it

Actor is at apify.com/george.the.developer/email-validator-api. Free to try if you have an Apify account, billed per call. Source for the docs and curl examples is at github.com/the-ai-entrepreneur-ai-hub/email-validator-api-docs (I keep the actor itself private but the call surface is documented).

If anyone has run into the same SaaS-cap problem with their own freelance gigs, would love to hear what you ended up using.

Originally published on Hashnode.

4 days to lock in current LinkedIn scraper pricing

George Kioko — Fri, 01 May 2026 08:24:24 +0000

Short post. The LinkedIn Company Employees Scraper on my Apify portfolio is raising PPE pricing on May 5. If you have a planned batch coming up, run it before then.

This is not a marketing nudge. This is an "I auto-disabled half the actor's value because I was losing money on residential proxy and the May 5 fix re-enables it" situation.

What changes May 5

Event	Old	New	Multiplier
short-profile	$0.003	$0.009	3x
full-profile	$0.006	$0.015	2.5x
full-profile-with-email	$0.01	$0.025	2.5x
actor-start	$0.005	$0.005	unchanged

A run that costs $0.10 today would cost about $0.30 after May 5. Same data, same accuracy, same actor.

Why now

Verification was auto-disabled on April 24 because residential proxy cost was running below the short-profile price. The actor falls back to confidence=low SERP-only output until the May 5 increase reactivates verified mode.

If you absolutely cannot wait until May 5 for verified data, pass acceptDiscoveryFallback: true on input. Build 2.2.21+ runs SERP-only at the current $0.003 rate.

Full breakdown of how the pricing got into this state in the first place:

theaientrepreneur.hashnode.dev/two-agency-users-were-83-of-my-revenue-they-left-and-i-noticed-29-days-later

Three actions if you use this actor

Run any planned bulk batches before May 5 to lock in current pricing on the events you need.
Update your maxTotalChargeUsd cap if you have one. The same volume after May 5 needs roughly 3x the cap on short-profile-heavy runs.
If your pipeline expects verified output and you cannot wait, switch to acceptDiscoveryFallback now to keep getting results at current pricing, with the confidence=low caveat.

What does not change

The actor itself. Same code, same maintenance, same response time. Same author who reads every Discussion thread.

The May 5 change brings pricing in line with what residential verification costs. After it lands, verification turns back on automatically and your runs return verified worksFor data again at the new rate.

When this is the wrong actor for you

If you only need the candidate set and not LinkedIn-verified worksFor data, the SERP-only path at $0.003 stays cheaper than competitors that bundle verification. If you need fully-verified output and your spreadsheet math says $0.009 per profile is too much, my actor is not the right tool. Phantombuster bundles verification at $69/mo for low volume. Bright Data is more expensive but enterprise-grade. Apify itself has 50+ LinkedIn actors, some priced lower for lower-quality verification.

I run mine at $0.009 because the residential proxy cost behind verification is real. Lower-priced competitors either skip verification, scrape with logged-in cookies (ToS risk), or run at a loss until they shut down (Proxycurl pattern).

Bottom line

Run your batches before May 5 if you can. Drop questions on the Apify Discussion thread for the actor if anything is unclear about the change.

apify.com/george.the.developer/linkedin-company-employees-scraper

6 Apify actors I actually use myself

George Kioko — Tue, 28 Apr 2026 19:51:26 +0000

I have 27 public Apify actors. Most are good. Six are genuinely useful and I run them through n8n and curl on a weekly basis. This is a tour of those six, with the actual prices, sample inputs, and the use cases I built them for.

If you found me through the silent-churn postmortem from earlier this week, this is the followup people kept asking for: "what else do you have?"

1. LinkedIn Company Employees Scraper

apify.com/george.the.developer/linkedin-company-employees-scraper

The one most people find me through. Takes a LinkedIn company URL, returns the top N employees who match your title filter. Verifies via JA4-accurate TLS fetch on a self-hosted Go service so it does not need login cookies and does not get flagged as a bot.

Sample input:

{
  "companies": ["https://www.linkedin.com/company/stripe"],
  "maxEmployees": 25,
  "targetTitles": ["CEO", "CTO", "Head of Engineering"]
}

Pay per event. $0.005 actor-start, $0.003 per short profile. Hike scheduled for May 5 to $0.009 per short profile to cover residential proxy cost properly.

Use it for: lead lists, sales prospecting, recruiter sourcing.

2. Email Validator API

apify.com/george.the.developer/email-validator-api

Standby HTTP API. Sub-second response. Runs syntax + MX + disposable + role-based + SMTP handshake checks. Pay per event $0.002 per email. Run a list of 50,000 emails and pay $100, not the $375 NeverBounce charges.

Sample call:

curl 'https://george-the-developer--email-validator-api.apify.actor/validate?email=test@stripe.com'

Use it for: pre-flight on cold email lists, signup form fraud filtering, list cleanup before importing to a CRM.

3. Domain WHOIS Lookup

apify.com/george.the.developer/domain-whois-lookup

Standby API. Returns registrar, age in days, expiry, DNS records. Falls back to RDAP since 374 gTLDs sunsetted port 43 WHOIS in early 2025. $0.005 per lookup.

Sample call:

curl 'https://george-the-developer--domain-whois-lookup.apify.actor/lookup?domain=stripe.com'

Use it for: lead-scoring (domain age is a real signal), security tooling, brand monitoring.

4. Company Enrichment API

apify.com/george.the.developer/company-enrichment-api

Domain in, company name + industry + tech stack signals out. Sub-second standby response. $0.01 per call.

Use it for: enrichment step in a lead-gen pipeline, ICP scoring, account research.

5. URL Metadata Extractor

apify.com/george.the.developer/url-metadata-extractor

OG tags, Twitter cards, favicon, canonical URL, structured data. Anything an AI agent needs to actually understand a page without parsing the full DOM. $0.003 per URL.

Use it for: content tools that show link previews, AI agents that need to summarize before they read, dashboards that aggregate links.

6. AI Content Detector

apify.com/george.the.developer/ai-content-detector

Text in, AI-probability score out. Uses an LLM-based classifier behind the scenes, not a regex. $0.003 per text.

Use it for: content moderation pipelines, marketplace listings filtering, dataset cleanup before training.

How they fit together

A typical pipeline I see in customer logs looks like this:

LinkedIn Company Employees Scraper finds candidates at a target company
Each candidate's email gets cleaned through Email Validator
Their company domain runs through WHOIS Lookup for age signal
Domain runs through Company Enrichment for industry + tech stack
Output goes into Hubspot or Pipedrive

Each step is pay per event. If you only need 3 of the 5 steps, you only pay for those events. There is no per-seat or per-month surcharge.

Honest pricing context

I just shipped a billing-guard fix for the LinkedIn actor that prevents it from emitting profiles when the charge would exceed your maxTotalChargeUsd cap. Postmortem on that lives here:

theaientrepreneur.hashnode.dev/why-my-linkedin-scraper-now-refuses-jobs

Same gate is rolling out across the standby APIs over the next two weeks. If you used any of these before the fix and your output count did not match your billed events, ping me.

Where to start

If you do lead generation, start with LinkedIn + Email Validator. That is the chain that produces revenue for users I see in the logs.

If you do content moderation or AI agent work, start with URL Metadata Extractor + AI Content Detector. They both return clean JSON in well under a second.

If you do security or domain research, start with WHOIS + Company Enrichment.

All six work standalone. All six bill per event, not per seat. None require API key contortions, just an Apify token and a curl.

apify.com/george.the.developer

What I shipped after the $540 silent churn postmortem

George Kioko — Sat, 25 Apr 2026 08:24:18 +0000

Yesterday I posted a postmortem on losing $540 a month to silent user churn. Some folks asked what the actual fix was. This is that post. Less drama, more code, three concrete patches that went live today.

If you missed yesterday: https://theaientrepreneur.hashnode.dev/two-agency-users-were-83-of-my-revenue-they-left-and-i-noticed-29-days-later

When I started digging into why my LinkedIn employee scraper was bleeding compute on real user runs, I found it was not one bug. It was three, layered.

Bug one: push first, charge second

Every Apify pay per event tutorial shows you Actor.charge('event-name', { count: 1 }). Easy. What none of them stress is what happens when the charge call fails.

There are at least three live failure modes:

The user set maxTotalChargeUsd on the run. They hit it. Charge returns chargedCount: 0.
Apify itself returns eventChargeLimitReached: true mid run.
The platform throws a transient error your try/catch swallows.

My actor's loop was structured like this:

await Actor.pushData(record);
try {
    await Actor.charge({ eventName, count: 1 });
} catch (e) {
    log.warning(`charge failed: ${e.message}`);
}
// the loop keeps going regardless

Push first, charge second, swallow errors, keep looping. So if charge stopped working halfway through a 100 profile run, the actor cheerfully output the remaining 50 for free while still spending real proxy and SERP money. The user got 100 profiles. I got billed for 50.

That is exactly the kind of leak you only notice when you stare at a per run cost graph and wonder why your revenue line is growing slower than your cost line.

The fix: a charge gate that fails closed

The new code calls a small helper before every emit. If charge fails for any reason, the gate refuses every subsequent call without even trying.

export function createProfileChargeGate({ isPPE, eventName, actorCharge, logger, stats }) {
    let chargeLimitReached = false;

    return {
        hasChargeLimitReached: () => chargeLimitReached,
        async chargeForNextProfile() {
            if (!isPPE) return { canEmit: true, charged: false, reason: 'not-ppe' };
            if (chargeLimitReached) return { canEmit: false, charged: false, reason: 'charge-limit-reached' };

            try {
                const result = await actorCharge({ eventName, count: 1 });
                if (result?.eventChargeLimitReached) {
                    chargeLimitReached = true;
                    return { canEmit: false, charged: false, reason: 'charge-limit-reached', result };
                }
                const charged = Number(result?.chargedCount || 0);
                if (charged <= 0) {
                    chargeLimitReached = true;
                    return { canEmit: false, charged: false, reason: 'not-charged', result };
                }
                stats.totalCharges = (stats.totalCharges || 0) + charged;
                return { canEmit: true, charged: true, reason: 'charged', result };
            } catch (error) {
                chargeLimitReached = true;
                return { canEmit: false, charged: false, reason: 'charge-error', error };
            }
        },
    };
}

The main loop now does:

const gate = createProfileChargeGate({ isPPE, eventName, actorCharge: Actor.charge, logger: log, stats });

for (const profile of profiles) {
    const verdict = await gate.chargeForNextProfile();
    if (!verdict.canEmit) {
        log.info(`Stopping at ${stats.totalCharges} profiles, gate refused: ${verdict.reason}`);
        break;
    }
    await Actor.pushData(profile);
}

Once the gate has refused, every call short circuits without trying to charge again. The run wraps up gracefully instead of bleeding compute on uncharged output.

Bug two: jobs that should never start

The second class of bug is the job that should not have run at all. A user sets companyCount 200, targetTitles 30, maxEmployees 1, hits Run, and watches my actor burn proxy and verification cost while emitting almost nothing.

The math is approachable. Per company you do roughly basePages + targetTitleCount SERP requests at about $0.0025 each, plus a verification attempt budget at about $0.0004 each. Per profile emitted you collect actorStartPriceUsd + shortProfilePriceUsd, then Apify takes 20% platform share off the top.

So a preflight estimator can compute estimatedPlatformCostUsd and estimatedCreatorRevenueUsd before any compute happens.

export function buildMarginPreflightEstimate({
    companyCount, targetTitleCount, maxEmployees, verifyEnabled,
    actorStartPriceUsd, shortProfilePriceUsd, creatorRevenueShare,
    serpCostUsd, verificationAttemptCostUsd, maxCostToCreatorRevenueRatio = 0.75,
}) {
    const basePages = getBaseSerpPagesPerCompany({ maxEmployees, verifyEnabled });
    const serpRequests = companyCount * (basePages + targetTitleCount);
    const verificationAttempts = verifyEnabled
        ? companyCount * getInitialVerificationCandidateLimit({ companyCount, maxEmployees })
        : 0;
    const estimatedProfiles = companyCount * maxEmployees;

    const estimatedPlatformCostUsd = (serpRequests * serpCostUsd) + (verificationAttempts * verificationAttemptCostUsd);
    const estimatedCreatorRevenueUsd = (actorStartPriceUsd + estimatedProfiles * shortProfilePriceUsd) * creatorRevenueShare;

    const ratio = estimatedCreatorRevenueUsd > 0
        ? estimatedPlatformCostUsd / estimatedCreatorRevenueUsd
        : Infinity;

    const exceedsMarginBudget = ratio > maxCostToCreatorRevenueRatio;
    return {
        estimatedPlatformCostUsd, estimatedCreatorRevenueUsd, ratio,
        exceedsMarginBudget,
        warning: exceedsMarginBudget
            ? `Not profitable enough for verified mode. Reduce companies, reduce targetTitles, or increase maxEmployees per company.`
            : '',
    };
}

In main, before any real work:

if (estimate.exceedsMarginBudget) {
    throw new Error(`Input rejected before run start: ${estimate.warning}. No PPE events will be charged.`);
}

The throw happens before Actor.charge has been called once. The user gets a clear refusal at submit time and pays nothing. They can resubmit with parameters that actually make sense.

The estimator tests confirm it accepts normal small runs (2 companies, 25 employees each, verified) and rejects the title-heavy 1-employee runs that were the worst offenders.

Bug three: a default that was too generous

The third change is product taste. Default maxEmployees was 100. That is too many for verified scraping with current LinkedIn block rates. Most users wanted 10 to 20 anyway and just left the default. The new default is 25.

If you really want 100 verified profiles per company, type 100 explicitly. Acknowledging it costs you a keystroke instead of nothing.

Small change, real impact. The new default protected at least one user yesterday from accidentally triggering the margin preflight refusal.

What this means if you use the actor

Three things you will notice in the build that went live today:

You will not get billed for partial runs where charge stopped working. Either the run completes and you pay for everything you got, or it stops mid run and you pay nothing past the limit, never both.

You will get rejected at submit time if your input is structurally unprofitable. The error message tells you exactly which knob to turn.

You will be defaulted into a smaller, faster run. Big jobs are still possible, you just have to opt in.

What I am doing next

The same three patterns apply to most of my PPE actors. The charge gate is already a module. I will be rolling it across the rest of the portfolio over the next week:

AI Content Detector
Email Validator API
URL Metadata Extractor
Domain WHOIS Lookup
Company Enrichment API
Website Intelligence API

These already shipped a fix yesterday for a different leak (GPT Store action pings hitting the standby actor with test payloads). The billing gate is the next layer.

If you build pay per event actors on Apify, take an hour and add a similar gate. The savings show up immediately. Your users start trusting your billing numbers because the numbers actually match the work.

Try the actor

The fixes are live as of today's build:

https://apify.com/george.the.developer/linkedin-company-employees-scraper

Pass companies as a list of LinkedIn URLs, set maxEmployees explicitly if you want more than 25, and watch the run console. The new guards should make the cost line predictable for the first time since I shipped this thing.

Yesterday was the diagnosis. Today is the fix. Tomorrow, I find out if anyone other than me actually cares.

How I lost $540/month in 30 days to silent user churn (and didn't notice)

George Kioko — Fri, 24 Apr 2026 04:34:05 +0000

Last week my 30 day profit dropped from $268 to $50 and I assumed it was a bug in the dashboard.

It wasn't a bug. It was me not paying attention for 29 days straight.

This is a postmortem of how I lost roughly $540/month from two agency buyers who just quietly stopped running my actor on March 25. I found out on April 23. That's 29 days of ambient denial while every other part of my portfolio was also quietly rotting.

Writing this partly so I remember the lesson, partly because I know at least three other Apify devs are about to make the same mistake.

The numbers

I run a bunch of scrapers and APIs on Apify. Here's what the revenue split actually looked like in early April before things went sideways.

Actor	Users	Monthly revenue	% of total
Google Maps Lead Intel	2	$540	83%
LinkedIn Employee Scraper	37	$42	6.5%
YouTube Transcript	40	$28	4.3%
Google Scholar	18	$14	2.1%
Email Validator API	46	$11	1.7%
Website Intelligence API	22	$8	1.2%
Everything else (5 actors)	188	$7	1.1%
Total	353	$650	100%

Read that first row again. Two users. $540. More than the other 351 users combined, by a factor of like 7x.

I told myself this was fine because the product was working and the buyers were happy. Both things were true in early March. Neither was true by late March. I just didn't know.

The silence

March 25 was the last run either agency executed. I didn't flag it because nothing explicit broke. No error email, no angry message, no refund request. My Apify dashboard just showed fewer runs but the rolling 30 day number still looked okay because it was still averaging in the fat weeks from before.

Here's roughly how the number moved:

Early April: $268 rolling 30d profit. I'm feeling smug.
Mid April: $92. I figure maybe it's a slow week.
April 22: $50. I finally open the run logs.

By the time I looked, the last run from either agency was 29 days ago. Whatever issue they had (I still don't fully know), they decided it wasn't worth telling me about. They just left.

Agency users don't complain. They just stop paying. If you're building for them, burn that into your forehead.

What I found when I actually looked

This is the part that made me feel physically ill. Once I started doing a proper audit of my portfolio, I found that 6 of my other 10 monetized actors were broken in some way. Not all catastrophic. Some were returning partial data. One had a silently failing selector from a site redesign in February. One was charging $0 per run because of a broken Actor.charge() signature I'd introduced in a refactor.

Let me repeat that: I had actors that were executing successfully, returning data to users, and billing them exactly nothing. For weeks.

If one of those 2 agencies had tried a second actor of mine during that period, they'd have gotten rot. That's probably why they didn't come back.

The root cause wasn't the bugs though. Bugs happen. The root cause was that my attention was entirely on the $25/run cash cow because it was paying the bills. The cash cow was hiding the state of the herd.

Why 2 agency users paid more than 353 devs

I want to sit with this one because I think most solo devs misunderstand it.

My Google Maps Lead Intel actor charges $25 per successful run. It scrapes a geography, enriches each business with a website audit, scores them, and hands the agency a ranked list of cold outreach targets. One agency was running it on a schedule against 40 US cities per week. At $25 a pop, that's serious money.

The 353 devs on my other actors were paying $0.003 to $0.01 per row. They're hobbyists, students, one guy building a thesis scraper. They're lovely. They're also economically irrelevant to whether I can pay rent.

Two lessons fell out of this.

First, your paying users and your popular users are almost never the same people. Popularity on Apify Store is a vanity metric. Agency retention is the only metric that buys groceries.

Second, concentrated revenue is fragile in ways that only hurt you once. When I had 2 whales, my revenue was 83% dependent on their mood. The moment either whale left, my month was destroyed. Worse, because they paid so much, I built no alerting around them. I assumed I'd notice. I did not notice.

If you're reading this as an agency owner looking for scraping tools, what you actually want is a vendor who is not dependent on you. Someone with 50 paying clients will answer your ticket faster than someone with 2, because the guy with 2 is terrified of you and therefore weirdly slow to respond to bad news.

What I'm changing

Not writing a manifesto. Just the four things I'm doing this week.

Push alerting on every run. Apify has webhooks. I never wired them up because my dashboard was enough. It wasn't. Every successful run, every failed run, every billing event now pings a private Telegram channel I actually read. Here's the whole snippet, it's embarrassingly short:

// webhooks config in actor.json points at this endpoint
// payload is whatever Apify sends plus the run metadata
export async function notify(req, res) {
    const { eventType, eventData, resource } = req.body;
    const text = `[${eventType}] ${resource?.actId} run ${resource?.id}\n`
               + `status: ${resource?.status}\n`
               + `charged: $${resource?.usageTotalUsd ?? 0}`;
    await fetch(`https://api.telegram.org/bot${TG_TOKEN}/sendMessage`, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ chat_id: TG_CHAT, text }),
    });
    res.status(200).end();
}

That's it. If I'd had this on March 25, I'd have noticed the absence of runs within 48 hours, not 29 days. If you run anything that bills users, stop reading and go wire this up. Seriously.

Weekly self test of every monetized actor. Every Sunday I run each of my paid actors against a known input and diff the output against last week's. If the schema changes or the row count collapses, I know before the user does. This is stupid simple and I should have been doing it from day one.

Diversifying the buyer pool. $25/run is staying. But I'm actively building out the $5 to $10 tier with two new actors targeted at small agencies, because I want the bottom of the revenue chart to be less wobbly. Ten $50/month buyers survive any one of them leaving. Two $270/month buyers don't.

Public status page. Still building this but the idea is: if an actor is degraded, the user knows before they hit it. Trust compounds and I just burned a chunk of it, so I'm paying interest now.

Close

If you run any product that bills users on autopilot, go wire a Telegram or Slack webhook today. Not tomorrow. The 30 day rolling dashboard lies to you when things trend down because it's still averaging in good weeks. Push alerts don't lie. Runs either happen or they don't.

I'm writing this mostly for me. But if you want to see what the portfolio looks like now, or hire the actor that caused all this drama in the first place, it's here:

Apify profile: https://apify.com/george.the.developer
Google Maps Lead Intel (the $25/run one): on the same profile
Everything else I've shipped (27 public actors, some broken last week, all fixed now): same profile

Ask me anything in the comments. Especially if you're an agency buyer thinking about pulling the trigger on a vendor. I have thoughts about what you should actually be looking for.