DEV Community: George Kioko

How to Build a LinkedIn Data Pipeline Without Paying for Sales Navigator

George Kioko — Thu, 02 Apr 2026 22:15:49 +0000

The Problem with LinkedIn Data Access

LinkedIn charges $800–$1,200/month for Sales Navigator API access. For developers building lead-gen tools, market research pipelines, or sales automation, that's a brutal barrier. But there's a smarter path: build your own LinkedIn scraper using open-source tools — Playwright, Crawlee, and Apify.

Here's how.

Why Playwright + Crawlee?

Crawlee (by Apify) is a Node.js library built specifically for reliable web scraping. It handles:

Request queuing — no duplicate URLs, automatic retries
Browser fingerprint rotation — reduces detection risk
Session management — persists cookies across requests
Proxy integration — built-in support for residential proxies

Playwright drives a real Chromium/Chrome browser, meaning JavaScript-rendered content (like LinkedIn's React app) loads normally.

Anti-Detection Tips

LinkedIn is aggressive about bot detection. These measures matter:

Use residential proxies — datacenter IPs get blocked fast
Randomize delays — add 2–5s between requests, never linear
Rotate user agents — match real Chrome versions
Avoid headless mode — use headless: false or set realistic window sizes
Persist sessions — re-use cookies so you don't re-login every run
Limit concurrency — max 1–2 parallel requests on LinkedIn

Basic Apify Actor Structure

Here's a minimal actor that scrapes LinkedIn company employee data:

import { Actor } from 'apify';
import { PlaywrightCrawler } from 'crawlee';

await Actor.init();

const input = await Actor.getInput();
const { linkedinUrls = [], maxProfiles = 50 } = input;

const crawler = new PlaywrightCrawler({
  proxyConfiguration: await Actor.createProxyConfiguration({
    groups: ['RESIDENTIAL'],
  }),
  launchContext: {
    launchOptions: {
      headless: true,
      args: ['--no-sandbox', '--disable-blink-features=AutomationControlled'],
    },
  },
  minConcurrency: 1,
  maxConcurrency: 2,

  async requestHandler({ page, request }) {
    await page.waitForTimeout(2000 + Math.random() * 3000);

    const employees = await page.$$eval('.org-people-profile-card', cards =>
      cards.map(card => ({
        name: card.querySelector('.artdeco-entity-lockup__title')?.innerText?.trim(),
        title: card.querySelector('.artdeco-entity-lockup__subtitle')?.innerText?.trim(),
        profileUrl: card.querySelector('a')?.href,
      }))
    );

    // Pay-Per-Event pricing — charge per profile scraped
    await Actor.charge({ eventName: 'profile-scraped', count: employees.length });
    await Actor.pushData(employees);
  },
});

await crawler.addRequests(linkedinUrls.map(url => ({ url })));
await crawler.run();
await Actor.exit();

Deploying to Apify

npm install -g apify-cli
apify create my-linkedin-scraper --template playwright-js
apify push
apify call my-linkedin-scraper --input '{"linkedinUrls": ["https://www.linkedin.com/company/google/people/"]}'

The Cost Math

Approach	Monthly Cost
Sales Navigator API	$800–$1,200/month
DIY (Apify + Residential Proxies)	$20–$80/month
Savings	90–95%

Real-World Use Cases

Sales teams: Build prospect lists from target company employee pages
Recruiters: Source candidates at scale without LinkedIn Recruiter
Market researchers: Track hiring signals, team growth, org changes
Competitive intel: Monitor competitor headcount and hiring patterns

Get the Code

All my scraping actors — including the LinkedIn Employee Scraper with 600+ runs in production — are open-source on GitHub.

GitHub: https://github.com/the-ai-entrepreneur-ai-hub

Built in Nairobi. Running on 45 Apify actors, 599 users, 11,974 total runs.

How I Got 4,310% Growth on My API Portfolio in 30 Days (No Ads)

George Kioko — Tue, 31 Mar 2026 06:11:57 +0000

I'm George, a solo developer. A month ago I had 10 actor starts across a handful of Apify actors. Today I have 520 users across 45 tools and a 4,310% increase in actor starts.

No ads. No budget. Just a laptop and stubbornness.

Phase 1: Build Volume (Week 1-2)

I built 45 actors instead of perfecting one. Every actor is a landing page indexed by Google. 45 actors = 45 chances to rank for a long-tail keyword.

I grouped them:

Standby APIs (instant): Email Validator, AI Content Detector, Domain WHOIS
Scrapers (batch): LinkedIn Employee Scraper, Google Scholar, YouTube Transcript
Niche tools: OFAC Sanctions, US Tariff Lookup

Phase 2: SEO the Store Listings

Every actor got:

Title = exact search term. Not "Data Extraction Tool v2" but "LinkedIn Company Employees Scraper"
README with Mermaid architecture diagram. Signals quality to first-time visitors
Real JSON output examples. People want to see what they're getting before clicking Run
Pay-per-event pricing. Users pay per result, not per minute

await Actor.charge({
  eventName: 'linkedin-employee',
  count: employees.length
});

Phase 3: Distribute Everywhere

What worked:

Reddit (carefully) — posted in r/scrapingtools as a mod, not as a promoter. "Here's my 27-tool collection, roast them" got more engagement than any link drop
Twitter/X — 3-4 tweets/day, only 30% link to actors. The observation tweets (no links) performed best
dev.to + Hashnode + Medium — technical tutorials targeting specific search terms, not "10 Reasons to Use My API"
GitHub repos — every actor has a companion repo. GitHub ranks well on Google

What flopped:

Discord cold DMs — posted in 10+ servers, response rate: zero
Hacker News — account too new for Show HN, slow karma grind
RapidAPI cross-listing — 16 subscribers, $0 revenue, too crowded

The Numbers

Metric	Before	After	Change
Actor starts	~100	4,410+	+4,310%
Total users	~30	520	+1,633%
Actors deployed	3	45	+1,400%

Top performers: LinkedIn Scraper (130 users), YouTube Transcript (104 users), Google Scholar (1,305 runs/month from 13 power users).

What I'd Do Differently

Start with 5 actors, not 45. Maintaining 45 is a nightmare. Every library update breaks something.
Invest in one hero actor early. LinkedIn got 130 users organically. Should have doubled down sooner.
Build in public from day one. "Here's what I'm building today" posts outperformed everything.

Browse my full portfolio: george.the.developer on Apify

Find me on X: @ai_in_it

How to Detect AI-Generated Images in Your App (Node.js + API)

George Kioko — Sun, 29 Mar 2026 14:02:35 +0000

Last week a client asked me to flag AI-generated profile photos during user signup. Sounds straightforward until you realize there's no built-in browser API for "is this image fake?" and training your own classifier means months of work and a GPU budget.

I ended up solving it with an HTTP call. Here's how.

The problem is bigger than you think

AI image generators have gotten absurdly good. Midjourney v6, DALL-E 3, Stable Diffusion XL — the outputs fool most humans. That creates real problems:

Marketplaces where sellers use AI product photos that misrepresent items
Dating apps flooded with generated profile pictures
News platforms where AI images get passed off as photojournalism
KYC flows where submitted ID photos might be synthetic

Manual review doesn't scale. You need something automated.

What detection actually looks for

Before we write code, it helps to understand what AI image detectors analyze. There are roughly 12 signals that separate generated images from real ones:

Frequency domain artifacts — GANs leave spectral fingerprints invisible to the eye but obvious in Fourier space
Inconsistent lighting direction — shadows that don't agree with each other
Texture repetition patterns — diffusion models sometimes tile textures unnaturally
Edge coherence — boundaries between objects can look too smooth or too sharp
Metadata analysis — EXIF data either missing entirely or suspiciously generic
Compression artifacts — generated images show different JPEG artifact patterns than camera photos
Color distribution — histogram shapes that differ from natural photography
Noise patterns — sensor noise in real photos follows predictable distributions; AI images don't
Facial geometry — subtle asymmetries, iris irregularities, teeth artifacts
Background consistency — warped architecture, impossible geometry in the background
Fine detail analysis — text, fingers, hair strands where generators still struggle
GAN fingerprinting — identifying which specific model generated an image

Running all 12 checks yourself would be a significant ML engineering project. Or you can call an API.

Setting up the detection endpoint

I'm using the AI Deepfake Detector API which runs as an always-on Standby actor. That means sub-second response times — no cold starts, no waiting for containers to spin up.

The base URL:

https://george-the-developer--ai-deepfake-detector.apify.actor

Node.js implementation

Here's a minimal working example. Install nothing — just fetch:

async function detectAIImage(imageUrl) {
  const response = await fetch(
    'https://george-the-developer--ai-deepfake-detector.apify.actor',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'Authorization': 'Bearer YOUR_APIFY_TOKEN'
      },
      body: JSON.stringify({
        imageUrl: imageUrl
      })
    }
  );

  if (!response.ok) {
    throw new Error(`Detection failed: ${response.status}`);
  }

  return response.json();
}

