Find Jobs on Twitter: How I Built a Hiring Scraper

Daniel Kolbassen — Wed, 06 May 2026 08:11:31 +0000

How to Find Jobs on Twitter When LinkedIn Fails You

Key Takeaway: The fastest way to find jobs on Twitter is to search for hiring keywords ("we are hiring", "open role", "looking for a [role]") combined with your niche, then run that search on a schedule and filter out noise. A small custom scraper hitting Twitter's search results every 30 minutes will surface real openings days before they hit LinkedIn or Wellfound, and most of the postings that matter in data, Web3, and AI never reach those boards at all.

A friend of mine, a junior data engineer, got laid off in early 2024. He spent three weeks on LinkedIn, Wellfound, and AngelList, applied to roughly 80 roles, and got back four auto-rejections and silence. I'd been telling him for months that the actually-good roles in our world were closing inside Twitter threads before they were ever posted, but you can't really "browse" Twitter for jobs. There's no filter for "people who are hiring right now." So one Saturday I sat down and built him one.

Six weeks later he had an offer from a Series B crypto data infrastructure company. The scraper had surfaced about 140 hiring threads in his niche, he'd messaged 11 of them, and one converted. Total infrastructure cost: $49, paid to Sorsa API for the Starter plan. This article is the build log: the keyword set, the code, the filtering rules, and the structural reasons Twitter ended up working when the job boards didn't.

A quick note before we dig in. I've been writing about Twitter/X data pipelines for years. I'm Daniel Kolbassen, a data engineer and API consultant in Austin. I've worked with Twitter's API since the v1.1 days and have helped 40+ companies migrate off the official API since the 2023 pricing reset. Sorsa API, which I'll use throughout this article, is also our product, so factor that in when reading the cost comparisons. The technique itself works with any source of Twitter data; the API choice is a cost decision.

Why Twitter is a real hiring channel for data, Web3, and AI
Why the official X API wasn't an option
How the scraper works (architecture overview)
Building the scraper step by step
What it cost
What actually happened
FAQ
How to try this yourself

Why is Twitter the Real Hiring Channel for Data, Web3, and AI?

A surprising share of senior and mid-level roles in data, Web3, and AI infrastructure are filled before the job description ever lands on LinkedIn. The hiring manager posts a "we're hiring a data engineer, DM if interested" thread, the replies fill up within hours, and the role closes from inside that thread.

Three structural reasons:

Speed beats process. Small teams hiring engineer #4 don't want a six-week funnel. They want someone who already follows the right people, gets the product, and can start in two weeks. A tweet does that filtering for free.
Trust beats credentials. In Web3 and AI infra, "who you follow and who follows you back" is a stronger signal than a resume. Hiring inside the network is an explicit strategy. The 2024 Stack Overflow Developer Survey showed referrals and personal networks remained the dominant route into developer roles, and Twitter is where a lot of those networks actually meet.
Job boards have an attention tax. A Wellfound posting attracts hundreds of applicants, most low-signal. Twitter is the opposite default: high-signal, no spam filter needed because the cost of replying publicly is real.

The catch is that Twitter has no built-in job board view. The information is there, but it's spread across millions of tweets per day. That's where a scraper earns its keep.

Why I Didn't Use the Official X API

I considered the official X API for about ten minutes. As of 2026, the X Developer Platform's pay-per-use model means search at scale gets expensive fast, and historical search is gated behind enterprise tiers that don't make sense for a personal job-hunting tool. We covered the full pricing breakdown in our 2026 X API pricing analysis, but the short version: paying $200+ a month to look for a job is absurd.

Sorsa API hit the right tradeoff. The Starter plan is $49 a month for 10,000 requests, all endpoints included, with a flat 20 requests per second rate limit. No OAuth, no app approval, no waitlist. I bought a key on Saturday morning, had the first search query running by lunch.

Disclosure: Sorsa API is our product. The choice of provider isn't the point of this article; if you prefer a different Twitter data source, the architecture below works on anything that exposes a search endpoint.

How the Scraper Works (60-Second Architecture Tour)

The whole system is four moving parts:

