DEV Community: Henry Knight

How I Built a Reddit Karma Bot with Claude API and CDP Browser Automation

Henry Knight — Sun, 07 Jun 2026 18:15:48 +0000

Reddit is one of the hardest platforms to automate. Shadowbans, karma gates, rate limits, fingerprint checks. I spent two weeks building a Reddit automation system using Chrome DevTools Protocol (CDP) and the Claude API, and here are the exact patterns that worked.

Why CDP Instead of Playwright or Selenium

Most tutorials reach for Playwright. It works great for testing, but it announces itself. Reddit detects navigator.webdriver, checks timing patterns, and analyzes mouse movement entropy.

CDP gives lower-level control. Connecting directly to a running Chrome instance (not spawned by automation) gives you a real browser profile with real history, cookies, and hardware fingerprints.

import subprocess, requests

# Launch Chrome with remote debugging - NOT via Playwright
chrome_proc = subprocess.Popen([
    "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
    "--remote-debugging-port=9222",
    "--user-data-dir=/tmp/reddit-session",
])

# Connect directly
targets = requests.get("http://localhost:9222/json").json()
ws_url = targets[0]["webSocketDebuggerUrl"]

Reddit sees a real Chrome install, not a puppeteer-spawned chromium binary.

Claude API as a Decision Layer

The hard problem is not navigation - it is knowing what to do. Karma grows through genuinely useful comments. Posting platitudes gets you shadowbanned in hours.

I wired Claude as a reasoning layer. For each post, the bot sends title, top comments, and subreddit context:

from anthropic import Anthropic
import json

client = Anthropic()

def should_comment(post_title, top_comments, subreddit):
    prompt = (
        f"Subreddit: r/{subreddit}\n"
        f"Post: {post_title}\n"
        f"Top comments: {top_comments}\n\n"
        "Should I comment? Only if I add genuine value. "
        "Return JSON: should_comment (bool), comment (str or null), reasoning (str)."
    )
    resp = client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=512,
        messages=[{"role": "user", "content": prompt}]
    )
    return json.loads(resp.content[0].text)

This single call separates a bot banned in 24 hours from one that survives weeks. Claude catches bot-sounding patterns that rule-based filters miss.

Detection Evasion: What Actually Works

1. Timing entropy. Bots type at consistent speeds. Humans do not. I added Gaussian-distributed delays between keystrokes (mean 80ms, sigma 30ms):

import random, time

def human_type(ws, text):
    for char in text:
        send_cdp(ws, "Input.dispatchKeyEvent", {"type": "keyDown", "text": char})
        time.sleep(abs(random.gauss(0.08, 0.03)))
        send_cdp(ws, "Input.dispatchKeyEvent", {"type": "keyUp", "text": char})

2. Scroll behavior. Reddit JS watches scroll patterns. I implemented smooth scrolling with pause durations proportional to estimated reading time.

3. Session aging. New accounts are suspect. I built a warmup phase: browse r/all for 20 minutes, upvote some posts, read threads before ever posting. Claude selects which posts to touch so the pattern looks organic.

4. Network fingerprinting. Reddit checks TLS fingerprints. A raw Python requests call looks nothing like Chrome. Routing API calls through the browser via CDP Network interception matches the fingerprint exactly.

Architecture

Task Queue      <- target subreddits and goals
     |
CDP Controller  <- real Chrome, human-like inputs
     |
Claude API      <- decides what is worth saying
     |
Action Logger   <- SQLite, records outcomes, feeds back

The logger matters long-term. Every comment, upvote received, shadowban - all in SQLite. The system learns which subreddits respond well and which comment styles land. What starts as a bot becomes a feedback loop.

What I Learned

The hardest part was not the code. It was understanding why each detection layer exists and addressing the underlying signal. Reddit does not ban you for using CDP - it bans you for behaving like a bot. The fix is behavioral, not technical.

Claude as a reasoning layer turned scripted automation into something closer to a judgment system. It reads context, decides whether a comment is worth making, and generates text that does not sound machine-generated - because it is not.

Get the full toolkit at https://payhip.com/b/GuYx8

How I Built a Reddit Karma Bot with Claude API and CDP Browser Automation