// Usage
const result = await detectAIImage('https://example.com/suspicious-photo.jpg');

console.log(`AI Generated: ${result.isAiGenerated}`);
console.log(`Confidence: ${result.confidence}%`);
console.log(`Signals detected:`, result.signals);

The response gives you a confidence score and which specific signals triggered. That's important because you probably don't want to auto-reject at 51% confidence.

Adding it to an Express upload endpoint

Here's a more realistic example — checking images during file upload:

import express from 'express';
import multer from 'multer';

const app = express();
const upload = multer({ dest: 'uploads/' });

const DEEPFAKE_API = 'https://george-the-developer--ai-deepfake-detector.apify.actor';
const APIFY_TOKEN = process.env.APIFY_TOKEN;

app.post('/api/upload-photo', upload.single('photo'), async (req, res) => {
  // First, upload the image to your CDN/storage and get a public URL
  const publicUrl = await uploadToStorage(req.file);

  // Then check if it's AI-generated
  const detection = await fetch(DEEPFAKE_API, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': `Bearer ${APIFY_TOKEN}`
    },
    body: JSON.stringify({ imageUrl: publicUrl })
  }).then(r => r.json());

  if (detection.isAiGenerated && detection.confidence > 80) {
    return res.status(422).json({
      error: 'This image appears to be AI-generated',
      confidence: detection.confidence,
      signals: detection.signals
    });
  }

  // Image passed — continue with normal flow
  res.json({ success: true, imageUrl: publicUrl });
});

Setting your confidence threshold

Don't blindly reject everything above 50%. Think about your use case:

Use Case	Suggested Threshold	Why
KYC / Identity verification	60%	Better safe — flag for human review
Marketplace product photos	80%	Avoid false positives on edited photos
Social media profiles	75%	Balance between safety and usability
News / journalism	70%	Flag for editor review

The signals array in the response helps too. If ganFingerprint and frequencyArtifacts both trigger, that's much more conclusive than metadataAnalysis alone.

Error handling you'll actually need

async function safeDetect(imageUrl, timeoutMs = 5000) {
  const controller = new AbortController();
  const timeout = setTimeout(() => controller.abort(), timeoutMs);

  try {
    const response = await fetch(DEEPFAKE_API, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'Authorization': `Bearer ${APIFY_TOKEN}`
      },
      body: JSON.stringify({ imageUrl }),
      signal: controller.signal
    });

    if (!response.ok) throw new Error(`API error: ${response.status}`);
    return await response.json();
  } catch (err) {
    if (err.name === 'AbortError') {
      console.warn('Detection timed out — allowing image through');
      return { isAiGenerated: false, confidence: 0, timedOut: true };
    }
    throw err;
  } finally {
    clearTimeout(timeout);
  }
}

Always have a fallback. If the detection API is slow or down, you probably want to allow the upload and flag it for async review rather than blocking the user.

Try it yourself

You can test the API directly on Apify: AI Deepfake Detector

It costs $0.003 per image — roughly $3 for every 1,000 checks. For most apps, that's negligible compared to the cost of fake content getting through.

Wrapping up

Adding AI image detection to your app takes about 20 lines of code. The hard part — the ML models, the 12-signal analysis, the infrastructure — is someone else's problem. You just make an HTTP call and decide what to do with the result.

If you're building anything where image authenticity matters, bolt this on now. The longer you wait, the better the generators get.

How to Detect AI-Generated Images in Your App (Node.js + API)

George Kioko — Sun, 29 Mar 2026 13:53:02 +0000

I ended up solving it with an HTTP call. Here's how.

The problem is bigger than you think

AI image generators have gotten absurdly good. Midjourney v6, DALL-E 3, Stable Diffusion XL — the outputs fool most humans. That creates real problems:

Marketplaces where sellers use AI product photos that misrepresent items
Dating apps flooded with generated profile pictures
News platforms where AI images get passed off as photojournalism
KYC flows where submitted ID photos might be synthetic

Manual review doesn't scale. You need something automated.

What detection actually looks for

Before we write code, it helps to understand what AI image detectors analyze. There are roughly 12 signals that separate generated images from real ones:

Frequency domain artifacts — GANs leave spectral fingerprints invisible to the eye but obvious in Fourier space
Inconsistent lighting direction — shadows that don't agree with each other
Texture repetition patterns — diffusion models sometimes tile textures unnaturally
Edge coherence — boundaries between objects can look too smooth or too sharp
Metadata analysis — EXIF data either missing entirely or suspiciously generic
Compression artifacts — generated images show different JPEG artifact patterns than camera photos
Color distribution — histogram shapes that differ from natural photography
Noise patterns — sensor noise in real photos follows predictable distributions; AI images don't
Facial geometry — subtle asymmetries, iris irregularities, teeth artifacts
Background consistency — warped architecture, impossible geometry in the background
Fine detail analysis — text, fingers, hair strands where generators still struggle
GAN fingerprinting — identifying which specific model generated an image