A keyword catalog. Hiring phrases ("we are hiring", "open role") cross-multiplied with niche terms ("data engineer", "dbt", "snowflake"). Roughly 30-40 distinct queries.
A search loop. Every 30 minutes, hit the Sorsa search endpoint once per query, ordered by latest.
A filter pass. Drop retweets, accounts with no followers, obvious shitposts, and anything we've already seen.
A notification. Push the survivors to a Slack channel (or Telegram, or just print to a terminal). The tweet URL goes in the message so you can read context and reply directly.

That's it. No vector database, no LLM ranking, no front-end. The whole thing is one Python file and a SQLite database. I'll show the code below.

Building the Scraper, Step by Step

Step 1: Get an API Key

Sign up at api.sorsa.io, pick the Starter plan, copy your key from the dashboard. Authentication is a single header: ApiKey: your_key_here. The full authentication doc is one page. This part takes about two minutes.

Step 2: Define Your Hiring Keyword Set

This is where most people screw up. If you only search "we are hiring", you'll drown in startup announcements that aren't relevant. The fix is to cross-multiply hiring phrases with niche-specific terms.

Here's the keyword config my friend used. Replace the NICHE_TERMS with whatever describes the job you actually want.

# config.py

HIRING_PHRASES = [
    '"we are hiring"',
    '"we\'re hiring"',
    '"now hiring"',
    '"looking for a"',
    '"open role"',
    '"open position"',
    '"join our team"',
    '"hiring a"',
]

# Edit these for your niche.
NICHE_TERMS = [
    "data engineer",
    "dbt",
    "snowflake",
    "airflow",
    "etl pipeline",
    "analytics engineer",
]

# Optional: minimum signal threshold
MIN_AUTHOR_FOLLOWERS = 50

The combinatorics give you about 50 unique queries. At one request per query every 30 minutes, that's 2,400 requests per day, well inside the 10,000-per-month Starter quota if you tighten the schedule a bit (we ran every two hours instead).

Step 3: Hit the Search Endpoint

Sorsa's /search-tweets endpoint accepts the same operator syntax as Twitter's advanced search, so you can layer in filters directly in the query string. The full operator list is in the search operators reference; the ones we care about are exact-phrase quotes, min_faves:, and lang:en.

# scraper.py

import os
import requests

API_KEY = os.environ["SORSA_API_KEY"]
BASE_URL = "https://api.sorsa.io/v3"

def search_tweets(query: str, order: str = "latest"):
    """Hit Sorsa /search-tweets and return the tweet list."""
    response = requests.post(
        f"{BASE_URL}/search-tweets",
        headers={"ApiKey": API_KEY},
        json={"query": query, "order": order},
        timeout=15,
    )
    response.raise_for_status()
    return response.json().get("tweets", [])

def build_query(hiring_phrase: str, niche_term: str) -> str:
    return f'{hiring_phrase} {niche_term} lang:en min_faves:1'

The min_faves:1 filter alone removes about a third of the spam. It costs nothing because Sorsa charges per request, not per result.

Step 4: Filter the Noise

Even with operators, you'll get garbage: scam recruiters, MLM pitches, people quoting other hiring tweets ironically. A short filter function handles 95% of it.

# filter.py

import re

SPAM_PATTERNS = [
    re.compile(r"dm me to earn", re.I),
    re.compile(r"(?:🔥|🚀|💰){4,}"),
    re.compile(r"https?://\S*\.(?:tk|ml|ga|cf)\b", re.I),
]

def is_real_hiring(tweet: dict, min_followers: int = 50) -> bool:
    if tweet.get("retweeted_status"):
        return False
    text = tweet.get("full_text", "")
    if any(p.search(text) for p in SPAM_PATTERNS):
        return False
    user = tweet.get("user", {})
    if user.get("followers_count", 0) < min_followers:
        return False
    if tweet.get("is_reply") and tweet.get("reply_count", 0) == 0:
        return False
    return True

Two notes on the rules. First, the followers threshold is the single highest-signal filter; bots and scam accounts almost always have fewer than 50 followers. Second, dropping replies that have no further replies removes "me too, hire me" comments without losing genuine hiring threads (those almost always accumulate replies fast).

Step 5: Deduplicate

