DEV Community: Rahul Sharma

Surfer SEO Alternatives Worth Testing in a Real Agency Workflow

Rahul Sharma — Fri, 17 Jul 2026 11:45:06 +0000

Eighteen months back, I started looking for Surfer SEO alternatives not because Surfer was bad, but because I was paying for features I never touched while missing things I needed. Running a consultancy with clients in the UK, US, and Australia, every subscription has to earn its place. Surfer made sense at a certain scale, but plenty of my projects didn't sit at that scale.

So I ran tests over a few months: real client briefs, real competition, real deadlines. Not a demo environment. Here's what came out of that.

Why look for Surfer SEO alternatives at all?

Surfer is genuinely good. The editor works, the keyword integration is decent, the AI features have gotten better. But three things kept frustrating me.

The pricing is the first one. The entry-level plan has limits you don't discover until you're already committed, and for an agency handling several clients at once, you hit those limits fast.

Second: the NLP recommendations don't always line up with what's ranking in competitive niches. Surfer gives you a score to optimize toward, but chasing that score doesn't guarantee results. I've watched articles score 80+ and still underperform pages that were optimized without any tool at all. That disconnect is frustrating when you're reporting to clients.

Third thing, and I don't see this brought up much: when you're using Surfer across multiple clients, the content starts feeling formulaic only. Same structure, same flow, same everything. Clients in different industries end up with content that reads like it came from the same mold.

That's basically why I started testing alternatives seriously.

The Surfer SEO alternatives I ran in live work

These aren't impressions from a free trial with practice content. I used each of these on actual client projects over several months.

1. Clearscope

Clearscope is the one I recommend most for clients with larger content budgets. The NLP analysis is better than most tools I've tested, and the interface is clean enough that writers with no SEO background can use it without needing constant support.

The D-through-A++ grading gives writers a clear target to hit, and the term suggestions are relevant, not just keyword variations. From my experience, pages optimized in Clearscope tend to hold rankings more consistently in that 30-90 day window than Surfer-optimized content does.

The issue is cost. $170 to $350 per month depending on the plan, and the per-document model adds up fast if you're producing at volume. For established agencies with retainer clients, the math works. For project-based work, it's a harder sell.

2. Frase

Frase is where I'd start if budget is the main constraint. Around $45/month for the base plan, and it combines research, outlining, and content optimization into one place, which is useful.

The research side is the strongest feature. Frase pulls in competitor content, SERP data, and question-based insights automatically. That saves a meaningful amount of time at the brief-building stage, and for agencies producing content at volume, that time saving alone can justify the cost.

The content optimizer is decent but not as precise as Clearscope. Topic suggestions can be noisy; you'll need to filter manually. For non-hyper-competitive niches, it's good enough. For tough competition, you'll want something more precise.

One note on the AI writing assistant: the output needs significant editing. Use Frase for research and outlining, not for finished content.

3. NeuronWriter

This one surprised me. NeuronWriter is a Polish tool that doesn't get much mention in English-language SEO circles, but the SERP analysis is solid and the pricing is competitive.

You're looking at $19-49/month for competitor content analysis, NLP suggestions, content templates, and internal linking recommendations in one platform. The internal linking feature itself is underrated. It flags relevant content on your site and suggests anchor text, which is a real time-saver for larger operations.

The interface takes some adjustment. It's not as polished as Surfer or Clearscope. But once you know where things are, the workflow is fast. I've used it for clients in health, finance, and education niches with good results.

For solo consultants and small agencies, NeuronWriter probably gives the best value among the Surfer SEO alternatives available right now.

4. PageOptimizer Pro

PageOptimizer Pro is different from the others. It's not a content editor. It's a technical on-page tool that tells you specifically what to change in existing content to improve rankings.

The analysis is granular: it reads what's ranking for your target keyword and tells you how many times to use a given term, where to place it, and which related entities to include. More precise than most content editors, which is both the strength and the limitation.

Where it works best is recovering underperforming pages. A page sitting between positions 8 and 15 can often be pushed into the top five with PageOptimizer Pro's recommendations faster than a full rewrite would achieve. From my experience, it makes most sense as a complement to your workflow rather than a replacement for a full content editor.

Pricing is around $34/month. The interface isn't the most intuitive, but the recommendations are sound once you understand the logic.

5. SEMrush Writing Assistant

