# AI Content Detector — Turnitin Alternative (`khadinakbar/turnitin-ai-detector-alternative`) Actor

Check English prose for AI-writing signals. Submit text and receive a provider signal, review band, optional sentence highlights, and human-review guidance in one report per text. Results are screening cues, not proof of authorship.

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

## Pricing

from $450.00 / 1,000 ai-writing pre-screen reports

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 — Turnitin Alternative

Check English prose for AI-writing signals. Submit text and receive a provider signal, review band, optional sentence highlights, and human-review guidance in one report per text. Results are screening cues, not proof of authorship. For editors and review teams, each dataset row is one text-screening report with a review band and provider provenance.

### Workflow: put the results to work

Submit intact English prose within the supported length range and keep each document's identifier. Use the review band to organize an editorial queue, inspect any highlighted sentences in context, and let a human reviewer decide the next step. The result does not identify which model wrote a passage.

### What you get

| Field | Meaning |
|---|---|
| `reviewBand` | `no-signal`, `low-signal`, `review`, or `high-signal` routing cue for a human queue |
| `reportedAiPercentage` | Cautiously displayed provider signal; intentionally omitted for 1-19% low-signal pre-screen results |
| `classification` | Threshold-based `human`, `mixed`, or `ai` label for workflow routing, not a finding |
| `reviewGuidance` | Mandatory reminder that a human reviewer and the applicable policy decide next steps |
| `aiSentences[]` | Optional provider-highlighted sentences, stored as review cues rather than evidence |
| `provider`, `detectedAt`, `textId` | Provenance that lets a reviewer trace every saved report |

The default `turnitin-pre-screen` profile accepts only intact 300-3,000-word sections. It declines short, oversized, or truncated submissions before calling the provider, so an ineligible input creates no provider request and no report usage event.

### When to use it

- Triage a queue of authorised essay, article, or application sections before assigning human review.
- Add a bounded AI-writing signal to an editorial or academic workflow that already stores source text elsewhere.
- Call an API and receive one durable dataset row per eligible section, with an `OUTPUT` / `RUN_SUMMARY` contract.
- Keep text preview disabled when a score and provenance are sufficient for the review queue.

Keep every disciplinary, employment, admissions, or other high-impact decision with an authorised human reviewer. Obtain permission to process the text, apply the relevant policy, and provide an appeal or review path where required.

### AI tools and writing sources covered by the workflow

The Actor is model-agnostic: it screens writing patterns rather than calling or reverse-engineering the tool that may have produced the text. Typical review inputs include content associated with:

- ChatGPT and OpenAI GPT models
- Claude
- Gemini
- Microsoft Copilot
- DeepSeek
- Grok
- Meta AI and Llama-based assistants
- Mistral and Le Chat
- Perplexity
- Jasper, Copy.ai, Writesonic, and Rytr
- QuillBot and other AI paraphrasing or rewriting tools
- Other current or future LLM-based writing assistants

These names describe possible text sources users may want to screen. ZeroGPT and this Actor return a general signal rather than named-model attribution, and performance can vary across models and versions. Human editing, translation, paraphrasing, text length, genre, and model updates can all affect the signal. The listed companies are unaffiliated with this Actor.

### Workflow: from authorised text to a human queue

An editor starts with an authorised 800-word article section, pastes it into `texts`, and starts the default profile with `includeTextPreview: false`. The Actor first checks the word range and truncation rule. It then sends only an eligible section to the provider, saves one report row, and turns the row into a review-queue item using `reviewBand` and `reviewGuidance`. Next, the editor reads the source in its original system alongside any optional highlights and records the human decision there. For recurring work, schedule the same saved task and export the dataset to the downstream review system after each completed execution.

### Input

| Field | Default | Purpose |
|---|---:|---|
| `texts` | one prefilled section | Up to 10 pasted sections, one report per eligible item |
| `text` | empty | Single-section API shortcut; combines with `texts` if both are supplied |
| `reviewProfile` | `turnitin-pre-screen` | Safe default with 300-3,000-word validation and cautious low-signal display |
| `maxTexts` | `1` | Per-execution report and cost cap; maximum `10` |
| `maxCharacters` | `20000` | Safeguard cap; an otherwise eligible pre-screen is declined if this would truncate it |
| `includeSentences` | `true` | Include provider-highlighted sentences as review cues |
| `includeTextPreview` | `false` | Add a short source preview only when the workflow needs it |
| `aiThreshold` / `humanThreshold` | `80` / `20` | Routing thresholds that leave the provider result unchanged |
| `maxConcurrency` | `1` | Stable provider pacing; maximum `3` |