You'll see the same tweet on multiple queries. SQLite is overkill but takes 10 lines and never fails.

# storage.py

import sqlite3

def open_db(path: str = "jobs.db"):
    db = sqlite3.connect(path)
    db.execute("""
        CREATE TABLE IF NOT EXISTS seen (
            id TEXT PRIMARY KEY,
            seen_at TEXT NOT NULL
        )
    """)
    return db

def is_new(db, tweet_id: str) -> bool:
    cur = db.execute("SELECT 1 FROM seen WHERE id = ?", (tweet_id,))
    return cur.fetchone() is None

def mark_seen(db, tweet_id: str, seen_at: str):
    db.execute("INSERT OR IGNORE INTO seen VALUES (?, ?)", (tweet_id, seen_at))
    db.commit()

Step 6: Schedule It and Pipe to Slack

The main loop ties it together. Run it under cron, systemd, or just a while True: time.sleep(7200) if you don't care about elegance.

# main.py

import time
from datetime import datetime, timezone

from config import HIRING_PHRASES, NICHE_TERMS
from scraper import search_tweets, build_query
from filter import is_real_hiring
from storage import open_db, is_new, mark_seen

SLACK_WEBHOOK = "https://hooks.slack.com/services/..."  # optional

def notify(tweet: dict):
    user = tweet["user"]["username"]
    msg = (
        f"*@{user}* ({tweet['user']['followers_count']} followers)\n"
        f"{tweet['full_text'][:280]}\n"
        f"https://x.com/{user}/status/{tweet['id']}"
    )
    print(msg, "\n")
    # requests.post(SLACK_WEBHOOK, json={"text": msg})

def run_once():
    db = open_db()
    now = datetime.now(timezone.utc).isoformat()
    for phrase in HIRING_PHRASES:
        for niche in NICHE_TERMS:
            query = build_query(phrase, niche)
            try:
                tweets = search_tweets(query)
            except Exception as e:
                print(f"skip {query!r}: {e}")
                continue
            for t in tweets:
                if not is_real_hiring(t) or not is_new(db, t["id"]):
                    continue
                mark_seen(db, t["id"], now)
                notify(t)
            time.sleep(0.5)  # be polite, stay under 20 req/s

if __name__ == "__main__":
    run_once()

That's the whole system. About 120 lines total. If you've followed our Twitter API in Python guide, the patterns will look familiar; this is the same plumbing applied to a hiring use case.

What It Cost

Six weeks of running the scraper every two hours, across 50 queries, used roughly 8,400 requests. That fit comfortably inside the Starter plan's 10,000-request monthly allowance. Total spend: $49 for the first month, $49 for the second, then he canceled. So $98 for the entire job hunt.

For context, tech recruiters in the US typically charge 20-25% of first-year salary as a placement fee, which on a $130K data engineer salary is $26K-$32K. The math is comically lopsided. Even if the scraper had only marginally helped (it did more than that), the ROI would have been absurd.

A quick rate-limit note: Sorsa's flat 20 requests per second is plenty for this workload, since the loop sends about one request per second at most. If you parallelized aggressively across many keyword sets, the rate limits doc explains how to request a higher cap, but you almost certainly won't need it for a personal scraper.

What Actually Happened

I want to be careful with this section, because "I built a tool and got rich" stories are usually lies. Here's the unembellished version.

In six weeks of running, the scraper surfaced 142 unique tweets that survived the filter. About 30 of those were genuine hiring posts in his niche; the rest were tangentially related (companies hiring "data" roles that turned out to be marketing analytics, recruitment agency posts, etc.). My friend cold-replied to 11 threads. He got responses from 6, made it to interviews with 3, and took an offer from a Series B crypto data infrastructure company eight weeks after we started.

Two things were notable. First, the offer came from a posting he never would have seen otherwise: the founder tweeted it, got 14 replies in two hours, and never posted it on a job board. Second, the median time between a hiring tweet appearing and the role being effectively closed (founder stopped responding to new replies) was about 36 hours. Speed mattered. The scraper hitting every two hours meant he was usually in the first 10 replies, not the 80th.