If you're already on SEMrush, try the Writing Assistant before adding another tool. It integrates directly with Google Docs and WordPress, which makes it easy to fold into existing client workflows.

The suggestions are adequate for mid-competition content. Readability, tone, and SEO score in real time—useful when you're working with freelance writers who need structured guidance.

It's not a replacement for Clearscope or Frase for serious optimization work. It's a bonus feature on your SEMrush subscription. Lightweight optimization, yes. Competitive content, no.

6. Dashword

Dashword is the simplest tool in this group. Fast, around $39/month, clean reports.

The keyword recommendations are easy to act on, and the lack of features makes it faster to use in practice. No complicated scoring systems, no bloated dashboards.

For agencies that need a basic content editor with a low learning curve, it's a reasonable option. Not for highly competitive keywords; the NLP analysis isn't precise enough for that. But for medium-difficulty content, it does the job.

How to choose between these Surfer SEO alternatives

In practice, I use different tools for different situations.

High-budget retainer clients in competitive niches: Clearscope.

Budget-constrained clients or high-volume content: Frase or NeuronWriter.

On-page audits and recovering underperforming pages: PageOptimizer Pro.

Clients already on SEMrush: Writing Assistant for day-to-day work, then escalate to a dedicated tool if the numbers aren't moving.

Basically, the tool should fit the project. There's no single Surfer SEO alternative that works for everything. I covered the full breakdown with ranking examples from my own client work in Best Surfer SEO Alternatives for SEO Writers and Agencies on Substack, worth reading if you want the data behind these decisions.

What to look for when evaluating alternatives

After testing all of these, a few things matter more than any feature comparison.

Data accuracy. Does the tool reflect what's ranking? Some tools base recommendations on models that don't align with real SERP results. Test it against pages you know before committing.

Writer-friendly interface. If writers or clients are using the tool, it has to be simple enough without constant guidance. Complexity creates friction and errors.

Pricing transparency. In many cases, a tool looks affordable until you hit the document limits or need a feature behind a higher-tier plan. Know the real cost before you sign up.

Rankings over scores. A tool that moves rankings matters more than one that gives your content a high score. Track performance over 60-90 days. That's the only meaningful evaluation.

Final thoughts

These Surfer SEO alternatives aren't fallback options. In many cases they're better choices depending on the project, budget, and content type.

Clearscope for quality. Frase for value. NeuronWriter for cost-conscious operations. PageOptimizer Pro for a specific use case nothing else quite replaces.

Test them on real content before deciding. The free trials are there for exactly this reason.

How Google's helpful content update actually treats AI articles: 6 months of data

Rahul Sharma — Tue, 14 Jul 2026 13:12:36 +0000

December. A client in Melbourne calls me with a very specific complaint.

Six months prior, he'd switched his content team fully to AI-generated articles, no real editing beyond a light proofread. Rankings stayed stable through November. Then a core update hit, and three of his top five pages dropped between 12 and 20 positions in two weeks.

He wanted to know if the Google helpful content update AI articles situation was as bad as people were saying. I told him I'd been tracking this across other clients for a few months already, so I could give him actual numbers, not speculation.

This is what I found.

What I was tracking and why

Six client sites. Two in Australia, two in the UK, one in Canada, one in the US. Niches: legal services, SaaS, home improvement, a few others. Page counts ranged from around 80 to about 400 per site. Traffic tracked through Google Search Console and an independent rank tracker, cross-referenced both.

Each site ran on a different content model:

Sites A and B: Pure AI output. Minimal editing, light formatting tweaks, published mostly as-is.
Sites C and D: AI drafts with serious human editing. Real client examples, case data, original analysis layered in before publishing.
Sites E and F: Hybrid. Some pages fully human-written, some AI-assisted and properly edited, some raw AI with very little done to it.

My goal wasn't to prove or disprove that AI content gets penalized. I wanted to see if any pattern held consistently across different approaches, over enough time to mean something.

The first 90 days: what the data showed

The first three months gave the clearest picture, but not the one I expected.

Sites A and B, the minimal-edit AI sites, showed the most volatility. That said, "volatility" is the right word here, not "decline." Site A gained traffic in months one and two. The drop only started in month three, and even then, it was limited to specific page clusters.

That made interpretation harder. A clean "AI content = penalty" story would show a straight-line drop from day one. What I saw instead was selective. Some AI pages held their rankings completely fine. Others dropped. And in many cases, the pages that dropped weren't the ones I'd have flagged as weak if I'd reviewed them manually.

