# AI Content Detector — ZeroGPT ChatGPT API (`khadinakbar/ai-content-detector`) Actor

Score pasted text with ZeroGPT and get an AI percent, human or mixed label, word counts, and highlighted sentences. Built for teachers, editors, recruiters, and agents who need Copyleaks-style detection as structured JSON. Charged $0.02 per text plus platform usage.

- **URL**: https://apify.com/khadinakbar/ai-content-detector.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** AI, Developer tools, SEO tools
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.00 / 1,000 ai text detecteds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## AI Content Detector

Score pasted essays, applications, ads, and SEO drafts with ZeroGPT and get one dataset row per document: an AI percent, a human or mixed label, word counts, and the sentences the detector highlighted. Built for teachers, editors, recruiters, content teams, and MCP agents that need Copyleaks/QuillBot-style detection as structured JSON instead of a screenshot from a website.

Designed for people who already have the wording in hand and need a repeatable score they can store, compare, and bill per document. After you score a brand's generated copy, continue with [AI Search Brand Monitor](https://apify.com/khadinakbar/ai-search-brand-monitor) to see whether AI answers mention that brand.

### What you get

| Output | What it answers |
|---|---|
| `classification` | **Label** — `ai`, `mixed`, or `human` from the ZeroGPT percent |
| `aiPercentage` + `humanPercentage` | **Score** — ZeroGPT's AI share and human share, 0–100 |
| `textWordCount` + `aiWordCount` | **Volume** — how much of the document was counted as AI-written |
| `aiSentences[]` + `feedback` | **Highlights** — the sentences ZeroGPT marked, plus the plain-language verdict |
| `textPreview`, `provider`, `detectedAt` | **Provenance** — which document, which engine, and when |

### Who it is for

- **Teachers and academic integrity staff** — score submitted essays and keep a dated row per student document.
- **Editors and SEO teams** — check drafts and ad copy before publish, then keep the highlighted sentences for revision notes.
- **Recruiters and HR coordinators** — score cover letters and take-home writing with a consistent threshold.
- **Agency QA** — batch-check a folder of client drafts in one run.
- **AI agents** — call one tool, read `classification` + `aiPercentage`, and route the next step from `OUTPUT.outcome`.

### When to use this Actor

- Paste one essay, cover letter, or ad and get a ZeroGPT score plus highlighted sentences.
- Batch-score a class set or a week of blog drafts, one row per document.
- Give an agent a Copyleaks-style JSON contract: label, percent, sentences, provenance, and cost.
- Keep `includeTextPreview` on when you need to match a score back to the source wording later.

### Best fit & sibling routing