The technique generalizes. Swap the niche keywords for "solidity engineer" or "ML researcher" or "rust developer" and the same approach surfaces roles in those worlds. The bottleneck isn't the tool; it's the keyword discipline.

FAQ

Can I find jobs on Twitter without using an API?

Yes, but it doesn't scale. Twitter's built-in search lets you query "we are hiring data engineer" manually, and you can pin a search column in TweetDeck or use the advanced search interface. The problem is that you need to be looking at the screen at the right moment. A scraper running every 30 minutes catches tweets you'd miss while sleeping or in a meeting, and the dedupe layer means you don't re-read the same tweet 40 times.

What hashtags are best for finding jobs on Twitter?

#hiring, #nowhiring, #jobopening, and niche-specific tags like #web3jobs, #dataengineering, or #mljobs work, but hashtags alone are noisier than phrase searches. Most genuine hiring tweets in technical fields don't use hashtags at all; they're written in natural language. The "we are hiring" phrase search outperforms hashtag searches by roughly 3-to-1 in our experience.

Is the X API free?

No. As of 2026, the official X API has no permanent free tier for new developer access. The cheapest paid tier still runs into significant monthly costs once you do meaningful search volume. We laid out the current pricing in our Twitter API alternative comparison. For a job-hunting tool, the official pricing model doesn't make sense; this is exactly the use case third-party APIs are built for.

What companies hire through Twitter?

Mostly small to mid-size technical companies in areas where the founder is technical and active on the platform: Web3 protocols, AI infrastructure, dev tools, data infrastructure, devrel-heavy SaaS. Larger companies (Google, Meta, etc.) post on LinkedIn first because they have HR processes that demand it. Twitter hiring skews toward seed-to-Series-B startups, which is also where the most interesting roles tend to be in 2026.

How do I avoid scams when replying to hiring tweets on Twitter?

Three checks before replying: (1) does the company exist with a website older than three months, (2) is the person tweeting actually associated with the company (check their pinned tweet and bio), (3) does the role description name a real tech stack, not just buzzwords. Scam "hiring" posts almost always fail check 2; real founders link their own company in their bio. The followers filter in the scraper above already kills most scam accounts before you ever see them.

Can I scrape Twitter without an API at all?

Technically yes; in practice, no. Headless-browser scrapers against the X.com web interface get rate-limited or blocked within hours, and the legal terrain is murky. We've covered the tradeoffs in detail, but the short answer is that paying $49 a month for a stable API is worth it compared to babysitting a fragile scraper that breaks every time X ships a UI change.

How long should I run a job scraper before deciding it works?

Three to four weeks. The first week is mostly tuning: you'll discover that some keyword combinations return pure noise and others surface gold, and you'll iterate the filter rules. By week two the signal-to-noise ratio stabilizes. By week four you'll have a sense of how often roles in your niche actually get tweeted. If after a month you're seeing fewer than five real hiring posts a week in your niche, the niche probably doesn't hire on Twitter and you should shift channels.

How to Try This Yourself

If you want to run this scraper, the four things you need are: a Sorsa API key, Python 3.10+, a niche keyword list that actually describes the role you want, and the patience to let it run for a few weeks. The full code above is copy-paste ready; the only edit is the NICHE_TERMS list and your API key.

A few starting points if you're new to the API:

The quickstart guide walks through your first request in under five minutes.
The API playground lets you test search queries in the browser without writing code, useful for tuning your keyword set before you build anything.
The search operators reference is the cheat sheet for getting cleaner results out of /search-tweets.

This isn't a magic system. It's a small piece of plumbing that does what manual searching can't: catch hiring tweets the moment they appear, filter the obvious garbage, and dedupe across multiple keyword angles. Whether you find a job depends on the quality of your replies, your portfolio, your timing. But finding the right tweets to reply to in the first place is solvable, and at $49 a month it's solved cheaply.

Daniel Kolbassen is a data engineer and API infrastructure consultant in Austin, TX, with 12+ years of experience building data pipelines around social media platforms. He has worked with the Twitter/X API since the v1.1 era and has helped over 40 companies restructure their data infrastructure after the 2023 pricing overhaul.

Last updated: May 6, 2026.

DEV Community: Daniel Kolbassen