What emerged by month three: pages covering topics already well-served by established, authoritative sources dropped more often. Pages with operational detail, with specifics tied to real-world scenarios, were more stable, even the AI-written ones.

Site B's decline was steadier and started earlier, around month two. That site was pushing 25 to 30 articles per month into a fairly narrow niche. By month three, topic overlap between articles was obvious. Google's consolidation behavior kicked in. Stronger pages started cannibalizing weaker ones within the same site itself.

Months 3 to 6: where things got more interesting

The clearest positive signal came from Sites C and D.

Both improved in rankings between months three and five, while Sites A and B were declining. Site C recovered pages that had dipped slightly in the earlier months. The format and structure weren't all that different from the other sites, but every article included real client case details, UK-market-specific examples, and original analysis. No generic filler.

Site D was the most interesting of all six. It runs in a competitive SaaS niche with a lot of AI content already indexed. I expected it to struggle. Instead, it outperformed every other site in organic growth percentage from months four through six.

Going through that content closely, the difference was specificity only. Every article had a clear angle grounded in observations from their actual product users, not generic "here's what industry experts say" framing.

Site E split into two distinct phases. Months one through three: human-written pages stable or improving, AI-assisted pages mixed, minimal-edit AI pages mostly holding. Then month four, the minimal-edit AI pages started declining consistently, while the other two categories mostly held their ground.

By month four, three tiers had basically emerged on Site E:

Human-written pages, stable to improving
AI-assisted with heavy editing, mixed but mostly stable
Minimal-edit AI pages, declining

What kept repeating across Google helpful content update AI articles

Six months in, a few things showed up consistently regardless of niche or geography.

Specificity separated the good from the bad more than anything else. Generic topic coverage performed worse than articles referencing specific scenarios, real data, or market-specific context, even when both types had similar structure and word count. In many cases, two articles on the same topic performed very differently based on this factor alone.

Frequency wasn't the problem people thought it was. High publishing volume alone didn't cause issues. High publishing volume on overlapping topics within a narrow niche, that caused problems. The issue wasn't how much content was going out. It was if the content was competing with itself.

E-E-A-T signals correlated with stability. Sites with strong author pages, proper citations, structured original data held up better. Not a surprising finding on its own, but the correlation was consistent enough across the data to note explicitly. It wasn't a one-site anomaly.

Recovery was possible, and one site proved it. Site A ran a content audit in month four and removed about 30 pages with high topic overlap and low engagement metrics. By month six, the remaining pages had partially bounced back. Not full recovery. Basically what you'd expect from Google reassessing a site after thin content is taken down.

What got hit versus what survived

From my experience, the Google helpful content update AI articles that dropped hardest shared these characteristics:

No original angle or data. Generic information restructured in AI format with nothing added.
Thin coverage. Articles under 600 words chasing competitive terms without real depth.
Internal self-competition. Multiple pages targeting near-identical intent within the same site.
No real-world specificity. Advice that could apply to any market, any situation, no context given.

What survived looked different: articles with referenced data, genuine first-person perspective, substantial depth even when AI-assisted, and a clear differentiation point from what already existed in the SERPs.

The production method wasn't the deciding factor, from what I can tell. Useful, specific, credible content survived. Content without those qualities dropped, regardless of how it was written.

Does Google penalize AI content, or just bad content?

This is what I get asked most. Here's my read after six months watching real sites.

Google's helpful content system isn't an AI detection tool. It's a quality classification system that's gotten better at identifying content with low information gain, poor specificity, and weak engagement signals. Those are quality signals, not origin signals.

AI content produced at scale without editorial control tends to fail on all three. That's the source of the correlation between raw AI content and helpful content system penalties. But the cause is quality, not origin.

The distinction matters when you're deciding how to manage your content program. Spending effort trying to hide that content is AI-generated is solving the wrong problem. Spending that same effort making content specific, useful, and genuinely differentiated, that's what moves rankings.

I've written more on this question with broader data from the SEO community in my piece on whether Google penalizes AI-written content. It goes beyond my client set into what other practitioners have been tracking.

What I'm doing differently now

The audit process has changed for clients running high volumes of AI content. Every three months, we do a content consolidation check: identify topic clusters, flag pages with overlapping intent and below-baseline performance, then improve or remove them. Simple, but it wasn't being done with enough regularity before.