Use this Actor when the job is **score wording you already have**. Pair it with [ChatGPT GPT Store Scraper](https://apify.com/khadinakbar/chatgpt-gpt-store-scraper) when you first need listing copy from the GPT Store, then pass that copy here to score it. For whether Google's AI Overview cites a brand, start with [Google AI Overviews Scraper](https://apify.com/khadinakbar/google-ai-overviews-scraper), then score any generated follow-up copy with this Actor. This Actor is designed as a focused standalone workflow for ZeroGPT text scores; file-upload and URL-crawl modes stay with dedicated crawlers.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `texts` | array | 1 sample document | Up to 50 strings, one document each |
| `text` | string | empty | Optional single-document shortcut for agents |
| `maxTexts` | integer | 50 | Cap how many documents this run scores |
| `maxCharacters` | integer | 4000 | Per-document cap; longer input is truncated and flagged |
| `includeSentences` | boolean | true | Add ZeroGPT highlighted sentences |
| `includeTextPreview` | boolean | true | Store a short preview of the scored wording |
| `aiThreshold` | integer | 80 | `classification=ai` at or above this percent |
| `humanThreshold` | integer | 20 | `classification=human` at or below this percent |
| `maxConcurrency` | integer | 2 | Documents scored in parallel (1–5) |

#### Example input — one essay

```json
{
    "texts": [
        "Artificial intelligence has transformed the way organizations approach content creation, enabling teams to produce high-quality written materials at unprecedented speed and scale. By leveraging large language models, businesses can generate drafts, summarize research, and personalize communications while maintaining a consistent brand voice across every customer touchpoint. This technological shift requires robust governance, including human review, disclosure policies, and authenticity checks, so stakeholders can trust the information they consume."
    ],
    "includeSentences": true,
    "maxTexts": 1
}
```

#### Example input — classroom batch

```json
{
    "texts": [
        "Artificial intelligence has transformed the way organizations approach content creation, enabling teams to produce high-quality written materials at unprecedented speed and scale. By leveraging large language models, businesses can generate drafts, summarize research, and personalize communications while maintaining a consistent brand voice across every customer touchpoint. This technological shift requires robust governance, including human review, disclosure policies, and authenticity checks, so stakeholders can trust the information they consume.",
        "The morning market opened mixed as traders digested overnight futures and a handful of earnings prints. I walked down to the corner shop, bought coffee, and sat on the bench watching buses. Nothing about this paragraph is trying to sound corporate. It is just a record of an ordinary Tuesday with a few numbers mixed in so the detector has enough words to score."
    ],
    "maxTexts": 50,
    "includeSentences": true,
    "aiThreshold": 80,
    "humanThreshold": 20
}
```

### Output

One dataset row per scored document.

| Field | Type | Meaning |
|---|---|---|
| `textId` | string | `text-1` or a caller-supplied id |
| `classification` | string | `ai` / `mixed` / `human` |
| `aiPercentage` | number | ZeroGPT AI share, 0–100 |
| `humanPercentage` | number | ZeroGPT human share, 0–100 |
| `textWordCount` | integer | Words counted |
| `aiWordCount` | integer | Words counted as AI |
| `aiSentences` | string\[] | Highlighted likely-AI sentences |
| `feedback` | string | Plain-language ZeroGPT verdict |
| `textPreview` | string | Leading characters of the document |
| `provider` | string | Always `zerogpt` |
| `detectedAt` | string | UTC timestamp |

#### Example output — one persisted item

```json
{
    "textId": "text-1",
    "classification": "ai",
    "aiPercentage": 100,
    "humanPercentage": 0,
    "textWordCount": 68,
    "aiWordCount": 68,
    "characterCount": 548,
    "truncated": false,
    "feedback": "Your Text is AI/GPT Generated",
    "aiSentences": [
        "Artificial intelligence has transformed the way organizations approach content creation, enabling teams to produce high-quality written materials at unprecedented speed and scale."
    ],
    "aiSentenceCount": 3,
    "textPreview": "Artificial intelligence has transformed the way organizations approach content creation",
    "provider": "zerogpt",
    "providerResultId": 58839863,
    "detectedAt": "ISO-8601 timestamp"
}
```

`OUTPUT` and `RUN_SUMMARY` record the run `outcome` (`COMPLETE`, `PARTIAL`, `VALID_EMPTY`, `INVALID_INPUT`, `UPSTREAM_FAILED`, `CONFIG_ERROR`), `itemsPushed`, classification counts, and `chargedEventCounts`.

### Workflow: from a draft folder to a review queue

A content lead starts with 20 blog drafts in a spreadsheet, pastes each body into `texts`, and runs this Actor with `includeSentences: true`. Rows with `classification=ai` go to a human editor with the highlighted sentences as revision notes. Mixed rows stay in a second queue. Human rows ship. Schedule the same saved input weekly for new drafts. Then export the dataset to Sheets and filter on `aiPercentage`.

### Pricing — Pay per event + platform usage

| Event | Price | Charged when |
|---|---|---|
| Actor start | $0.00005 | Once per run (scaled by memory) |
| `text-detected` | $0.02 | One document scored and saved |

#### Cost scenarios (typical runs)

| Run | Texts saved | Event cost (approx.) |
|---|---|---|
| One essay | 1 | ~$0.02 |
| 10-draft batch | 10 | ~$0.20 |
| 50-document max batch | 50 | ~$1.00 |

Only saved rows are billed. Then check the live [Pricing tab](https://apify.com/khadinakbar/ai-content-detector/pricing) for current Pay per event plus platform usage on your plan.

### API example

```bash
curl -X POST "https://api.apify.com/v2/acts/khadinakbar~ai-content-detector/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "texts": ["Artificial intelligence has transformed the way organizations approach content creation, enabling teams to produce high-quality written materials at unprecedented speed and scale. By leveraging large language models, businesses can generate drafts, summarize research, and personalize communications while maintaining a consistent brand voice across every customer touchpoint."],
    "includeSentences": true,
    "maxTexts": 1
  }'
```

Results land in the run's default dataset: `https://api.apify.com/v2/datasets/{datasetId}/items?clean=true`. Paginate large batches with `offset`/`limit` on that endpoint. The same actor is exposed through Apify MCP as `apify--ai-content-detector` for agent clients.

### Use with AI agents through Apify MCP

> Score this pasted essay with ZeroGPT. Return classification, aiPercentage, highlighted sentences, dataset rows, OUTPUT outcome, provenance (provider + detectedAt), and confirm the $0.02 per-text cost. Read back the default dataset when the Actor completes.

Agents should pass `texts` (or `text` for one document), keep `maxTexts` bounded, and treat `OUTPUT.outcome` as the machine contract. Scope is pasted wording only; pagination is `offset`/`limit` on the dataset items endpoint.

### Best results guidance

- Give ZeroGPT 60+ words per document so sentence highlights have something to mark.
- Keep one student, ticket, or URL's wording per array item so `textId` maps back cleanly.
- Use `aiThreshold` 80 / `humanThreshold` 20 unless your review policy needs a stricter AI band.
- Split long articles at 4,000 characters for more precise highlights and a predictable $0.02 row.
- Turn `includeTextPreview` off for classrooms that should store scores without retaining the original essay in Apify.

### Builder's note

I built this after calling ZeroGPT's Business `detectText` API against both a corporate AI-style paragraph and a messy diary paragraph: I found the official payload already returns `fakePercentage`, `isHuman`, `feedback`, and highlighted sentences in `h[]` — the same shape Copyleaks and QuillBot show in a UI, only as JSON. In my testing, wrapping that engine as an Apify PPE actor was more useful for agents than scraping the public ZeroGPT website, because the score, the highlights, and the billing unit stay on one row.

### FAQ

**How is classification decided?**
ZeroGPT returns `fakePercentage`. This Actor labels `ai` at or above `aiThreshold` (default 80), `human` at or below `humanThreshold` (default 20), and `mixed` in between. The raw percents stay on the row.

**Does a user need their own ZeroGPT key?**
No. The Actor uses the owner's managed ZeroGPT Business API key. You paste text and receive scores.

**What happens if ZeroGPT is briefly unavailable?**
The Actor retries retryable HTTP statuses, then records that document in `OUTPUT`. A run that saved at least one row finishes `PARTIAL`; a run where every document stayed unavailable finishes `UPSTREAM_FAILED`. Only saved rows are charged.

**Can an AI agent use this?**
Yes. It is MCP-ready: `texts` in, one structured row per document, with outcome readback, provenance, cost, and dataset pagination.

### Legal

Submit only text you are authorized to process. You are responsible for complying with applicable laws, ZeroGPT's terms of service, classroom or employer policy, and Apify's terms when using the scores. AI-detection percentages are estimates for review workflows, not a legal finding of authorship.

# Actor input Schema

## `texts` (type: `array`):

Documents to run through ZeroGPT, one string per document. Example: an essay paragraph or ad draft of 60+ words. Prefill scores one sample so the run returns a row immediately. This is the source wording to classify, not a URL or file path.

## `text` (type: `string`):

Optional one-document shortcut for agents that pass a single string instead of an array. Example: the body of a cover letter. Combined with texts when both are set. Leave empty when you already filled the texts list.

## `maxTexts` (type: `integer`):

Maximum number of documents to score in this run. Default 50 matches the per-run cap. Lower it to 1 for a cheap quality-sample or agent probe. This caps volume and cost; it does not change how ZeroGPT scores a single document.

## `maxCharacters` (type: `integer`):

Per-document character cap before scoring. Default 4000 is enough for a typical essay section. Raise toward 15000 for longer articles; longer input is truncated and flagged on the row. Split book-length files into sections for cleaner sentence highlights.

## `includeSentences` (type: `boolean`):

When enabled (default), each row includes aiSentences\[] — the sentences ZeroGPT marked as likely AI-written, QuillBot/Copyleaks highlight style. Turn off when you only need the overall percent and classification. Sentence lists do not change the $0.02 per-text charge.

## `includeTextPreview` (type: `boolean`):

When enabled (default), each row includes a short textPreview of the scored document so you can match scores back to source copy. Turn off for privacy-sensitive classrooms or HR queues that should store scores without the original wording. The full document is still sent to ZeroGPT for scoring.

## `aiThreshold` (type: `integer`):

aiPercentage at or above this value is labeled classification=ai. Default 80 matches a Copyleaks-style high-confidence band. Lower toward 50 for a stricter classroom filter. This only changes the label; the raw ZeroGPT percent is always returned.

## `humanThreshold` (type: `integer`):

aiPercentage at or below this value is labeled classification=human. Default 20. Scores between humanThreshold and aiThreshold are labeled mixed. This only changes the label; it does not recompute ZeroGPT's fakePercentage.

## `maxConcurrency` (type: `integer`):

How many documents to score in parallel. Default 2 balances speed against ZeroGPT pacing. Raise to 5 for bulk classroom batches; lower to 1 if the log shows HTTP 429 retries. Each document is still one $0.02 event.

## Actor input object example

```json
{
  "texts": [
    "Artificial intelligence has transformed the way organizations approach content creation, enabling teams to produce high-quality written materials at unprecedented speed and scale. By leveraging large language models, businesses can generate drafts, summarize research, and personalize communications while maintaining a consistent brand voice across every customer touchpoint. This technological shift requires robust governance, including human review, disclosure policies, and authenticity checks, so stakeholders can trust the information they consume."
  ],
  "text": "The morning market opened mixed as traders digested overnight futures and a handful of earnings prints.",
  "maxTexts": 1,
  "maxCharacters": 4000,
  "includeSentences": true,
  "includeTextPreview": true,
  "aiThreshold": 80,
  "humanThreshold": 20,
  "maxConcurrency": 2
}
```

# Actor output Schema

## `results` (type: `string`):

Dataset items containing AI percent, human or mixed classification, word counts, highlighted sentences, and a text preview for each scored document.

## `summary` (type: `string`):

Run summary including outcome, itemsPushed, classification counts, ZeroGPT status codes, warnings, and billing counters.

## `runSummary` (type: `string`):

Machine-readable RUN\_SUMMARY record mirroring OUTPUT for integrations that read RUN\_SUMMARY directly.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "texts": [
        "Artificial intelligence has transformed the way organizations approach content creation, enabling teams to produce high-quality written materials at unprecedented speed and scale. By leveraging large language models, businesses can generate drafts, summarize research, and personalize communications while maintaining a consistent brand voice across every customer touchpoint. This technological shift requires robust governance, including human review, disclosure policies, and authenticity checks, so stakeholders can trust the information they consume."
    ],
    "maxTexts": 1,
    "maxCharacters": 4000,
    "includeSentences": true,
    "includeTextPreview": true,
    "aiThreshold": 80,
    "humanThreshold": 20,
    "maxConcurrency": 2
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/ai-content-detector").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "texts": ["Artificial intelligence has transformed the way organizations approach content creation, enabling teams to produce high-quality written materials at unprecedented speed and scale. By leveraging large language models, businesses can generate drafts, summarize research, and personalize communications while maintaining a consistent brand voice across every customer touchpoint. This technological shift requires robust governance, including human review, disclosure policies, and authenticity checks, so stakeholders can trust the information they consume."],
    "maxTexts": 1,
    "maxCharacters": 4000,
    "includeSentences": True,
    "includeTextPreview": True,
    "aiThreshold": 80,
    "humanThreshold": 20,
    "maxConcurrency": 2,
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/ai-content-detector").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "texts": [
    "Artificial intelligence has transformed the way organizations approach content creation, enabling teams to produce high-quality written materials at unprecedented speed and scale. By leveraging large language models, businesses can generate drafts, summarize research, and personalize communications while maintaining a consistent brand voice across every customer touchpoint. This technological shift requires robust governance, including human review, disclosure policies, and authenticity checks, so stakeholders can trust the information they consume."
  ],
  "maxTexts": 1,
  "maxCharacters": 4000,
  "includeSentences": true,
  "includeTextPreview": true,
  "aiThreshold": 80,
  "humanThreshold": 20,
  "maxConcurrency": 2
}' |
apify call khadinakbar/ai-content-detector --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,khadinakbar/ai-content-detector"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/1h8i1BgpPFd2GT2mr/builds/U0IWkfqR1qGKfY5Qm/openapi.json