#### Example: one pre-screen

```json
{
  "texts": ["Paste one intact 300-3,000-word English prose section here."],
  "reviewProfile": "turnitin-pre-screen",
  "maxTexts": 1,
  "includeSentences": true,
  "includeTextPreview": false,
  "maxConcurrency": 1
}
```

#### Example: a general non-academic score

```json
{
  "text": "Paste a short product description or support reply here.",
  "reviewProfile": "general",
  "maxTexts": 1,
  "includeSentences": false,
  "includeTextPreview": false
}
```

### Output and execution contract

Each eligible section yields one dataset row. The row preserves the raw `aiPercentage` for auditability and supplies `reportedAiPercentage`, `reviewBand`, `requiresHumanReview=true`, and `reviewGuidance` for a safer queue experience.

`OUTPUT` and `RUN_SUMMARY` contain the terminal outcome, queued and saved counts, profile eligibility, provider attempts and retries, status codes, warnings, errors, and usage-event counters. Treat an `UPSTREAM_FAILED` or `PARTIAL` execution as a retry/review condition; an absent row is a signal to review the terminal summary.

| Dataset view | Use it for |
|---|---|
| `reviewQueue` | Sort eligible sections by cautious review band and human-review requirement |
| `evidence` | Inspect provider signals, highlights, feedback, and timestamped provenance |

### API and automation

Start the Actor through the Apify API, saved tasks, schedules, webhooks, or an Actor chain. A successful execution writes its dataset and summary to Apify storage, so downstream systems can read results by identifier without scraping a user interface.

```bash
curl -X POST "https://api.apify.com/v2/acts/khadinakbar~turnitin-ai-detector-alternative/runs" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "texts": ["Paste one intact 300-3,000-word English prose section here."],
    "reviewProfile": "turnitin-pre-screen",
    "maxTexts": 1,
    "includeSentences": true,
    "includeTextPreview": false
  }'
```

Retrieve dataset rows at `https://api.apify.com/v2/datasets/{datasetId}/items?clean=true` and the execution summary at `https://api.apify.com/v2/key-value-stores/{storeId}/records/OUTPUT`. Use ordinary dataset `offset` and `limit` pagination for downstream review queues.

#### AI-agent review prompt

> Screen this authorised 1,000-word English essay for AI-written-content signals. Return the dataset row's `reviewBand`, `reportedAiPercentage`, `reviewGuidance`, provider, and timestamp; then read back `OUTPUT.outcome`. Leave source-model attribution unspecified. For `PARTIAL`, `UPSTREAM_FAILED`, or `INVALID_INPUT`, surface the diagnostic or eligibility warning for a human.

The Actor is designed for an AI-agent workflow that needs bounded input, a saved dataset result, explicit outcome semantics, and pagination. Decision authority remains with the writer-review process and its human reviewer.

### Evidence and freshness

Source metadata, input rules, output fields, and provider-cost policy are recorded in the Actor source. Release verification, delayed storage readback, and usage evidence stay in the release log rather than becoming timeless marketing copy. Refresh provider pricing against the owner account before changing public price or production volume.

### Design note

I designed this workflow around a narrow question: how can a review team receive one explicit signal without confusing that signal with a decision? I chose a bounded long-form input, provenance fields, a cautious low-signal display, and mandatory human-review guidance so the output fits a real queue rather than a hidden scoring system.

### How this alternative compares with Turnitin

This comparison covers a narrow AI-written-content screening workflow. Turnitin's AI-writing feature is documented within its enhanced Similarity Report and institutional licensing context; this Actor provides a separate ZeroGPT-backed pre-screen for API-led queues. Suite and detection parity remain outside the comparison.