Henry Knight — Sun, 07 Jun 2026 16:52:04 +0000

Why CDP Instead of Playwright or Selenium

Most tutorials reach for Playwright. It works great for testing, but it announces itself. Reddit detects navigator.webdriver, checks timing patterns, and analyzes mouse movement entropy.

CDP gives lower-level control. Connecting directly to a running Chrome instance (not spawned by automation) gives you a real browser profile with real history, cookies, and hardware fingerprints.

import subprocess, requests

# Launch Chrome with remote debugging - NOT via Playwright
chrome_proc = subprocess.Popen([
    "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
    "--remote-debugging-port=9222",
    "--user-data-dir=/tmp/reddit-session",
])

# Connect directly
targets = requests.get("http://localhost:9222/json").json()
ws_url = targets[0]["webSocketDebuggerUrl"]

Reddit sees a real Chrome install, not a puppeteer-spawned chromium binary.

Claude API as a Decision Layer

The hard problem is not navigation - it is knowing what to do. Karma grows through genuinely useful comments. Posting platitudes gets you shadowbanned in hours.

I wired Claude as a reasoning layer. For each post, the bot sends title, top comments, and subreddit context:

from anthropic import Anthropic
import json

client = Anthropic()

def should_comment(post_title, top_comments, subreddit):
    prompt = (
        f"Subreddit: r/{subreddit}\n"
        f"Post: {post_title}\n"
        f"Top comments: {top_comments}\n\n"
        "Should I comment? Only if I add genuine value. "
        "Return JSON: should_comment (bool), comment (str or null), reasoning (str)."
    )
    resp = client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=512,
        messages=[{"role": "user", "content": prompt}]
    )
    return json.loads(resp.content[0].text)

This single call separates a bot banned in 24 hours from one that survives weeks. Claude catches bot-sounding patterns that rule-based filters miss.

Detection Evasion: What Actually Works

1. Timing entropy. Bots type at consistent speeds. Humans do not. I added Gaussian-distributed delays between keystrokes (mean 80ms, sigma 30ms):

import random, time

def human_type(ws, text):
    for char in text:
        send_cdp(ws, "Input.dispatchKeyEvent", {"type": "keyDown", "text": char})
        time.sleep(abs(random.gauss(0.08, 0.03)))
        send_cdp(ws, "Input.dispatchKeyEvent", {"type": "keyUp", "text": char})

2. Scroll behavior. Reddit JS watches scroll patterns. I implemented smooth scrolling with pause durations proportional to estimated reading time.

Architecture

Task Queue      <- target subreddits and goals
     |
CDP Controller  <- real Chrome, human-like inputs
     |
Claude API      <- decides what is worth saying
     |
Action Logger   <- SQLite, records outcomes, feeds back

What I Learned

If you want the full starter kit with working code, grab it here: https://payhip.com/b/Gu42Y

I built a Claude browser agent that automates Playwright tasks — here's the starter kit

Henry Knight — Sun, 07 Jun 2026 15:09:03 +0000

Browser automation has a dirty secret: the code you write today is already dying.

You spend two hours reverse-engineering a login form. You figure out the exact XPath. You write //div[@class='auth-container']//input[@data-testid='email-field'] and it works. You ship it. You forget about it.

Three weeks later it breaks. The frontend team ran an A/B test and swapped data-testid for id. Or they rolled out a redesign. Or they just changed a class name.

This happens constantly. Most browser automation isn't hard to write — it's hard to maintain.

The Selector Problem

Here's the actual issue: CSS selectors and XPath describe structure, not intent.

When you write #signup-form > .input-wrapper:nth-child(2) > input, you're not saying "fill the email field." You're saying "find an input element that is the second child of a wrapper inside the signup form." The machine knows nothing about what that input does — only where it lives in the DOM.

The moment the DOM changes — and it will — your selector is invalid.

Dynamic IDs make this worse. React, Angular, and Vue all generate class names like _3xR9s or css-1q5f3g. There's no stable handle to grab. You end up chaining 8 selectors together hoping one of them survives the next deploy.

A Different Approach: Describe What You See

What if, instead of describing the DOM structure, you described what you see on screen?

Instead of: //input[@id='email_input_63h2']