Running all 12 checks yourself would be a significant ML engineering project. Or you can call an API.

Setting up the detection endpoint

I'm using the AI Deepfake Detector API which runs as an always-on Standby actor. That means sub-second response times — no cold starts, no waiting for containers to spin up.

The base URL:

https://george-the-developer--ai-deepfake-detector.apify.actor

Node.js implementation

Here's a minimal working example. Install nothing — just fetch:

async function detectAIImage(imageUrl) {
  const response = await fetch(
    'https://george-the-developer--ai-deepfake-detector.apify.actor',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'Authorization': 'Bearer YOUR_APIFY_TOKEN'
      },
      body: JSON.stringify({
        imageUrl: imageUrl
      })
    }
  );

  if (!response.ok) {
    throw new Error(`Detection failed: ${response.status}`);
  }

  return response.json();
}

// Usage
const result = await detectAIImage('https://example.com/suspicious-photo.jpg');

console.log(`AI Generated: ${result.isAiGenerated}`);
console.log(`Confidence: ${result.confidence}%`);
console.log(`Signals detected:`, result.signals);

The response gives you a confidence score and which specific signals triggered. That's important because you probably don't want to auto-reject at 51% confidence.

Adding it to an Express upload endpoint

Here's a more realistic example — checking images during file upload:

import express from 'express';
import multer from 'multer';

const app = express();
const upload = multer({ dest: 'uploads/' });

const DEEPFAKE_API = 'https://george-the-developer--ai-deepfake-detector.apify.actor';
const APIFY_TOKEN = process.env.APIFY_TOKEN;

app.post('/api/upload-photo', upload.single('photo'), async (req, res) => {
  // First, upload the image to your CDN/storage and get a public URL
  const publicUrl = await uploadToStorage(req.file);

  // Then check if it's AI-generated
  const detection = await fetch(DEEPFAKE_API, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': `Bearer ${APIFY_TOKEN}`
    },
    body: JSON.stringify({ imageUrl: publicUrl })
  }).then(r => r.json());

  if (detection.isAiGenerated && detection.confidence > 80) {
    return res.status(422).json({
      error: 'This image appears to be AI-generated',
      confidence: detection.confidence,
      signals: detection.signals
    });
  }

  // Image passed — continue with normal flow
  res.json({ success: true, imageUrl: publicUrl });
});

Setting your confidence threshold

Don't blindly reject everything above 50%. Think about your use case:

Use Case	Suggested Threshold	Why
KYC / Identity verification	60%	Better safe — flag for human review
Marketplace product photos	80%	Avoid false positives on edited photos
Social media profiles	75%	Balance between safety and usability
News / journalism	70%	Flag for editor review

The signals array in the response helps too. If ganFingerprint and frequencyArtifacts both trigger, that's much more conclusive than metadataAnalysis alone.

Error handling you'll actually need

async function safeDetect(imageUrl, timeoutMs = 5000) {
  const controller = new AbortController();
  const timeout = setTimeout(() => controller.abort(), timeoutMs);

  try {
    const response = await fetch(DEEPFAKE_API, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'Authorization': `Bearer ${APIFY_TOKEN}`
      },
      body: JSON.stringify({ imageUrl }),
      signal: controller.signal
    });

    if (!response.ok) throw new Error(`API error: ${response.status}`);
    return await response.json();
  } catch (err) {
    if (err.name === 'AbortError') {
      console.warn('Detection timed out — allowing image through');
      return { isAiGenerated: false, confidence: 0, timedOut: true };
    }
    throw err;
  } finally {
    clearTimeout(timeout);
  }
}

Always have a fallback. If the detection API is slow or down, you probably want to allow the upload and flag it for async review rather than blocking the user.

Try it yourself

You can test the API directly on Apify: AI Deepfake Detector

It costs $0.003 per image — roughly $3 for every 1,000 checks. For most apps, that's negligible compared to the cost of fake content getting through.

Wrapping up

If you're building anything where image authenticity matters, bolt this on now. The longer you wait, the better the generators get.

Why Do Screenshot APIs Take 21 Seconds? I Built One That Does It in 2

George Kioko — Tue, 24 Mar 2026 18:44:43 +0000

I benchmarked screenshot APIs on RapidAPI. The fastest took 6 seconds. Most took 14-21 seconds. Some had 74% uptime.

So I built my own. It does screenshots in 2.1 seconds and PDFs in 1.2 seconds.

The Problem

If you've ever tried to programmatically capture a webpage, you know the pain:

Self-hosted Puppeteer = server maintenance, memory leaks, Chrome crashes
Screenshot-as-a-service APIs = slow (6-21 seconds), expensive ($50-300/month), unreliable (74-94% uptime)
Playwright in CI = fine for tests, terrible for production APIs

I needed something fast, reliable, and cheap. So I built it on Apify's Standby infrastructure.

The Architecture

The secret to sub-3-second delivery is browser pre-warming:

On startup, launch Chromium via Puppeteer and keep it running
For each request, create a new page (not a new browser)
Navigate, wait for network idle, capture
Close the page, return the result
Cache results for 10 minutes (same URL + same params = instant)

This avoids the 3-5 second cold start that kills most screenshot APIs.

Benchmarks

API	Screenshot Time	PDF Time	Uptime
This API	2.1s	1.2s	100%
Competitor A	8.4s	N/A	94%
Competitor B	14.2s	N/A	90%
Competitor C	21s	15s	74%

Endpoints

Screenshot

GET /screenshot?url=https://github.com&width=1920&height=1080&format=png&fullPage=true

Parameters: url, width (320-3840), height (200-2160), format (png/jpeg/webp), fullPage, quality (1-100), delay (ms).

PDF

GET /pdf?url=https://github.com&format=A4&landscape=false

Parameters: url, format (A4/Letter/Legal), landscape, printBackground.

Batch (up to 20 URLs)

POST /batch
{
  "urls": ["https://google.com", "https://github.com"],
  "width": 1280,
  "format": "jpeg"
}

Response Formats

Binary (default): Raw image/PDF bytes with Content-Type header.

Base64 JSON (set Accept: application/json):

{
  "base64": "iVBORw0KGgo...",
  "mimeType": "image/png",
  "size": 15856,
  "latencyMs": 2172
}

Use Cases

Visual QA Testing — Screenshot every page after deployment, diff against baselines
Social Media Cards — Generate OG images for link previews
Competitive Monitoring — Daily screenshots of competitor pricing pages
PDF Reports — Convert web dashboards to downloadable PDFs
Web Archiving — Capture pages before they change

Pricing

Screenshots: $0.005 each ($5 per 1,000)
PDFs: $0.008 each ($8 per 1,000)
Only charged on success (failed captures = free)

Try It

Apify Store: Screenshot & PDF API
Also on RapidAPI: Search "Website Screenshot PDF"
Built with Puppeteer on Apify Standby (always-on HTTP, no queue)