| Decision dimension | This Actor | Turnitin workflow | What that means |
|---|---|---|---|
| Scope and workflow | Pasted, intact 300-3,000-word English prose becomes a dataset-backed pre-screen report. | Turnitin documents AI-writing detection in its enhanced Similarity Report. | Use this Actor for the bounded API pre-screen; retain Turnitin when the institutional report workflow is required. |
| Billing and cost | The live Pricing tab shows the per-saved-report event and additional Apify platform usage. | Turnitin's documented feature is available within a licensed product environment; this comparison has no matching public self-serve same-job price. | The Actor exposes a per-report event; a price comparison requires a current Turnitin quote. |
| Effective efficiency | Eligibility validation avoids sending short, oversized, or truncated default-profile inputs to the provider. | Turnitin's suitability depends on its licensed report flow and policy configuration. | Both require human judgment; this Actor is intended for a small, pre-defined review step. |
| Output contract | Structured dataset fields, terminal outcomes, provider label, and timestamp are available to API, schedule, webhook, and Actor-chain workflows. | Turnitin's enhanced Similarity Report is a broader institutional report surface. | The API contract supports automation, but it does not replace institutional dashboard, policy, or collaboration capabilities. |
| Integration and automation | Apify runs can be started and read programmatically with storage-backed results. | Turnitin may be the better fit where its licensed integrations and institutional workflow are needed. | Select based on the actual operating workflow, not a score alone. |
| Reliability and provenance | The Actor records provider attempts, retries, status codes, and a timestamped report row when it succeeds. | Turnitin documentation cautions that AI-writing detection should not be the sole basis for adverse action. | Keep a human reviewer and the relevant policy in every decision path. |

Turnitin is a trademark of Turnitin, LLC. This independent Actor is not affiliated, associated, or endorsed by Turnitin, LLC.

### Scope, boundaries, and responsible use

- This Actor is an independent provider-backed signal, not Turnitin and not a reconstruction of Turnitin's proprietary detection method.
- It returns an estimated signal, never a verified authorship determination.
- The default pre-screen profile is intentionally narrow: English prose, 300-3,000 words, intact source text, and human review required.
- Send only text you are authorised to process. The text is sent to the selected detection provider for scoring.
- Consult applicable academic, workplace, privacy, and anti-discrimination requirements before using the output.

### FAQ

**Why does the default profile reject text outside 300-3,000 words?**

The profile is designed for long-form pre-screening. Enforcing a visible range prevents a short phrase or silently truncated document from being treated like an evidence-bearing report.

**Does an `ai` classification prove the text was written by AI?**

No. It is a routing label based on a provider score and your thresholds. Every saved default-profile report sets `requiresHumanReview` to true.

**Can it detect ChatGPT, Claude, Gemini, Copilot, DeepSeek, Grok, or Llama?**

It can screen text that may come from those and other AI writing tools, while returning a general ZeroGPT AI-writing signal. Originating-model identification is outside the report contract, and performance can vary as models and editing techniques change.

**Is a ZeroGPT key required from the caller?**

No. The Actor uses an owner-managed provider key. You are still responsible for making sure you may submit the text for processing.

**What if the provider is unavailable?**

Retryable provider interruptions receive backoff retries. When no row can be saved, `RUN_SUMMARY` records `UPSTREAM_FAILED`; when only some rows succeed, it records `PARTIAL`. The primary report event applies only to saved rows.

### Pricing and run costs