The briefing process for new AI content has changed too. Every draft now starts with a defined angle: a real case from the client's business, a market-specific observation, or an industry data point. Generic overview articles don't get commissioned without a differentiation plan attached. That rule alone has changed the quality of what gets written.

At the site level, topical authority signals are getting more attention. Being the most comprehensive resource on a narrower set of topics outperforms being a moderate resource on a wide range, especially in competitive niches. From my experience, this gap has been widening since the HCU started rolling out.

None of these are dramatic changes. It's applying quality standards that good SEOs have recommended for years, but with more discipline in checking if the AI-assisted content meets those standards, rather than assuming it does.

One thing the data reinforced: backlinks still interact with content quality signals in ways that matter. If a page doesn't have the quality signals to support it, strong backlinks don't move things the way they used to. I went into more detail on which backlinks are still moving rankings in 2026.

For anyone using AI content for guest posts, there's an additional layer because you're being evaluated by an editor in addition to an algorithm. The rejection patterns I've seen are covered in this piece on what editors are rejecting in 2026.

And for the broader AI content workflow, the process I've settled on is detailed in this overview of my current AI SEO content workflow.

Six months of data won't give you definitive answers on everything. But it does show patterns. Content quality beats content origin. Specificity beats coverage volume. That holds for AI content and human content alike.

Why I Moved Away from My Old AI SEO Content Stack and What I Replaced It With

Rahul Sharma — Fri, 10 Jul 2026 11:19:49 +0000

About fourteen months ago, I counted the browser tabs I had open to produce a single SEO article for a client. There were eight. ChatGPT for the draft. A humanizer. A second humanizer I was testing because the first one kept making things worse. An AI detector. Surfer SEO. Ahrefs. The client's brief. And a Grammarly tab I'd opened and then forgotten about.

That's not a workflow. That's just chaos with steps in between.

My AI SEO content stack at the time looked impressive on paper. In practice, it was producing content that kept getting flagged by editors, eating more time than I was billing, and giving me no real way to tell which part was failing. Rebuilding it took about six weeks of testing and a few uncomfortable client conversations. What came out the other side is simpler, faster, and it works.

This is what changed and why.

What my old AI SEO content stack looked like

The original stack had four layers. Ahrefs for keyword research and backlink analysis. ChatGPT for drafts, using custom prompts I'd been refining for two years. A standalone humanizer to clean up the AI patterns. Surfer SEO for on-page optimization and content scoring.

On paper, that covered everything. In practice, none of these tools talked to each other. The workflow was entirely manual handoffs: write in ChatGPT, copy to humanizer, copy to detector, edit, paste back, run Surfer, edit again. By the time a piece was done, I'd touched it six or seven times across four different windows.

The humanizer was the specific weak point. It handled some passes fine. Others it made worse, introducing phrasing that sounded awkward or shifting the meaning of sentences in ways I'd only catch after reading the whole thing again. From my experience, that inconsistency is the part that kills content quality at scale. You can't build a reliable system on a tool that produces unpredictable output.

There was also no feedback loop. I couldn't measure whether any step of the process was working until an editor told me it wasn't.

Where it started breaking down

The clearest signal came from a professional services client in the UK. We were running eight to ten articles per month, a mix of blog content and guest post outreach. Three pitches in a row came back rejected. Two included explicit notes that the content seemed AI-generated.

I ran those rejected pieces through a proper AI detector. They were scoring 80 to 90 percent AI. The humanizer had run on all of them. It hadn't done what I assumed it was doing.

That alone was enough to start testing replacements. But the deeper problem was what I mentioned: no feedback loop. Once I started looking carefully, I realized I had no way to tell whether the humanizer was working short of submitting to an editor and waiting for a rejection. That's not a testing methodology. That's just finding out after the damage is done.

I'd been assuming the humanizer was handling it because I hadn't checked systematically. I did a few spot checks when I first started using it, saw decent results, and moved on. Testing each step in isolation is not the same as testing whether the whole chain produces output that passes real editorial review.

So I ran a batch test. I took 20 pieces from the previous quarter, ran them all through a detection tool, and mapped the scores by content type and which tools had processed them. Average score after humanization: 73 percent AI. The only pieces below 50 percent were ones I'd manually rewritten myself, which defeated the purpose of having AI in the workflow at all.