You say: "Fill the email address field"

Instead of: button.btn-primary:nth-child(3)

You say: "Click the blue Submit button at the bottom of the form"

This is how vision-based browser automation works. Take a screenshot. Send it to a vision model. Ask it to locate and interact with the element you described in plain English. The model sees exactly what a human sees — layout, labels, colors, context.

The DOM changes. The visual structure mostly doesn't. A blue Submit button is still a blue Submit button after a redesign.

How It Works in Practice

Here's the core of a vision-based interaction module built with Claude's vision API:

from vision_browser import VisionBrowser
from patchright.async_api import async_playwright

async with async_playwright() as p:
    browser = await p.chromium.launch(headless=True)
    page = await browser.new_page()
    await page.goto("https://example.com/signup")

    vb = VisionBrowser(page)

    # Understand the page state first
    state = await vb.understand_page()
    print(state)
    # -> {"title": "Sign Up", "forms": ["email", "username", "password"],
    #     "buttons": ["Sign Up", "Already have an account?"]}

    # Fill fields by description, not selector
    await vb.smart_fill_field("email address field", "user@example.com")
    await vb.smart_fill_field("username or display name", "henry_knight")
    await vb.smart_fill_field("password", "my-secure-pass-123")

    # Click by description
    await vb.smart_click("the Sign Up button")

No selectors. No XPath. No DOM inspection. The agent takes a screenshot at each step, sends it to Claude, and uses the visual response to determine where to click or type.

The Agent Layer

For full browser tasks, wrap this in an agent loop:

// browser-agent.js — simplified
const task = "sign up for an account on example.com with email user@test.com";

// Before starting, check what failed last time
const failureHistory = buildFailureHistory(task);

const prompt = `
Complete this browser task: ${task}

Past failures to avoid:
${failureHistory}

You have access to: take_screenshot, navigate_page, click, fill, evaluate_script.
Screenshot first. Describe what you see. Then act.
`;

spawn('claude', ['-p', prompt, '--permission-mode', 'bypassPermissions']);

The key part is failureHistory — before each run, the agent queries a SQLite database of past attempts, reads what failed and why, and starts with that context. Each run gets smarter.

Handling CAPTCHAs

Vision-based interaction also changes how you handle CAPTCHAs. With traditional selectors, detection usually means looking for a specific iframe ID or class. Fragile. With vision, you ask Claude to describe the page state:

state = await vb.understand_page()

if "captcha" in state.get("obstacles", []):
    captcha_type = state["captcha_type"]  # "press_hold", "image_select", "text", "turnstile"

    if captcha_type == "press_hold":
        await solve_press_hold(page)      # timing algorithm, no API needed
    elif captcha_type == "text":
        answer = await vb.ask_claude_vision(screenshot, "Read and solve this text CAPTCHA")
        await vb.smart_fill_field("captcha answer field", answer)
    else:
        await solve_via_api(page, captcha_type)   # EzCaptcha / 2captcha

Text CAPTCHAs are free — Claude reads them directly. Press-and-hold CAPTCHAs are free — solved with a timing algorithm. Only the hard ones (Arkose Labs, some image grids) require a paid API.

The Memory Layer

The last piece that makes this production-ready is persistence. Every attempt gets logged:

mem = BrowserMemory('/path/to/my.db')

# Before attempting
history = mem.get_site_history('example.com', limit=10)
strategy = mem.suggest_next_strategy('example.com', history)

# After outcome
mem.log_attempt(
    site='example.com',
    strategy_name=strategy,
    outcome='success',
    reasoning='Vision locate worked for all 3 fields. No CAPTCHA encountered.'
)

When the agent runs again against the same site, it reads this history first. It knows which strategies worked, which failed, and why. It doesn't repeat known dead ends.

Getting the Starter Kit

I packaged all of this — vision_browser.py, captcha_brain.py, browser_memory.py, proxy_manager.py, the agent runner, and 3 ready-to-run examples — into a starter kit.

If you're building browser agents and want to skip the parts I already figured out the hard way:

Get the Claude Browser Agent Starter Kit →

$27. Python + Node.js. Production-ready. No XPath required.

Questions or feedback? Drop a comment below — happy to explain any part in more detail.