This Actor uses **Pay per event plus Apify platform usage**. The [Pricing tab](https://apify.com/khadinakbar/turnitin-ai-detector-alternative/pricing) lists the current event rates and billing terms.

| Event | Billing unit | When it applies |
|---|---|---|
| `apify-actor-start` | Actor Start | Charged when the Actor starts running. Number of events charged depends on Actor memory (one event per GB, minimum one event). |
| `ai-writing-pre-screen-completed` | AI-writing pre-screen report | One text scored by ZeroGPT and saved as a JSON report for human review. Not an authorship or misconduct finding. |

Run cost combines the charged events and Apify platform usage. Review the run charge limit and requested result count before starting.

### Connect an AI agent

Use the [Apify MCP configurator](https://mcp.apify.com) to choose an available client connection. Inspect this Actor’s current input schema and required credentials before running it.

# Actor input Schema

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

One or more intact English prose sections, one string per report. The default pre-screen profile accepts 300-3,000 words per item and rejects truncated or out-of-range text before calling the provider. Use one clearly labelled section per item so a reviewer can trace the resulting row. This is pasted text only, not a file upload or URL.

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

Optional shortcut for one pasted writing section. It is combined with texts when both are supplied. Under the default profile, provide an intact 300-3,000-word English prose section; short notes, titles, and oversized documents are declined without a provider request. Leave this empty when you use the texts list.

## `reviewProfile` (type: `string`):

Turnitin-alternative pre-screen is the safe default: it enforces a 300-3,000-word range, suppresses low-signal exact percentages, and adds mandatory human-review guidance. General keeps the same independent provider but allows shorter non-academic copy and does not apply that review band. Neither profile is Turnitin or a misconduct decision.

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

Hard cap on scored documents for this run. Default 1 keeps review queues and event charges predictable; raise it only for separate, authorised sections. This limits volume and cost, not how a provider calculates an individual score. Items outside the selected profile's eligibility rules stop the run before any provider request.

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

Character cap applied before scoring. Default 20,000 preserves most 3,000-word prose sections; the Actor declines anything it would truncate in the default pre-screen profile. Raise up to 30,000 only when the complete text still fits the 3,000-word maximum. Split longer work into labelled sections rather than silently clipping it.

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

When enabled, the dataset includes sentence-level highlights returned by the independent provider. These highlights are review cues, not a finding that a sentence was AI-written. Turn this off when your workflow only needs the document score and review band. It does not alter the report event price.

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

When enabled, each row contains the leading characters of the text so a reviewer can match the report to a source section. It is off by default for privacy-sensitive queues. The full submitted section still has to be sent to the detection provider for scoring. Do not submit personal, confidential, or restricted writing unless you are authorised to process it.

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

Provider AI percentage at or above this value receives classification=ai. Default 80 is a routing threshold for a human review queue, not an authorship conclusion. Values between the human and AI thresholds are labelled mixed. The review profile still supplies its own cautious reviewBand.

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

Provider AI percentage at or below this value receives classification=human. Default 20; values in the middle are mixed. In the default pre-screen profile, a non-zero 1-19% result is intentionally withheld as an exact displayed percentage and marked low-signal. This setting does not alter the underlying provider score.

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

How many reports may be sent to the provider at once. Default 1 prioritises stable, observable pre-screens; use 2 or 3 only after your own volume test is healthy. Retryable provider errors are retried with backoff. Each successfully saved report still creates one primary usage event.

## Actor input object example

```json
{
  "texts": [
    "The neighbourhood library has become the most useful public room in our town because it gives people a place to learn without first asking them to buy something. I first noticed this during a wet Tuesday afternoon when the buses were late and the coffee shop was full. At one table, a father was helping his daughter read a science worksheet. At another, two job seekers compared interview notes beside the printer. The librarian moved between them, answering questions about a council form, a broken keyboard, and the next book-club meeting. None of those tasks looked dramatic, but together they showed why the library matters. It turns information into a shared resource rather than a private advantage. The building also gives young people a safe place to wait after school. They can use computers, borrow novels, finish homework, or simply sit quietly before going home. Older residents use the same tables to read newspapers, learn video calling, and ask for help with online appointments. The library therefore reduces a small but important kind of isolation. It connects people who might otherwise have no reason to speak to one another. Funding a library is not only about shelves of books. It is about maintaining a dependable civic space where curiosity, practical help, and ordinary conversation can happen every day. When councils measure value only through ticket sales or retail income, they miss this wider benefit. A library earns trust slowly, through hundreds of patient interactions that do not appear on a balance sheet. The quiet routines also build confidence: a first-time borrower learns the catalogue, a teenager asks for a revision guide, and a new resident discovers a local noticeboard. Those small encounters make public services feel accessible instead of distant. That is precisely why the library deserves protection when budgets are tight."
  ],
  "text": "Paste one intact 300-3,000-word English prose section here.",
  "reviewProfile": "turnitin-pre-screen",
  "maxTexts": 1,
  "maxCharacters": 20000,
  "includeSentences": true,
  "includeTextPreview": false,
  "aiThreshold": 80,
  "humanThreshold": 20,
  "maxConcurrency": 1
}
```

# Actor output Schema

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

Dataset items containing provider signals, cautious review bands, mandatory human-review guidance, word counts, optional highlights, and provenance for each eligible section.

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

Run summary including outcome, eligibility, 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": [
        "The neighbourhood library has become the most useful public room in our town because it gives people a place to learn without first asking them to buy something. I first noticed this during a wet Tuesday afternoon when the buses were late and the coffee shop was full. At one table, a father was helping his daughter read a science worksheet. At another, two job seekers compared interview notes beside the printer. The librarian moved between them, answering questions about a council form, a broken keyboard, and the next book-club meeting. None of those tasks looked dramatic, but together they showed why the library matters. It turns information into a shared resource rather than a private advantage. The building also gives young people a safe place to wait after school. They can use computers, borrow novels, finish homework, or simply sit quietly before going home. Older residents use the same tables to read newspapers, learn video calling, and ask for help with online appointments. The library therefore reduces a small but important kind of isolation. It connects people who might otherwise have no reason to speak to one another. Funding a library is not only about shelves of books. It is about maintaining a dependable civic space where curiosity, practical help, and ordinary conversation can happen every day. When councils measure value only through ticket sales or retail income, they miss this wider benefit. A library earns trust slowly, through hundreds of patient interactions that do not appear on a balance sheet. The quiet routines also build confidence: a first-time borrower learns the catalogue, a teenager asks for a revision guide, and a new resident discovers a local noticeboard. Those small encounters make public services feel accessible instead of distant. That is precisely why the library deserves protection when budgets are tight."
    ],
    "reviewProfile": "turnitin-pre-screen",
    "maxTexts": 1,
    "maxCharacters": 20000,
    "includeSentences": true,
    "includeTextPreview": false,
    "aiThreshold": 80,
    "humanThreshold": 20,
    "maxConcurrency": 1
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/turnitin-ai-detector-alternative").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": ["The neighbourhood library has become the most useful public room in our town because it gives people a place to learn without first asking them to buy something. I first noticed this during a wet Tuesday afternoon when the buses were late and the coffee shop was full. At one table, a father was helping his daughter read a science worksheet. At another, two job seekers compared interview notes beside the printer. The librarian moved between them, answering questions about a council form, a broken keyboard, and the next book-club meeting. None of those tasks looked dramatic, but together they showed why the library matters. It turns information into a shared resource rather than a private advantage. The building also gives young people a safe place to wait after school. They can use computers, borrow novels, finish homework, or simply sit quietly before going home. Older residents use the same tables to read newspapers, learn video calling, and ask for help with online appointments. The library therefore reduces a small but important kind of isolation. It connects people who might otherwise have no reason to speak to one another. Funding a library is not only about shelves of books. It is about maintaining a dependable civic space where curiosity, practical help, and ordinary conversation can happen every day. When councils measure value only through ticket sales or retail income, they miss this wider benefit. A library earns trust slowly, through hundreds of patient interactions that do not appear on a balance sheet. The quiet routines also build confidence: a first-time borrower learns the catalogue, a teenager asks for a revision guide, and a new resident discovers a local noticeboard. Those small encounters make public services feel accessible instead of distant. That is precisely why the library deserves protection when budgets are tight."],
    "reviewProfile": "turnitin-pre-screen",
    "maxTexts": 1,
    "maxCharacters": 20000,
    "includeSentences": True,
    "includeTextPreview": False,
    "aiThreshold": 80,
    "humanThreshold": 20,
    "maxConcurrency": 1,
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/turnitin-ai-detector-alternative").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": [
    "The neighbourhood library has become the most useful public room in our town because it gives people a place to learn without first asking them to buy something. I first noticed this during a wet Tuesday afternoon when the buses were late and the coffee shop was full. At one table, a father was helping his daughter read a science worksheet. At another, two job seekers compared interview notes beside the printer. The librarian moved between them, answering questions about a council form, a broken keyboard, and the next book-club meeting. None of those tasks looked dramatic, but together they showed why the library matters. It turns information into a shared resource rather than a private advantage. The building also gives young people a safe place to wait after school. They can use computers, borrow novels, finish homework, or simply sit quietly before going home. Older residents use the same tables to read newspapers, learn video calling, and ask for help with online appointments. The library therefore reduces a small but important kind of isolation. It connects people who might otherwise have no reason to speak to one another. Funding a library is not only about shelves of books. It is about maintaining a dependable civic space where curiosity, practical help, and ordinary conversation can happen every day. When councils measure value only through ticket sales or retail income, they miss this wider benefit. A library earns trust slowly, through hundreds of patient interactions that do not appear on a balance sheet. The quiet routines also build confidence: a first-time borrower learns the catalogue, a teenager asks for a revision guide, and a new resident discovers a local noticeboard. Those small encounters make public services feel accessible instead of distant. That is precisely why the library deserves protection when budgets are tight."
  ],
  "reviewProfile": "turnitin-pre-screen",
  "maxTexts": 1,
  "maxCharacters": 20000,
  "includeSentences": true,
  "includeTextPreview": false,
  "aiThreshold": 80,
  "humanThreshold": 20,
  "maxConcurrency": 1
}' |
apify call khadinakbar/turnitin-ai-detector-alternative --silent --output-dataset

```

## MCP server setup

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

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/gmbxvNaMFf7EIxiK0/builds/rM9YagE0A7VtpFRoh/openapi.json