How I approached rebuilding the AI SEO content stack

The first thing I did was separate the problem into two questions: what functional layers did I need, and which tools were genuinely doing their job?

The functional layers were clear enough. Keyword research, AI-assisted drafting, humanization, detection, and on-page optimization. That hadn't changed. What needed to change was the tools filling those layers and the order of operations between them.

I spent about six weeks testing alternatives, mostly focused on the humanization layer because that was the clear failure point. The full testing notes are in a separate post for anyone who wants the breakdown: every AI tool I tested for SEO content in 2026.

The short version: the quality gap between humanizers is significant. Most tools do word-level replacement. They swap vocabulary and adjust sentence structure slightly. Detection tools look for writing patterns and phrasing structures, not just word frequency. Surface-level word swapping doesn't move the score much.

The tools that pass editorial review do structural rewriting: they change how ideas are expressed, not just which words carry them. From my experience, that's the distinction worth looking for. If a tool is just swapping synonyms, that's not humanization in any useful sense. Structural rewriting changes the rhythm of paragraphs, the way arguments are built, the variation in sentence length. Those are the things editors and detection tools notice.

The new setup, piece by piece

The rebuilt AI SEO content stack has the same four functional layers. The tools and sequence are different.

Keyword research: Ahrefs. No change here. It's the strongest tool I've found for keyword difficulty, SERP analysis, and backlink work, and I use it on every client project.

AI drafting: Still ChatGPT, but with tighter brief templates. The biggest improvement wasn't the tool itself, it was the prompts. I now specify persona, content structure, which sections need specific examples, and what claims need sourcing. Generic prompts produce generic content. The prompt is basically half the work.

Humanization and detection: This is where the biggest change happened. In the old stack, these were separate steps with separate tools. In the new stack, I use a single tool that handles both inside the same editor. Write, humanize, check the detection score, decide if another pass is needed, all in one place. That change alone cut the time I spent on this step by roughly half, and it built in the feedback loop that was missing before.

On-page optimization: Surfer SEO. Still the most reliable option for real-time keyword guidance and content scoring against live SERPs.

The improvement is the integration. There's nothing exotic about any of these tools individually. What changed was that the workflow now has a visible feedback loop at the most critical step. The score tells me whether the content is ready. I'm not submitting and waiting to find out.

The complete workflow, including how the tools connect to each other in practice, is in an earlier post: the complete AI SEO content workflow for agencies in 2026.

What changed after the switch

Detection scores improved immediately. Before the rebuild, content was averaging 70 to 80 percent AI after humanization. After, that dropped to 20 to 30 percent on the same detection tools. For high-stakes content like guest posts headed to editorial sites, additional rewrite passes bring it lower.

Guest post acceptance rates improved over the following quarter. Not dramatically in the first month, but consistently. The rejection rate from editorial sites dropped from roughly one in three to around one in nine. For a solo consultant where guest post placements are a core deliverable for backlink clients, that shift is meaningful.

The second change was less measurable but worth mentioning: I stopped second-guessing the stack. The old setup had too many disconnected steps with no feedback. Every rejection left me guessing which part had failed. Now the stack tells me whether the content meets the bar before anything goes out the door. If the score is too high, I know immediately and do another pass. That certainty has its own value.

For the tool-by-tool breakdown in more detail, I've covered this in two other posts: the best AI SEO content tools I've tested and ranked and the SEO tools I actually use every month and what I've cut.

What I'd tell someone building their AI SEO content stack today

Build the feedback loop before you optimize anything else.

Most people building a content stack focus on output: which AI writer produces the best prose, which SEO platform has the best keyword data. Those things matter. But if you can't measure whether the final output is performing, you're running the system blind.

For SEO content, the minimum viable feedback loop is: humanize, detect, check the score. If it's still too high, you need to know that before the piece goes to an editor or gets published, not after.

Sequence matters as much as the tools. From my experience, most AI content quality issues don't come from using the wrong tool. They come from doing steps in the wrong order, or skipping a step because you assumed another tool handled it. Write before you optimize. Humanize before you run detection. And check the score before you decide the content is done.

It's simple only when you lay it out that way. But in many cases, consultants are doing at least one of these steps out of order, or they've skipped detection entirely because the humanizer looked fine when they first tested it.