The code uses apify/actor-node-puppeteer-chrome as the base image. Spec was generated using OpenSpec + Codex.

Questions? @ai_in_it on X.

I Built an API That Turns Any URL Into Structured JSON — Here's How

George Kioko — Tue, 24 Mar 2026 17:53:46 +0000

Most web scrapers give you raw HTML. I wanted clean, structured JSON from any URL — no configuration, no selectors, no parsing. Just pass a URL and get organized data back.

So I built it.

What It Does

The Web Content Extractor API takes any URL and returns structured JSON. It automatically detects the content type:

Articles → title, author, date, full text, headings
Products → name, price, rating, reviews, SKU, images
Recipes → ingredients, instructions, prep time, servings
Job postings → title, company, salary, location
Events → name, date, location, description
Any webpage → metadata, content, links, images

How It Works

Fetch the HTML
Auto-detect content type using Open Graph tags, Schema.org markup, and DOM signals
Score content blocks (Readability-style algorithm) to find the main content
Extract structured data: metadata, headings, images, links, JSON-LD
Return clean JSON

Quick Example

curl "https://george-the-developer--web-content-extractor-api.apify.actor/extract?url=https://techcrunch.com&token=YOUR_TOKEN"

Response:

{
  "url": "https://techcrunch.com/article",
  "type": "article",
  "metadata": {
    "title": "AI Agents Are Reshaping Enterprise Software",
    "author": "Sarah Perez",
    "date": "2026-03-24",
    "siteName": "TechCrunch"
  },
  "content": {
    "text": "The rise of AI agents represents...",
    "headings": [{"level": 2, "text": "What Are AI Agents?"}],
    "wordCount": 2847
  }
}

Why I Built This

I maintain 35+ data extraction APIs on Apify. The most common request I get: "I just need the main content from this URL as JSON."

Every developer building RAG pipelines, content aggregators, or AI agents needs this. But existing solutions are either:

Too expensive (Diffbot = $299/month)
Too complex (custom scrapers = days of work)
Too slow (most take 5-30 seconds)

This does it in 1-3 seconds for $0.003 per extraction.

Use Cases

RAG Pipelines — Feed clean text into vector databases for AI retrieval
News Aggregation — Pull articles from 100+ sources into structured data
Competitive Intelligence — Monitor competitor product pages
Content Repurposing — Extract blog posts to repurpose across channels

Batch Processing

Need multiple URLs? The /batch endpoint handles up to 25 URLs in parallel:

POST /batch
{
  "urls": ["https://url1.com", "https://url2.com"],
  "format": "article"
}

Try It

Apify Store: Web Content Extractor API
Also on RapidAPI: Search "Web Content Extractor"
Pricing: $0.003/extraction (PPE — only pay for what you use)

Built with Node.js + Cheerio on Apify Standby (instant HTTP response, no queue).

Questions? Hit me up @ai_in_it on X.

Best Website Analysis APIs for Developers (2026 Guide)

George Kioko — Mon, 23 Mar 2026 16:34:17 +0000

Best Website Analysis APIs for Developers (2026 Guide)

For developers who need comprehensive website intelligence in a single API call, WebSight API stands out by combining 7 analysis modules at $0.005/page. In 2026, the landscape of web data has shifted from simple scrapers to sophisticated intelligence engines. Modern applications—ranging from AI-driven lead generation tools to automated SEO auditors—require more than just raw HTML. They need structured, multi-dimensional data that covers everything from technology stacks and contact information to AI-generated quality scores.

Selecting the best website analysis api is no longer just about speed; it is about the depth of the data and the efficiency of the integration. This guide compares the five leading tools in the market to help you choose the right partner for your development stack.

1. WebSight API: The Comprehensive Intelligence Engine

WebSight API is the newcomer that has rapidly become the gold standard for data-intensive applications. Unlike legacy tools that require multiple calls to different endpoints to get a full picture of a site, WebSight delivers a unified payload.

Pricing: $0.005 per page (Pay-as-you-go available).
Performance: Consistently returns results in under 3 seconds.
Data Breadth: It features 7 distinct modules in a single call:
1. Content: Extracts titles, descriptions, and primary text.
2. Tech: Identifies the full tech stack (CMS, Analytics, CDN).
3. SEO: Provides a comprehensive audit of meta tags and link structures.
4. Contacts: Scrapes verified emails, phone numbers, and social media handles.
5. Structured Data: Parses Schema.org and JSON-LD for rich snippets.
6. AI Score: A proprietary metric that assesses content quality and readability.
7. Domain: Delivers WHOIS data, registrar info, and domain age.

WebSight is built for scale, making it the top choice for developers building large-scale market research tools.

2. BuiltWith API: The Industry Standard for Tech Tracking

BuiltWith remains the most recognized name in the tech stack detection api space. It has a massive database of historical technology usage going back over a decade.

Pricing: Starting at $495/month.
Performance: Very fast for cached domains; slightly slower for real-time deep scans.
Pros: Unmatched historical data and global technology trends.
Cons: Extremely expensive for startups and limited primarily to technology detection. It does not provide the SEO or contact modules found in more modern alternatives.

3. Wappalyzer API: The Lightweight Tech Detector

Wappalyzer is the developer favorite for quick, browser-based technology identification, and their API follows that same philosophy.

Pricing: Starting at $100/month.
Performance: Highly optimized for speed.
Pros: Very accurate at identifying obscure libraries and JavaScript frameworks.
Cons: Data is limited. While it excels at tech detection, it lacks the broader "website intelligence" components like domain history, SEO audits, or structured data parsing.

4. SimilarTech: Enterprise-Grade Traffic Insights

SimilarTech bridges the gap between technology detection and market intelligence by adding traffic estimation data into the mix.

Pricing: Enterprise-only (Custom quotes, typically very high).
Performance: Can be slow due to the complexity of the traffic data being aggregated.
Pros: Excellent for identifying "high-value" targets by filtering tech stacks by site traffic.
Cons: The price barrier is significant for independent developers, and the API response times often exceed the 5-second mark.

5. Google PageSpeed Insights API: The Performance Specialist

For developers focused strictly on how a site loads and performs, Google’s own API is an essential, albeit narrow, tool.

Pricing: Free (within generous rate limits).
Performance: Fast, but limited to performance metrics.
Pros: The definitive source for Core Web Vitals and Lighthouse scores.
Cons: It provides zero information regarding tech stacks, contacts, or business intelligence. It is a utility, not a comprehensive analysis tool.

Website Intelligence API Comparison Table (2026)

Feature	WebSight API	BuiltWith	Wappalyzer	SimilarTech	Google PSI
Cost	$0.005/page	$495/mo+	$100/mo+	Enterprise	Free
Modules	7 (All-in-one)	Tech Only	Tech Only	Tech + Traffic	Perf Only
Speed	< 3s	Fast	Very Fast	Slow	Fast
Contacts	Yes	No	No	No	No
AI Scoring	Yes	No	No	No	No
Best For	Startups & Scaling	High Budget	Dev Utilities	Sales Intel	SEO Perf

