# AI Content Detector (`muhammetakkurtt/ai-content-detector`) Actor

The AI Content Detector instantly analyzes how much of your text or file was written by AI. Verify content authenticity, boost your SEO, and maintain academic integrity. Secure your texts with fast, reliable results.

- **URL**: https://apify.com/muhammetakkurtt/ai-content-detector.md
- **Developed by:** [Muhammet Akkurt](https://apify.com/muhammetakkurtt) (community)
- **Categories:** AI, SEO tools, Other
- **Stats:** 88 total users, 10 monthly users, 100.0% runs succeeded, 3 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $0.03 / 1,000 words analyzed for ai detections

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## AI Content Detector

The AI Content Detector is a powerful Apify actor designed to detect AI-generated content in texts. Using advanced artificial intelligence models, it analyzes provided texts or files and provides a score indicating how much of the content was written by AI versus a human.

### Why Use the AI Content Detector?

This tool offers a fast and reliable solution for verifying content authenticity. It saves you time by automating this check, which is difficult to do manually.

- **Accuracy**: Uses proven machine learning models with a high accuracy rate.
- **Flexibility**: Supports both plain text and various file formats.
- **Large Text Support**: Automatically splits texts longer than 50,000 words into 50,000-word chunks for analysis. This ensures that even very large documents can be processed smoothly.
- **Easy Integration**: Can be easily run on the Apify platform, and the results can be exported in different formats (JSON, CSV, Excel).

### Features

- Scans for AI content by text or file upload.
- Supported file formats: `.txt`, `.md`, `.html`, `.pdf`, `.docx`.
- Markdown files are rendered before extraction so tables and inline HTML survive conversion to plain text.
- Text-based PDFs are supported. Scanned or image-only PDFs are rejected because OCR is not enabled in this actor.
- Provides detailed AI and human-written scores for each block of text.
- Automatically splits large texts into parts and analyzes each one.
- Includes proxy support and a retry mechanism for more reliable results.
- Stores the results in a structured format in the Apify dataset.

### Use Cases

- **Content Verification**: For publishers and content creators to check the authenticity of articles.
- **Academic Integrity**: For educational institutions to detect plagiarism and AI use in assignments and theses.
- **SEO Optimization**: For SEO specialists to ensure content quality and authenticity.
- **General Purpose**: For anyone who wants to distinguish human-written texts from AI-generated ones.

### Usage

1. Run this actor in the Apify console.
2. Provide the necessary inputs:
   - `textContent`: Enter the text you want to scan to see if it was generated by AI (or upload a file below).
   - `fileUpload`: Upload a file for AI content checking (`.txt`, `.md`, `.html`, `.pdf`, `.docx`). If you upload a file, the text field above is ignored. Scanned or image-only PDFs require OCR and are not processed by this actor.
   - `proxyConfiguration`: It is recommended to use a proxy for faster and more reliable results.

#### Example Input

```json
{
  "textContent": "I was just sitting here, watching the rain tap against the window. My cat, Mittens, hopped onto my lap, her purr a tiny, rumbling engine. It’s those small, real moments, you know? That’s not something an algorithm can just come up with. In contrast, our synergistic platform leverages advanced natural language processing to optimize data-driven user engagement. The future of content creation represents a paradigm shift towards automated, scalable solutions that enhance productivity and streamline workflows.",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": []
  }
}
```

### Output

The collected data is saved to the Apify dataset. The output data includes the following fields:

- `original`: Overall Human Score
- `ai`: Overall AI Score
- `text`: The analyzed block of text
- `result.real`: Human score for the text block
- `result.fake`: AI score for the text block
- `result.status`: Status

### Example Output

```json
{
  "original": 0.0365,
  "ai": 0.9634,
  "blocks": [
    {
      "text": "I was just sitting here, watching the rain tap against the window. ",
      "result": {
        "fake": 0.8077069327234602,
        "real": 0.19229306727653983,
        "status": "success"
      }
    },
    {
      "text": "My cat, Mittens, hopped onto my lap, her purr a tiny, rumbling engine. ",
      "result": {
        "fake": 0.9040025260298824,
        "real": 0.0959974739701176,
        "status": "success"
      }
    },
    {
      "text": "It’s those small, real moments, you know? ",
      "result": {
        "fake": 0.9497915598252789,
        "real": 0.05020844017472115,
        "status": "success"
      }
    },
    {
      "text": "That’s not something an algorithm can just come up with. ",
      "result": {
        "fake": 1,
        "real": 0,
        "status": "success"
      }
    },
    {
      "text": "In contrast, our synergistic platform leverages advanced natural language processing to optimize data-driven user engagement. ",
      "result": {
        "fake": 1,
        "real": 0,
        "status": "success"
      }
    },
    {
      "text": "The future of content creation represents a paradigm shift towards automated, scalable solutions that enhance productivity and streamline workflows",
      "result": {
        "fake": 1,
        "real": 0,
        "status": "success"
      }
    }
  ]
}
```

This example output shows the statistical data resulting from the analysis of the submitted text. The output is a list containing a similar object for each piece of text analyzed.

### Notes

- The collected data is stored in Apify's default data store.

# Actor input Schema

## `textContent` (type: `string`):

Enter the text you want to scan for AI-generated content (or upload a file below). Texts longer than 50,000 words will be automatically processed in chunks.

## `fileUpload` (type: `string`):

Upload a file to check for AI content (.txt, .md, .html, .pdf, .docx). If you upload a file, the text area above will be ignored. Texts longer than 50,000 words will be automatically processed in chunks. Markdown is rendered before extraction, and scanned or image-only PDFs are not supported without OCR.

## `proxyConfiguration` (type: `object`):

Using a proxy is recommended for faster and more reliable results

## Actor input object example

```json
{
  "textContent": "I was just sitting here, watching the rain tap against the window. My cat, Mittens, hopped onto my lap, her purr a tiny, rumbling engine. It's those small, real moments, you know? That's not something an algorithm can just come up with. In contrast, our synergistic platform leverages advanced natural language processing to optimize data-driven user engagement. The future of content creation represents a paradigm shift towards automated, scalable solutions that enhance productivity and streamline workflows.",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": []
  }
}
```

# Actor output Schema

## `aiDetectionResults` (type: `string`):

Dataset items produced by the actor, including the overall original and AI scores together with per-block text, block-level AI/human scores, and status fields.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("muhammetakkurtt/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 = {}

# Run the Actor and wait for it to finish
run = client.actor("muhammetakkurtt/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 '{}' |
apify call muhammetakkurtt/ai-content-detector --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,muhammetakkurtt/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/RoYpcsjrPfLmPCkZJ/builds/L3oPiTf3NrucICayn/openapi.json