The tools in my current stack aren't exotic. Ahrefs is the standard. ChatGPT is everywhere. Surfer is a common choice in this space. The real change was structural: a workflow where each step connects to the next, where I can see the output quality at the point that matters most before anything leaves my hands.

The stack matters less than the sequence, and the sequence matters less than having a feedback loop built in somewhere. Without that, you're testing your quality control by submitting to editors and clients and finding out the hard way.

AI content detection script Python: how I test against 3 detectors at once

Rahul Sharma — Tue, 07 Jul 2026 13:35:57 +0000

Last October a client forwarded me a screenshot. She'd written a guest post with an AI tool, submitted it to a UK marketing blog, and got the rejection email. The editor wrote: "This reads like it was generated by ChatGPT. We don't accept AI content."

What annoyed both of us: she'd tested it through one detector. Came back clean. That was enough for her.

It wasn't.

I've seen the same piece of content flagged as 85% AI by GPTZero and cleared as human by another tool in the same hour. That inconsistency is not unusual. It's how these tools work. Different models, different signals, no common standard. Editors use whatever they use, and you don't get to pick. So I built a small AI content detection script in Python that runs content through three detectors and returns a comparison. It's part of my workflow now for every client batch before anything goes out.

Why one AI detector isn't the full picture

The three tools I use in this script approach detection differently. GPTZero measures perplexity and burstiness — basically, how surprising each word is and how much sentence length varies. Sapling AI is a transformer model fine-tuned on labeled human and AI text. Originality.ai layers its own classifier on top of plagiarism checking. These aren't variations on the same method. They genuinely catch different things.

That matters. If content passes GPTZero but the editor is running Originality.ai on submissions, you've wasted a guest post slot. From my experience with clients doing guest posting at volume, that's a real thing that happens. Not rarely either.

I looked at this more closely in my breakdown of GPTZero alternatives — specifically for freelancers targeting UK, US, and Australian markets where editorial standards tend to be stricter. Detector disagreement is the norm on borderline content, not the exception.

Running three together gives you something more useful: a pattern. If all three score content above 70% AI, the writing has problems that are recognisable across different detection methods. If two say human and one says AI, you're looking at something borderline, worth a second pass. A consensus tells you more than any single score, basically.

What this AI content detection script Python does

The script accepts text strings or reads from a file, sends each piece to GPTZero, Sapling AI, and Originality.ai, calculates the average AI probability across all three, and outputs a side-by-side score comparison to the terminal. No web interface, no dashboard. Just a clean comparison you can run in a terminal from anywhere.

Adding a fourth detector or pulling from a CSV is a few extra lines.

Prerequisites

Keys required for each service. All three have free tiers or trials:

GPTZero API — apply at gptzero.me/api
Sapling AI — free key at sapling.ai
Originality.ai — paid but low per-scan; sign up at originality.ai

Install requests:

pip install requests

Python 3.10+ for the type hints.

The full AI content detection script Python

import requests
import time
import json
import os