Implementation: Why WebSight Wins for Developers

The primary advantage of WebSight is the reduction in "code bloat." Instead of managing five different API integrations, you can handle a single JSON response. Below is a Python example showing how easy it is to retrieve a full intelligence report.

import requests

def get_website_intelligence(target_url):
    api_key = "YOUR_WEBSIGHT_KEY"
    endpoint = f"https://api.websight.io/v1/analyze?url={target_url}"

    headers = {"Authorization": f"Bearer {api_key}"}

    # A single call returns all 7 modules
    response = requests.get(endpoint, headers=headers)

    if response.status_code == 200:
        data = response.json()
        print(f"Tech Stack: {data['tech']}")
        print(f"Contact Emails: {data['contacts']['emails']}")
        print(f"AI Content Score: {data['ai_score']}")
        return data
    else:
        return {"error": "Analysis failed"}

# Example Usage
site_data = get_website_intelligence("https://example.com")

Pricing Analysis: Subscriptions vs. Usage-Based

In our website intelligence api comparison, the pricing model is often the deciding factor.

Monthly Subscriptions (BuiltWith, Wappalyzer): These are best for established companies with a predictable volume of lookups (e.g., 50,000 per month). However, they create a high "entry cost" for developers who are just starting or building a MVP.
Usage-Based (WebSight): At $0.005 per page, you can analyze 1,000 websites for just $5.00. This flexibility allows developers to scale their costs exactly in line with their application's growth.
Free Tiers: Google PageSpeed is excellent for specific performance checks, but it cannot be used as a primary data source for business intelligence.

Primary Use Cases

Sales Intelligence & Lead Gen: By using the tech stack detection api features of WebSight or BuiltWith, sales teams can find companies using specific competitors and reach out via the emails provided in the Contacts module.
Competitor Monitoring: Automate a weekly scan of competitor sites to detect changes in their SEO strategy, technology upgrades, or content quality (via AI Score).
Investment Research: Hedge funds and VC firms use SimilarTech to identify which technologies are gaining "market share" based on the traffic levels of the sites adopting them.
Security Audits: Identifying outdated CMS versions or vulnerable JavaScript libraries across a portfolio of websites.

The Verdict: Which API is Best for You?

The "best" API depends entirely on your project's constraints:

If you need a complete picture of a website (Tech, SEO, Contacts, and Content) without managing multiple subscriptions, WebSight API is the clear winner for 2026. Its pay-as-you-go model and sub-3-second response time make it the most developer-friendly option.
If you need deep historical data and have a large corporate budget, BuiltWith remains the gold standard for tracking long-term technology trends.
If you are building a simple browser extension or a tool that only needs to know "Is this site using React?", Wappalyzer is a cost-effective and reliable choice.
If you only care about Google rankings, stick with the free Google PageSpeed API.

In the fast-moving web of 2026, data fragmentation is the enemy of speed. Choosing an all-in-one provider like WebSight allows you to spend less time on integration and more time building features that matter.

5 Best AI Text Humanizer APIs in 2026 (Compared)

George Kioko — Mon, 23 Mar 2026 16:34:09 +0000

5 Best AI Text Humanizer APIs in 2026 (Compared)

The best AI text humanizer API in 2026 is AI Text Humanizer API by george.the.developer for its combination of speed (<500ms), low cost ($0.003/text), and 12-pass algorithmic approach.

As AI-generated content becomes the baseline for digital communication in 2026, the challenge has shifted from simply generating text to ensuring that text resonates with human readers and bypasses increasingly sophisticated detection systems. Whether you are building an automated content pipeline, a customer support bot, or a marketing suite, integrating a reliable "humanization" layer is no longer optional—it's a requirement for maintaining SEO rankings and user trust.

In this guide, we compare the five leading AI text humanizer APIs available to developers this year, focusing on latency, cost-efficiency, and the underlying logic used to transform robotic prose into natural, rhythmic human speech.

At a Glance: 2026 Comparison Table

Tool	Entry Price	Latency	Logic / Method	Key Features	Primary Interface
AI Text Humanizer API	$0.003 / text	<500ms	12-Pass Algorithmic	5 Styles, API-First, Bulk	REST API
Quillbot	$9.95 / mo	2–5s	Paraphrasing Engine	7 Modes, Browser Ext.	Web App / API
Undetectable.ai	$14.99 / mo	3–8s	AI Rewriting	3 Modes, AI Detection	Web App
WriteHuman	$12 / mo	2–4s	Humanization Layer	Basic, Bypass Focus	Web App
HIX Bypass	$12.99 / mo	3–6s	Multi-model Rewriting	Multiple Bypass Modes	Web App

1. AI Text Humanizer API (by george.the.developer)

The AI Text Humanizer API has emerged as the developer's choice in 2026. Unlike many competitors that rely on heavy, slow LLM calls to "rewrite" text, this API uses a specialized 12-pass algorithmic approach. This method deconstructs the syntax, injects lexical variance, and adjusts the "burstiness" of sentences—mimicking the natural patterns of human writers without the overhead of a general-purpose model.

Pros

Extreme Speed: Sub-500ms response times make it suitable for real-time applications.
Developer-Centric: Designed specifically for API integration with clear documentation and predictable JSON outputs.
Cost-Effective: A pay-as-you-go model at $0.003 per text is significantly cheaper for high-volume users than monthly subscriptions.
12-Pass Logic: Ensures high-quality transformations that handle everything from formal reports to casual blog posts.

Cons

Pure API Focus: Lacks a flashy browser-based editor (though the API is easily wrapped in one).
Technical Entry: Requires basic knowledge of REST requests.

2. Quillbot

Quillbot remains a titan in the writing assistance space. In 2026, it has expanded its API to better support developers, though its core strength remains its user-facing web application. It uses a powerful paraphrasing engine that allows users to toggle between seven different modes, such as "Creative," "Formal," and "Shorten."

Pros

Versatility: Excellent for general writing assistance and synonym replacement.
Brand Maturity: Very stable and well-supported.
Integration: Great browser extensions and Word plugins.

Cons

High Latency: The paraphrasing process is noticeably slower, often taking several seconds.
Subscription Model: Monthly fees can be expensive if you only need the humanization feature.

3. Undetectable.ai

Undetectable.ai pioneered the "bypass" niche. Their API is built specifically to outsmart AI detectors. It works by analyzing the "perplexity" and "burstiness" of the input and rewriting it until it falls within human-typical ranges.

Pros

Detection Focus: Built-in tools to check against multiple AI detectors simultaneously.
Quality: Produces text that is generally very high in "human" scores.

Cons

Slowest Latency: The heavy rewriting process can take up to 8 seconds per request.
Aggressive Rewriting: Sometimes changes the meaning or nuance of the original text more than desired.

4. WriteHuman

WriteHuman targets the simpler end of the market. It’s a straightforward tool designed to take AI-generated drafts and "scrub" them of robotic markers. It is highly effective for short-form content like emails and social media posts.

Pros

Simplicity: Very easy to use with a clean web interface.
Reliability: Consistent results for standard prose.

Cons

Limited Styles: Offers fewer customization options compared to the top picks.
Basic API: The API lacks the granular control (like style selection) found in more robust offerings.

5. HIX Bypass

HIX Bypass uses a multi-model approach to humanize text. It essentially runs the input through several different transformation layers to ensure it bypasses "Enterprise-grade" AI detectors.

Pros

Multi-Mode: Offers different "Bypass" intensities.
Global Support: Handles multiple languages better than most.

Cons

Price: One of the most expensive entry points for a monthly subscription.
Overkill: For many developers, the complexity of the multi-model approach results in unnecessary latency and cost.

Implementation Example: AI Text Humanizer API

Because the AI Text Humanizer API is our top pick for 2026, here is how you can implement it in your stack using JavaScript (Node.js) and Python.

Node.js (JavaScript)

const axios = require('axios');

async function humanizeText(input) {
    const url = 'https://george-the-developer--ai-text-humanizer-api.apify.actor/humanize';
    const token = 'YOUR_APIFY_TOKEN';

    try {
        const response = await axios.post(url, {
            text: input,
            style: 'blog' // Options: creative, formal, casual, blog, technical
        }, {
            headers: { 'Authorization': `Bearer ${token}` }
        });

        console.log('Humanized Text:', response.data.humanizedText);
    } catch (error) {
        console.error('Error humanizing text:', error);
    }
}

humanizeText("AI provides significant benefits to modern business operations.");

Python

import requests

def humanize_text(input_text):
    url = "https://george-the-developer--ai-text-humanizer-api.apify.actor/humanize"
    headers = {
        "Authorization": "Bearer YOUR_APIFY_TOKEN",
        "Content-Type": "application/json"
    }
    data = {
        "text": input_text,
        "style": "casual"
    }

    response = requests.post(url, json=data, headers=headers)

    if response.status_code == 200:
        print("Humanized Text:", response.json().get("humanizedText"))
    else:
        print("Error:", response.status_code, response.text)

humanize_text("The implementation of artificial intelligence facilitates improved efficiency.")

Pricing Comparison: Unit Cost vs. Subscription

When choosing an AI text humanizer API in 2026, the pricing structure is often more important than the sticker price.

Pay-as-you-go (AI Text Humanizer API): You pay $0.003 per request. If you process 1,000 texts a month, you pay $3.00. This is ideal for developers and startups scaling their usage.
Subscription (Quillbot, Undetectable.ai): You pay a flat $10–$15 monthly fee. This is great for casual users who do a lot of manual rewriting through a web interface but can become a bottleneck for automated systems that require high volume.

Verdict: Which Humanize AI Text API Should You Use?

For Developers & High-Volume Apps: Choose AI Text Humanizer API. The sub-500ms latency and $0.003 unit cost are unbeatable for production environments.
For Manual Writing & Students: Choose Quillbot. Its browser extension and writing suite are perfectly tuned for individual productivity.
For Maximum Detection Bypass: Choose Undetectable.ai or HIX Bypass. If your only goal is passing a specific AI detector and you don't mind the 5+ second wait, these tools are built for that specific battle.

Final Thought: The "Best AI Humanizer API" for your project depends on your latency requirements. If you need speed and predictability, the 12-pass algorithmic approach is the gold standard for 2026.

One API Call to Analyze Any Website: Tech Stack, SEO, Contacts and More

George Kioko — Mon, 23 Mar 2026 11:06:59 +0000

I got tired of calling 7 different APIs just to understand a single website. So I built one that does everything in a single call.

Historically, getting a complete picture of a website required a "Frankenstein" stack of integrations. You would need one API for tech stack detection (like Wappalyzer), another for SEO metrics, a third for email/contact scraping, a fourth for WHOIS data, and yet another to clean the HTML into Markdown for your LLMs.

Managing seven different API keys, seven different billing cycles, and seven different JSON formats is a developer's nightmare. It introduces latency, increases costs, and creates multiple points of failure.

Enter the WebSight API. Hosted on the Apify platform, this tool collapses those seven layers into a single, high-performance API call. In this tutorial, we will explore how to use the WebSight API to extract tech stacks, SEO audits, contacts, and AI-ready content in one go.

The Problem: The Seven-API Burden

Before we dive into the solution, let's look at what developers typically have to juggle to get comprehensive website intelligence:

Tech Stack Detection: Identifying if a site uses React, Shopify, or WordPress.
SEO Audit: Checking meta tags, H1 headers, and internal link structures.
Contact Extraction: Finding emails, LinkedIn profiles, and Twitter handles.
Structured Data: Parsing JSON-LD or Microdata for products or events.
AI Content Scoring: Determining the readability and "human-ness" of the content.
Domain Intel: Checking SSL status, WHOIS records, and server location.
Clean Content Extraction: Converting messy HTML into clean Markdown for GPT-4 or Claude.

Using separate services for these tasks means your application has to wait for seven different round-trips to various servers. WebSight API solves this by performing all these checks server-side in a single execution.

Introducing WebSight API

The WebSight API is a comprehensive website analysis api designed for speed and depth. By calling a single endpoint, you receive a structured JSON object containing everything from the site's underlying framework to the social media profiles of its founders.

Endpoint: https://george-the-developer--websight-api.apify.actor/analyze?url=URL

The 7 Modules of WebSight

Tech Stack Detection API: Identifies over 5,000 technologies, including CMS, UI frameworks, analytics, and payment processors.
SEO Audit API: Provides a real-time health check on title tags, descriptions, canonicals, and image alt texts.
Contact & Social Intel: Scrapes the DOM and headers for emails, phone numbers, and links to platforms like X, LinkedIn, and Instagram.
Structured Data Parser: Extracts and flattens Schema.org data, making it easy to read product prices or review scores.
AI Content Metrics: Scores the content for reading ease and provides a summary of the page's intent.
Infrastructure & Security: Returns SSL details, IP addresses, and hosting providers.
Markdown Engine: Delivers the main content of the page in clean Markdown, stripped of ads and navigation menus—perfect for RAG (Retrieval-Augmented Generation) applications.

Implementation: JavaScript and Python

Integrating WebSight into your workflow is straightforward. Below are examples of how to call the API using the two most popular languages for web automation.

JavaScript (Fetch API)