class AIDetectorBatch:
    """
    Batch AI content detection across GPTZero, Sapling AI, and Originality.ai.
    """

    def __init__(self, gptzero_key: str, originality_key: str, sapling_key: str):
        self.gptzero_key = gptzero_key
        self.originality_key = originality_key
        self.sapling_key = sapling_key

    def check_gptzero(self, text: str) -> dict:
        url = "https://api.gptzero.me/v2/predict/text"
        headers = {
            "x-api-key": self.gptzero_key,
            "Content-Type": "application/json",
            "Accept": "application/json",
        }
        payload = {"document": text, "multilingual": False}
        response = requests.post(url, headers=headers, json=payload, timeout=30)
        response.raise_for_status()
        data = response.json()
        doc = data["documents"][0]
        return {
            "detector": "GPTZero",
            "ai_probability": doc["completely_generated_prob"],
            "classification": doc["predicted_class"],
        }

    def check_sapling(self, text: str) -> dict:
        url = "https://api.sapling.ai/api/v1/aidetect"
        payload = {"key": self.sapling_key, "text": text}
        response = requests.post(url, json=payload, timeout=30)
        response.raise_for_status()
        data = response.json()
        score = data["score"]
        return {
            "detector": "Sapling AI",
            "ai_probability": score,
            "classification": "ai" if score >= 0.5 else "human",
        }

    def check_originality(self, text: str) -> dict:
        url = "https://api.originality.ai/api/v1/scan/ai"
        headers = {
            "X-OAI-API-KEY": self.originality_key,
            "Content-Type": "application/json",
        }
        payload = {"content": text, "aiModelVersion": "1", "storeScan": False}
        response = requests.post(url, headers=headers, json=payload, timeout=30)
        response.raise_for_status()
        data = response.json()
        ai_score = data["score"]["ai"]
        return {
            "detector": "Originality.ai",
            "ai_probability": ai_score,
            "classification": "ai" if ai_score >= 0.5 else "human",
        }

    def check_all(self, text: str, delay: float = 1.5) -> list[dict]:
        """Run all three detectors on a single piece of text."""
        results = []
        checks = [self.check_gptzero, self.check_sapling, self.check_originality]
        for fn in checks:
            try:
                results.append(fn(text))
            except requests.HTTPError as e:
                results.append({"detector": fn.__name__, "error": str(e)})
            time.sleep(delay)
        return results

    def batch_check(self, texts: list[str], delay: float = 1.5) -> list[dict]:
        """Run all detectors on a list of text strings."""
        all_results = []
        for i, text in enumerate(texts):
            print(f"Processing {i + 1}/{len(texts)}...")
            entry = {
                "text_preview": text[:100].replace("\n", " ") + ("..." if len(text) > 100 else ""),
                "results": self.check_all(text, delay=delay),
            }
            valid = [r for r in entry["results"] if "ai_probability" in r]
            if valid:
                entry["average_ai_probability"] = (
                    sum(r["ai_probability"] for r in valid) / len(valid)
                )
            all_results.append(entry)
        return all_results


def render_results(batch_output: list[dict]) -> None:
    """Print a formatted comparison table to stdout."""
    for item in batch_output:
        print(f"\n{'=' * 65}")
        print(f"Text: {item['text_preview']}")
        print(f"{'=' * 65}")
        for r in item["results"]:
            if "error" in r:
                print(f"  {r['detector']:<15}  ERROR: {r['error']}")
                continue
            pct = r["ai_probability"] * 100
            filled = int(pct / 5)
            bar = "█" * filled + "░" * (20 - filled)
            label = r["classification"].upper()
            print(f"  {r['detector']:<15}  [{bar}]  {pct:5.1f}%  ({label})")
        if "average_ai_probability" in item:
            avg = item["average_ai_probability"] * 100
            print(f"\n  {'Average':<15}  {avg:.1f}% AI probability")


def save_results(results: list[dict], output_path: str) -> None:
    """Export results to JSON for logging or downstream analysis."""
    with open(output_path, "w", encoding="utf-8") as f:
        json.dump(results, f, indent=2)
    print(f"\nResults saved to {output_path}")


# Entry point

if __name__ == "__main__":
    detector = AIDetectorBatch(
        gptzero_key=os.getenv("GPTZERO_API_KEY", "your_gptzero_key"),
        originality_key=os.getenv("ORIGINALITY_API_KEY", "your_originality_key"),
        sapling_key=os.getenv("SAPLING_API_KEY", "your_sapling_key"),
    )

    sample_texts = [
        (
            "The integration of artificial intelligence into content marketing workflows "
            "has fundamentally transformed how organizations approach content creation at scale. "
            "By leveraging large language models, teams can produce high-quality written materials "
            "in a fraction of the time previously required, enabling unprecedented levels of output "
            "while maintaining consistency in brand voice and messaging across all channels."
        ),
        (
            "Last year I made a mistake that cost me three months of work. "
            "A client in Manchester needed product descriptions for over 400 items. "
            "I used AI to draft the lot, did a quick read-through, and sent them over. "
            "The site owner rejected all of them after their in-house editor flagged them as AI. "
            "I had not run a single detection check before delivery. "
            "That was my fault, and I still think about it when setting up any content workflow."
        ),
    ]

    results = detector.batch_check(sample_texts)
    render_results(results)
    save_results(results, "detection_results.json")

How the script is structured

One class, AIDetectorBatch. A method each for GPTZero, Sapling, and Originality. Then check_all and batch_check sit on top of those.

The design decision I'd highlight: all three detector methods return the same dict shape — detector, ai_probability, classification. That's it. I kept it uniform on purpose. Means render_results and the averaging logic don't need to know which detector produced which result. One loop handles all three.

check_all runs the detectors sequentially with a delay. The default is 1.5 seconds between calls. Don't remove this unless you're on a paid plan with higher rate limits. I've hit limits on the free tiers when batching articles quickly, and the script handles HTTPError gracefully — it logs the error and keeps going rather than crashing the whole batch.

batch_check is the main entry point for most use. It takes a list of strings, runs check_all on each, stores the preview plus all results, and calculates the average probability across detectors that returned successfully. So if Sapling's API goes down mid-batch, the average is still computed from the two that responded.

render_results just makes terminal output readable. ASCII bars instead of raw floats. When you're scanning 20 articles in one go, that visual difference matters more than it sounds.

What the sample output looks like

The two texts in the sample are intentional extremes. First one is generic AI filler — "transformational", "at scale", "brand voice across all channels." All three detectors pick it up, consistently above 70%. Second one is a personal story with a specific city, a specific client mistake, a specific volume of work. Scores come in below 30% across all three.

Processing 1/2...
Processing 2/2...

=================================================================
Text: The integration of artificial intelligence into content marketing workflo...
=================================================================
  GPTZero          [████████████████░░░░]   82.3%  (AI)
  Sapling AI       [██████████████░░░░░░]   71.8%  (AI)
  Originality.ai   [███████████████░░░░░]   78.5%  (AI)

  Average           77.5% AI probability

=================================================================
Text: Last year I made a mistake that cost me three months of work. A client in...
=================================================================
  GPTZero          [████░░░░░░░░░░░░░░░░]   21.4%  (HUMAN)
  Sapling AI       [███░░░░░░░░░░░░░░░░░]   17.2%  (HUMAN)
  Originality.ai   [█████░░░░░░░░░░░░░░░]   27.9%  (HUMAN)

  Average           22.2% AI probability

Agreement across all three is the signal to watch. One outlier is noise. Three outliers is a problem in the content.

Loading from a file instead of hardcoded strings

For actual content batches, I use a plain text file with --- as a separator between articles:

def load_texts_from_file(filepath: str, delimiter: str = "---") -> list[str]:
    with open(filepath, "r", encoding="utf-8") as f:
        content = f.read()
    return [t.strip() for t in content.split(delimiter) if t.strip()]

texts = load_texts_from_file("articles.txt")
results = detector.batch_check(texts)
render_results(results)

I save results to JSON on every run too. Lets me compare scores between draft versions. When I wrote about API integrations for content pipelines, this score-tracking across revisions is the part people actually found useful — more than the integration setup itself.

Reading the scores correctly

The number that matters is the average, not any single detector's output. I had a situation where GPTZero flagged an article at 80%, Sapling cleared it, and Originality put it at 85%. The client wanted to publish based on the Sapling pass. The piece got rejected by the site editor. I documented similar inconsistencies in detail — same content, same day, wildly different individual scores.

What to look for: are all three pointing in the same direction? That's your real verdict.

On thresholds — different editors have different cutoffs. From my experience, under 30% average across all three is a safe zone for editorial submissions. Some sites are stricter, some are looser. Under 20% and I've never had a detection-based rejection, from my experience.

Short text gives bad results, basically across every detector I've tried. Under 150 words, the classifications start behaving randomly. Test full articles or at least full sections.

One more thing: both GPTZero and Originality.ai update their models without much announcement. A score from three months ago doesn't hold. Run this check close to the submission date, not once during initial drafting.

Ways to extend this

Winston AI has an API and is used specifically by a lot of academic editors. Worth adding as a fourth check if content goes to research or educational publications.

argparse turns this into a proper CLI tool — call it with a file path from the terminal rather than editing the script. gspread writes results to a Google Sheet in a few lines if you're managing content across multiple client accounts. And if Originality.ai is timing out during busy hours, wrapping check_originality in a retry decorator with exponential backoff fixes most of those failures.

Detection is the starting point, not the end

The script tells you where the problem is. Fixing it is separate work.

Content scoring above 60% across all three detectors tends to have the same fingerprints: sentence lengths that barely vary, transitions like "furthermore" and "it is worth noting", paragraphs that state a point and then restate it from a slightly different angle. Those are the specific patterns to go after when revising.

My roundup of humanizer tools covers what fits into the pipeline after detection flags something — if that's the next step.

Modify the script as needed. Most people add a detector or change the output format within the first week. If parsing breaks after a few weeks, check Originality.ai first. That response shape changes most often.

Leave a comment if you extend it somewhere interesting.