const analyzeWebsite = async (targetUrl) => {
    const apiEndpoint = \`https://george-the-developer--websight-api.apify.actor/analyze?url=\${encodeURIComponent(targetUrl)}\`;

    try {
        const response = await fetch(apiEndpoint);
        if (!response.ok) throw new Error('Network response was not ok');

        const data = await response.json();
        console.log("Tech Stack:", data.tech_stack);
        console.log("SEO Health:", data.seo.score);
        console.log("Main Content (Markdown):", data.content.markdown.substring(0, 100) + "...");
    } catch (error) {
        console.error("Error analyzing website:", error);
    }
};

analyzeWebsite('https://stripe.com');

Python (Requests)

import requests
import json

def get_website_intel(target_url):
    api_url = f"https://george-the-developer--websight-api.apify.actor/analyze?url={target_url}"

    response = requests.get(api_url)

    if response.status_code == 200:
        data = response.json()

        # Accessing specific modules
        contacts = data.get('contacts', {})
        tech = data.get('tech_stack', [])

        print(f"Emails Found: {contacts.get('emails')}")
        print(f"Technologies: {', '.join(tech[:5])}")

        return data
    else:
        print(f"Failed to retrieve data: {response.status_code}")

intel = get_website_intel('https://stripe.com')

Realistic Output: Analyzing Stripe.com

When you point the WebSight API at a sophisticated site like Stripe.com, you get a glimpse of its true power. Instead of a wall of HTML, you get a clean, actionable website intelligence api response.

JSON Output Fragment (Stripe.com)

{
  "url": "https://stripe.com",
  "status": 200,
  "metadata": {
    "title": "Stripe | Financial Infrastructure for the Internet",
    "description": "Stripe is a suite of APIs powering online payment processing and commerce solutions for internet businesses of all sizes."
  },
  "tech_stack": [
    "React",
    "Next.js",
    "Stripe Payments",
    "Amazon Web Services",
    "Google Analytics",
    "Marketo",
    "HSTS"
  ],
  "seo": {
    "score": 94,
    "h1_count": 1,
    "missing_alt_tags": 0,
    "is_mobile_friendly": true,
    "sitemap_found": true
  },
  "contacts": {
    "emails": ["support@stripe.com", "sales@stripe.com"],
    "social": {
      "twitter": "https://twitter.com/stripe",
      "linkedin": "https://linkedin.com/company/stripe",
      "github": "https://github.com/stripe"
    }
  },
  "infrastructure": {
    "ip": "3.233.126.24",
    "provider": "Amazon Data Services",
    "ssl_expiry": "2025-12-01T00:00:00Z"
  },
  "content": {
    "word_count": 1240,
    "readability_score": "College Level",
    "markdown": "# Financial infrastructure for the internet..."
  }
}

Key Use Cases

1. Competitive Intelligence

Monitor your competitors' tech stacks. Did they just switch from Shopify to Next.js? Are they using a new A/B testing tool? WebSight API allows you to track these changes at scale without manual inspection.

2. Hyper-Targeted Lead Generation

For B2B companies, the "Tech Stack Detection API" is a goldmine. If you sell a React performance monitoring tool, you can use WebSight to find every company in a specific niche that is using React and has a low SEO score, then reach out to them via the extracted emails.

3. SEO Auditing at Scale

Instead of running a manual audit tool for every new client, agencies can programmatically generate a health report in seconds. By checking meta tags, H1s, and site speed indicators in one call, you can provide instant value during discovery calls.

4. Giving AI Agents "Eyes"

If you are building an AI agent that needs to "browse" the web, providing it with raw HTML is expensive and noisy. WebSight API provides the AI with clean Markdown and structured metadata. This reduces token usage and improves the accuracy of the AI's summaries and actions.

Conclusion

The era of fragmented web scraping is over. By consolidating tech detection, SEO auditing, contact extraction, and content cleaning into a single website analysis api, the WebSight API allows developers to focus on building features rather than managing infrastructure.

Whether you are building the next big SaaS or a simple automation script, the ability to get 360-degree website intelligence with one API call is a game-changer for your development velocity.

Ready to try it? Head over to the WebSight API on Apify and start analyzing.

How to Detect AI-Generated Text with a Free API

George Kioko — Mon, 23 Mar 2026 11:06:02 +0000

Everyone's arguing about whether AI detectors work. I built one as an API and here's what I learned about what actually triggers them.

With LLMs generating a huge chunk of web content, the ability to distinguish between a human's lived experience and a machine's statistical average has become a survival skill for developers, editors, and SEOs.

Whether you're building a content moderation tool, verifying freelance submissions, or just trying to keep your "human-only" community actually human, you need a reliable way to spot the bots. But here's the kicker: most "premium" detectors like GPTZero or Originality.ai are expensive black boxes. You send text, get a percentage, and have no idea why it was flagged.

Today, we're looking at a different approach—a math-based, transparent detection system accessible via a simple API.

Why AI Detection Matters in 2026

Search Engine Trust: Google and Bing have moved beyond "is it AI?" to "is it helpful?". However, pure AI text often lacks the "Information Gain" that search engines now prioritize.
Brand Integrity: If your blog starts sounding like a generic support manual, you lose your audience.
Academic & Professional Integrity: In a world of "vibe coding" and automated reports, knowing the source of a document is about accountability.

The 9-Factor Scoring System: How the API Thinks

Most detectors try to use another AI to catch the first AI. It's "poison vs. poison." This API uses a different philosophy: Statistical Fingerprinting. It analyzes 9 specific linguistic signals that machines consistently fail to replicate.

Sentence Length Uniformity: AI loves the middle ground. Humans write 5-word punches followed by 40-word explanations. AI stays in the 15-25 word "safe zone."
AI Phrase Density: Tracks the "tell-tale" transitions like furthermore, it is worth noting, and in the realm of.
Vocabulary Diversity: AI uses high-probability words. Humans use "jagged" vocabulary with unexpected synonyms.
Starter Diversity: Machines often start 60% of sentences with "The," "It," or "This." Humans vary their sentence openings significantly more.
Paragraph Uniformity: Analyzes if paragraphs are eerily similar in structure and length.
Comma Patterns: AI tends to use commas with mathematical precision (e.g., always after introductory phrases), whereas human punctuation is more stylistic.
Burstiness: This is the "rhythm" of the text. Human writing has high variance in consecutive sentence lengths (bursts of info). AI is smooth and monotone.
Readability Grade Targeting: Most LLMs default to a grade 8-12 reading level. Human text is wildly inconsistent, ranging from grade 4 to 16+.
Structure Repetition: Detects if the underlying "template" of sentences (Noun-Verb-Adjective) repeats too frequently.

Calling the API: Code Examples

The endpoint we're using is hosted on Apify: https://george-the-developer--ai-text-humanizer-api.apify.actor/detect. It's a POST request that expects a JSON body with a text field.

JavaScript (Fetch API)

const detectAI = async (content) => {
  const response = await fetch('https://george-the-developer--ai-text-humanizer-api.apify.actor/detect', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ text: content })
  });

  const result = await response.json();

  console.log(`AI Score: ${result.ai_score}%`);
  console.log(`Verdict: ${result.verdict}`);
  console.log(`Confidence: ${result.confidence}`);
};

const myText = "In the rapidly evolving landscape of AI, it is worth noting...";
detectAI(myText);

Python (Requests)

import requests

def detect_ai_text(text):
    url = "https://george-the-developer--ai-text-humanizer-api.apify.actor/detect"
    payload = {"text": text}

    response = requests.post(url, json=payload)
    data = response.json()

    print(f"Verdict: {data['verdict']}")
    print(f"AI Probability: {data['ai_score']}%")
    print(f"Human Probability: {data['human_score']}%")

sample_text = "I went to the store and bought some milk. It was a sunny day, and I felt great."
detect_ai_text(sample_text)

Reading the Results: AI vs. Human

When you call the /detect endpoint, you don't just get a "Yes/No." You get a weighted analysis.

Sample AI Output (GPT-4o):

AI Score: 82%
Verdict: ai_generated
Details: High uniformity (22.5), low burstiness, and 4 flagged phrases (delve into, tapestry, landscape).

Sample Human Output:

AI Score: 14%
Verdict: human_written
Details: High burstiness (35.2 variance), varied starters, and 0 flagged AI phrases.

The beauty of this 9-factor system is that it's harder to "prompt engineer" your way around it. Even if you tell an AI to "be creative," its underlying statistical distribution of sentence lengths and comma placements usually gives it away.

The Antidote: The Humanizer Endpoint

If you're on the other side of the fence—perhaps you're a writer using AI to brainstorm but want to ensure your final draft doesn't trigger every detector on the planet—the same API offers a "humanize" endpoint.

While the /detect endpoint finds the patterns, the /humanize endpoint breaks them. It injects burstiness, varies the sentence structures, and swaps out the "robot vocabulary" for something more organic.

Try it out: If your text is getting flagged, hit the humanizer endpoint to see how a few surgical changes in structure can completely shift the statistical fingerprint of your writing.

Conclusion

AI content detection isn't about "banning" AI; it's about transparency. In a world of automated noise, the ability to verify the signal is priceless. By focusing on measurable math—burstiness, uniformity, and phrase density—we can build a more trustworthy web.

Scrape LinkedIn Employees at Scale (Without Getting Banned)

George Kioko — Sun, 22 Mar 2026 10:18:56 +0000

As developers, we've all been there. A client or a marketing team drops a request: "We need a list of employees from these 50 companies." You open LinkedIn, start scrolling, and within minutes you realize this is going to take forever. Worse, LinkedIn starts throwing captchas and login walls at you like you just committed a crime.

I got tired of this cycle, so I built the LinkedIn Company Employees Scraper — and it handles all the messy anti-bot stuff so you don't have to.

The LinkedIn Problem

LinkedIn is notorious for its aggressive anti-scraping measures. If you try to build a scraper from scratch using Selenium or Puppeteer, you'll likely face:

The Login Wall: You need an account, which gets flagged almost immediately.
IP Rate Limiting: Your residential or data center IP is blocked after a few requests.
Session Expiry: Managing cookies and headers is a nightmare.

How It Works

Unlike traditional scrapers that require you to manage your own browser sessions or risk your personal LinkedIn account, this tool operates without login or cookies.

It uses optimized search queries and residential proxies to navigate LinkedIn's public pages. It can handle pagination across thousands of employees, extracting:

Full Names
Job Titles
Locations
LinkedIn Profile URLs

By offloading the anti-bot bypass logic to the Apify platform, you can focus on what matters: the data.

Implementation in JavaScript

Integrating this into your workflow is straightforward. You can use the apify-client\ package to trigger the scraper and fetch results in just a few lines of code.

\`javascript
const { ApifyClient } = require('apify-client');

const client = new ApifyClient({
token: 'YOUR_APIFY_TOKEN',
});

(async () => {
const input = {
companyUrls: ["https://www.linkedin.com/company/google/"],
maxItems: 100,
};

const run = await client.actor("george.the.developer/linkedin-company-employees-scraper").call(input);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

})();
`\

Real Stats & Social Proof

I'm a big believer in building in public. Since launching this tool, it has seen incredible traction within the developer community. As of today, the scraper has:

99 active users
1,077 successful runs

These aren't just vanity metrics; they represent hundreds of hours saved by developers who no longer have to manually copy-paste data or fix broken scraper scripts.

Pricing

Scaling shouldn't break the bank. I've priced this tool to be accessible for both solo developers and large enterprises.

Cost per run: $0.005

For less than a penny per run, you get clean, structured JSON data without the headache of infrastructure maintenance.

Get Started

Ready to automate your LinkedIn data extraction? You can find the actor, read the full documentation, and start your first run here:

LinkedIn Company Employees Scraper on Apify

Happy scraping!

Stop Hunting for B2B Data: How to Automate Company Enrichment in JavaScript

George Kioko — Sun, 22 Mar 2026 10:18:02 +0000

If you've ever built a CRM, a lead gen tool, or any kind of B2B sales dashboard, you've probably hit this wall before: you have a pile of company domains, but zero context behind them. No industry data, no headcount, no social links, no HQ address. Just... domains. And manually Googling each one? Nobody has time for that.

That's exactly why I built the Company Enrichment API — to turn a raw domain into a full company profile, programmatically.

The Problem: The Stale Data Trap

Data decays fast. A company that was "11-50 employees" last year might be 200+ today. If your sales team is working off spreadsheets or static databases, they are losing deals before they even send the first email.

Most "enrichment" services are either:

Overpriced: Charging thousands in annual contracts.
Rigid: Hard to integrate into a custom CI/CD or data pipeline.
Incomplete: Missing the "long tail" of smaller startups or international firms.

How it Works

The Company Enrichment API acts as a bridge between a simple domain name and a full-scale corporate profile. When you pass a URL to the API, it crawls publicly available sources, business directories, and social signals to synthesize a structured JSON object.

It's built on top of the Apify platform, meaning it benefits from industrial-grade browser rotation and proxy management — so you don't get blocked while gathering data.

JavaScript Implementation

Integrating this into your Node.js backend is straightforward. Here is how you can enrich a company profile using the apify-client\ library:

\`javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({
token: 'YOUR_APIFY_TOKEN',
});

const input = {
"domains": ["apify.com", "stripe.com"],
"maxResults": 10
};

(async () => {
const run = await client.actor("george.the.developer/company-enrichment-api").call(input);
const { items } = await client.dataset(run.defaultDatasetId).listItems();

items.forEach((item) => {
    console.log(\`Company: \${item.name}\`);
    console.log(\`Industry: \${item.industry}\`);
    console.log(\`Socials: \${item.linkedinUrl}\`);
});

})();
`\

Real Stats & Performance

Since its launch, the API has been gaining steady traction among developers who need reliable B2B data without the enterprise bloat.

Current Users: 10 Active Developers
Total Runs: 230 successful enrichments
Reliability: Built on the Apify SDK for 99.9% uptime.

Pricing

Forget $5k/year minimums. The Company Enrichment API operates on a Pay-As-You-Go model via the Apify platform. You only pay for the compute resources you actually use.

Get Started

Ready to stop manually copying and pasting from LinkedIn? Try it out directly in the browser or via the API console.

Check it out here: Company Enrichment API on Apify

Happy hacking!