# AI Generated Image Detector from URLs (`playful_ultrasound/ai-image-detector`) Actor Detect AI-generated vs real images from public URLs. No limit on how many images you can test submit them in batches of 32 URLs per run. Get ai\_generated, deepfake, and generator scores. $0.50/100 successes; pay only when detection works. URLs only - no file upload. - **URL**: https://apify.com/playful\_ultrasound/ai-image-detector.md - **Developed by:** [Manas Khandelwal](https://apify.com/playful_ultrasound) (community) - **Categories:** AI, Developer tools, Automation - **Stats:** 4 total users, 3 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing $5.00 / 1,000 successful ai image detections This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events. Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event ## What's an Apify Actor? Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases. 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. In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md): ```bash npm install apify-client ``` In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md): ```bash pip install apify-client ``` In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md): ````bash # MacOS / Linux curl -fsSL https://apify.com/install-cli.sh | bash # Windows irm https://apify.com/install-cli.ps1 | iex ```bash In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md). If your project is in a different language, use 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 Image Detector **Who this guide is for:** Anyone running this actor on Apify — via the Console, API, or integrations. *(Developer setup, deploy, and secrets are in the GitHub repo README, not here.)* --- ### Quick start **AI image detection from URLs** — test **any number of images** in batches of **up to 32 URLs per run** (start multiple runs or loop the API for larger jobs). Paste public image links, click **Start**, open the **Dataset** for scores. Detect **AI-generated**, **deepfake**, and **generator-specific** probabilities (Midjourney, DALL·E, Stable Diffusion, and more). **$0.50 per 100 successful detections** — failed URLs are not charged. ```json { "imageUrls": ["https://picsum.photos/id/237/400/300"], "maxConcurrency": 3 } ```` *** ### What this actor does Provide **public image URLs** (up to **32 per run** — run again for more). For each URL you get one row in the **Dataset** with: - **Success:** probability scores for AI-generated content, deepfake, and specific AI generators - **Failure:** a clear error code (e.g. broken link, file too large) You do **not** upload files directly — only `http`/`https` links to images that are reachable from the internet. *** ### Before you run Your URLs must be: | Requirement | Detail | | ----------- | ------ | | **Public** | No login, no signed URLs that expire mid-run | | **Direct image links** | JPEG, PNG, WebP, GIF, etc. — not an HTML page | | **Size** | Up to **8 MB** per image | | **Count** | **Up to 32 URLs per run** — any total volume via multiple runs or API loops | | **Scheme** | `http` or `https` only | **Pricing:** **$0.50 per 100 successful detections** ($0.005 per image). You are only charged when detection succeeds — see [Billing](#billing). **Not supported:** localhost, private IPs, `file://`, or URLs behind your firewall. *** ### How to run (Apify Console) #### Step 1 — Open the actor 1. Go to [Apify Console](https://console.apify.com) 2. Open **Actors** → **AI Image Detector** #### Step 2 — Enter input 1. Click the **Input** tab 2. Paste or edit JSON. Minimal example: ```json { "imageUrls": [ "https://picsum.photos/id/237/400/300" ] } ``` 3. Or use the **Image URLs** field in the form UI — one URL per line (up to **32 per run**) Optional fields (defaults are fine for most runs). **You cannot exceed the hard limits below** — the actor clamps or rejects values server-side, even via API: ```json { "imageUrls": [ "https://picsum.photos/id/237/400/300" ], "maxConcurrency": 3, "maxRetries": 3, "requestTimeoutSeconds": 30 } ``` | If you send | Actor uses | | ----------- | ---------- | | `maxConcurrency: 99` | **5** (capped) | | `maxRetries: 10` | **3** (capped) | | `requestTimeoutSeconds: 600` | **120** (capped) | | **33+ URLs** | Run **fails immediately** (not started) | #### Step 3 — Start the run 1. Click **Start** (or **Save & Start**) 2. You are taken to the **Run** page — wait until status is **Succeeded** Typical timing: a few seconds for one small image; longer for many or large images. #### Step 4 — Read results 1. On the run page, open the **Dataset** tab 2. Each row = one input URL 3. Click a row to expand JSON, or use **Export** → JSON / CSV / Excel **Success:** open `result` → `type` → `ai_generated` (0.0–1.0). Higher = more likely AI-generated. **Failure:** top-level `error` field explains what went wrong. #### Step 5 — Re-run or schedule (optional) - **Run again:** change input → **Start** - **Schedule:** **Schedules** tab → create a cron job with the same input JSON - **Integrate:** use the **API** tab on the actor page for code snippets and your actor ID *** ### Input reference | Field | Required | Default | Description | | ----- | -------- | ------- | ----------- | | `imageUrls` | **Yes** | — | List of public image URLs (**1–32 per run**) | | `maxConcurrency` | No | `3` | Parallel images (**1–5**, hard cap) | | `maxRetries` | No | `3` | Retries on transient errors (**1–3**, hard cap) | | `requestTimeoutSeconds` | No | `30` | Per-request timeout in seconds (**5–120**, hard cap) | Values above the maximum (or below the minimum) are **automatically reduced** to the nearest allowed value. More than **32 URLs** rejects the entire run before processing starts. Large images are automatically resized before analysis — you do not need to compress them yourself. *** ### How users access this actor (Console vs API) This actor runs on **Apify’s cloud**. Users do not run Python on their machine — they **start a run** with JSON input and **read results from the dataset**. #### Apify Console (click UI) 1. Paste input → **Start** 2. Wait for run to finish 3. Open **Dataset** tab → view or export JSON/CSV Best for manual tests and small batches. #### Apify API (programmatic — “call and get results”) Typical flow: ``` POST /runs → start job with { "imageUrls": [...] } GET /runs/{id} → poll until status = SUCCEEDED GET /datasets/{id}/items → JSON array of detection results ``` Example — start and wait in one call (`waitForFinish` waits up to 120 s): ```bash curl -X POST \ "https://api.apify.com/v2/acts/YOUR_USERNAME~ai-image-detector/runs?token=YOUR_TOKEN&waitForFinish=120" \ -H "Content-Type: application/json" \ -d '{"imageUrls": ["https://picsum.photos/id/237/400/300"]}' ``` The response includes `defaultDatasetId`. Fetch rows: ```bash curl "https://api.apify.com/v2/datasets/DATASET_ID/items?token=YOUR_TOKEN" ``` **Important:** This is an **async job**, not a single instant HTTP response with scores. Each run takes seconds to minutes depending on image count and size. For long batches, poll the run status or use [Apify webhooks](https://docs.apify.com/platform/integrations/webhooks) when the run finishes. Your actor ID format: `YOUR_USERNAME~ai-image-detector` (e.g. `playful_ultrasound~ai-image-detector`). Find exact URLs on the actor page → **API** tab. *** ### Understanding the output Every dataset row has the same shape: | Field | Meaning | | ----- | ------- | | `imageUrl` | The URL you submitted | | `mode` | `upload` = processed · `rejected` = blocked before download (e.g. SSRF) | | `attempts` | How many tries were made (includes retries) | | `httpStatus` | HTTP status from the detection service (null if not reached) | | `result` | Detection scores on success (`status` + `type`), or error details on failure | | `error` | Present only when failed — see error codes below | #### Successful detection ```json { "imageUrl": "https://picsum.photos/id/237/400/300", "mode": "upload", "attempts": 1, "httpStatus": 200, "result": { "status": "success", "type": { "ai_generated": 0.02, "ai_generators": { "midjourney": 0.01, "dalle": 0.01, "stable_diffusion": 0.01 }, "deepfake": 0.01 } } } ``` **How to interpret scores** | Field | Meaning | | ----- | ------- | | `result.type.ai_generated` | Overall AI-generated probability (0–1) | | `result.type.deepfake` | Deepfake probability (0–1) | | `result.type.ai_generators.*` | Per-generator hints (Midjourney, DALL·E, etc.) | There is no fixed “threshold” in the actor — your app decides what counts as “AI” (e.g. `ai_generated > 0.5`). #### Failed detection ```json { "imageUrl": "https://example.com/not-an-image.html", "mode": "upload", "attempts": 1, "httpStatus": null, "result": { "status": "error", "error": { "type": "download_failed", "message": "download_failed" } }, "error": "download_failed" } ``` One bad URL does **not** stop other URLs in the same run — each row is independent. *** ### Batch run (multiple images) ```json { "imageUrls": [ "https://picsum.photos/id/237/400/300", "https://picsum.photos/id/238/400/300", "https://picsum.photos/id/239/400/300" ], "maxConcurrency": 3 } ``` - **Up to 32 URLs per run** — process any total volume by starting multiple runs or looping the API - Use **Export** on the dataset to download all results at once *** ### Limits (hard — enforced in code) These cannot be overridden by input, API, or Console. The actor enforces them on every run. | Limit | Maximum | If exceeded | | ----- | ------- | ----------- | | URLs per run | **32** | Run fails before processing | | `maxConcurrency` | **5** | Silently capped to 5 | | `maxRetries` | **3** | Silently capped to 3 | | `requestTimeoutSeconds` | **120** | Silently capped to 120 | | `requestTimeoutSeconds` (min) | **5** | Silently raised to 5 | | Image download size | **8 MB** | Row error `image_too_large` | | URL schemes | `http`, `https` only | Row error `blocked_url` / `invalid_url_scheme` | *** ### Error codes | Code | What happened | What to do | | ---- | ------------- | ---------- | | `blocked_url` | URL blocked (localhost, private IP, etc.) | Use a public internet URL | | `invalid_url` | Malformed URL | Fix the URL string | | `invalid_url_scheme` | Not http/https | Use `https://...` | | `image_too_large` | File > 8 MB | Host a smaller copy or resize before linking | | `download_failed` | Could not fetch URL | Check link works in a browser; fix 404/auth/hotlink blocking | | `decode_failed` | Response is not a valid image | Link must point to image bytes, not HTML | | `compress_failed` | Could not prepare image | Try another format (JPEG/PNG) | | `rate_limited` | Too many requests | Lower `maxConcurrency`, wait, retry | | `request_failed` | Temporary network/service error | Retry the run | | `service_unavailable` | Service in maintenance | Try again later (message suggests ~12 hours) | *** ### Billing This actor uses **pay per event**. You pay for successful AI detections only. #### Price | | | | -- | -- | | **Rate** | **$0.005** per successful detection | | **In practice** | **$0.50 per 100 images** (100 successes) | | **Event name** | `detection-result` | #### What you pay for | Result | Charged? | | ------ | -------- | | `result.status` = `"success"` | **Yes** — one `detection-result` event | | Failed row (bad URL, >8 MB, blocked, rate limit, etc.) | **No** — row still appears in the dataset | #### Example costs | Run | Successful images | You pay | | --- | ----------------- | ------- | | 1 test URL | 1 | **$0.005** | | Batch | 10 | **$0.05** | | Full batch (max) | 32 | **$0.16** | | Large job | 100 (e.g. 4 runs × 25) | **$0.50** | Failed URLs in the same run do **not** increase the detection charge (you still pay normal Apify compute for the run itself — see **Cost** on the run detail page). #### Before you start Set a **max cost per run** in the Console if you want a spending cap. With 32 URLs, the maximum detection charge is **32 × $0.005 = $0.16** (plus Apify platform usage for the run). *** ### Common questions **Can I upload a file from my computer?**\ No. Host the image somewhere public (S3, R2, CDN, your server) and pass the **URL**. **Why did my CDN URL fail?**\ Some CDNs block automated downloads. Test the URL in an incognito window; ensure it returns image bytes, not a login page. **Can I process more than 32 images?**\ Start multiple runs with 32 URLs each, or call the API in a loop from your own workflow. **Where is my API token?**\ Console → **Settings** → **Integrations** → **Personal API tokens**. *** ### Need help? Open a run → **Log** tab for technical details. For billing or access issues, contact the actor owner through Apify. # Actor input Schema ## `imageUrls` (type: `array`): Public http(s) image URLs up to 8 MB each. Up to 32 URLs per run — start another run or loop the API for larger batches. Large images are compressed before proxy upload. One result row per URL. ## `maxConcurrency` (type: `integer`): Maximum parallel detection requests. ## `maxRetries` (type: `integer`): Retries per detection mode on transient failures or rate limits. ## `requestTimeoutSeconds` (type: `integer`): HTTP timeout for detection and image download. ## Actor input object example ```json { "imageUrls": [ "https://picsum.photos/id/237/400/300" ], "maxConcurrency": 3, "maxRetries": 3, "requestTimeoutSeconds": 30 } ``` # Actor output Schema ## `results` (type: `string`): Dataset items with ai\_generated, deepfake, and generator scores per image URL. # 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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "imageUrls": [ "https://picsum.photos/id/237/400/300" ] }; // Run the Actor and wait for it to finish const run = await client.actor("playful_ultrasound/ai-image-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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "imageUrls": ["https://picsum.photos/id/237/400/300"] } # Run the Actor and wait for it to finish run = client.actor("playful_ultrasound/ai-image-detector").call(run_input=run_input) # Fetch and print Actor results from the run's dataset (if there are any) print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"]) for item in client.dataset(run["defaultDatasetId"]).iterate_items(): print(item) # 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start ``` ## CLI example ```bash echo '{ "imageUrls": [ "https://picsum.photos/id/237/400/300" ] }' | apify call playful_ultrasound/ai-image-detector --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "command": "npx", "args": [ "mcp-remote", "https://mcp.apify.com/?tools=playful_ultrasound/ai-image-detector", "--header", "Authorization: Bearer " ] } } } ``` ## OpenAPI specification ```json { "openapi": "3.0.1", "info": { "title": "AI Generated Image Detector from URLs", "description": "Detect AI-generated vs real images from public URLs. No limit on how many images you can test submit them in batches of 32 URLs per run. Get ai_generated, deepfake, and generator scores. $0.50/100 successes; pay only when detection works. URLs only - no file upload.", "version": "0.1", "x-build-id": "wOVdTbsFHDob1AnF4" }, "servers": [ { "url": "https://api.apify.com/v2" } ], "paths": { "/acts/playful_ultrasound~ai-image-detector/run-sync-get-dataset-items": { "post": { "operationId": "run-sync-get-dataset-items-playful_ultrasound-ai-image-detector", "x-openai-isConsequential": false, "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK" } } } }, "/acts/playful_ultrasound~ai-image-detector/runs": { "post": { "operationId": "runs-sync-playful_ultrasound-ai-image-detector", "x-openai-isConsequential": false, "summary": "Executes an Actor and returns information about the initiated run in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK", "content": { "application/json": { "schema": { "$ref": "#/components/schemas/runsResponseSchema" } } } } } } }, "/acts/playful_ultrasound~ai-image-detector/run-sync": { "post": { "operationId": "run-sync-playful_ultrasound-ai-image-detector", "x-openai-isConsequential": false, "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK" } } } } }, "components": { "schemas": { "inputSchema": { "type": "object", "required": [ "imageUrls" ], "properties": { "imageUrls": { "title": "Image URLs", "minItems": 1, "maxItems": 32, "type": "array", "description": "Public http(s) image URLs up to 8 MB each. Up to 32 URLs per run — start another run or loop the API for larger batches. Large images are compressed before proxy upload. One result row per URL.", "items": { "type": "string" } }, "maxConcurrency": { "title": "Max concurrency", "minimum": 1, "maximum": 5, "type": "integer", "description": "Maximum parallel detection requests.", "default": 3 }, "maxRetries": { "title": "Max retries", "minimum": 1, "maximum": 3, "type": "integer", "description": "Retries per detection mode on transient failures or rate limits.", "default": 3 }, "requestTimeoutSeconds": { "title": "Request timeout (seconds)", "minimum": 5, "maximum": 120, "type": "integer", "description": "HTTP timeout for detection and image download.", "default": 30 } } }, "runsResponseSchema": { "type": "object", "properties": { "data": { "type": "object", "properties": { "id": { "type": "string" }, "actId": { "type": "string" }, "userId": { "type": "string" }, "startedAt": { "type": "string", "format": "date-time", "example": "2025-01-08T00:00:00.000Z" }, "finishedAt": { "type": "string", "format": "date-time", "example": "2025-01-08T00:00:00.000Z" }, "status": { "type": "string", "example": "READY" }, "meta": { "type": "object", "properties": { "origin": { "type": "string", "example": "API" }, "userAgent": { "type": "string" } } }, "stats": { "type": "object", "properties": { "inputBodyLen": { "type": "integer", "example": 2000 }, "rebootCount": { "type": "integer", "example": 0 }, "restartCount": { "type": "integer", "example": 0 }, "resurrectCount": { "type": "integer", "example": 0 }, "computeUnits": { "type": "integer", "example": 0 } } }, "options": { "type": "object", "properties": { "build": { "type": "string", "example": "latest" }, "timeoutSecs": { "type": "integer", "example": 300 }, "memoryMbytes": { "type": "integer", "example": 1024 }, "diskMbytes": { "type": "integer", "example": 2048 } } }, "buildId": { "type": "string" }, "defaultKeyValueStoreId": { "type": "string" }, "defaultDatasetId": { "type": "string" }, "defaultRequestQueueId": { "type": "string" }, "buildNumber": { "type": "string", "example": "1.0.0" }, "containerUrl": { "type": "string" }, "usage": { "type": "object", "properties": { "ACTOR_COMPUTE_UNITS": { "type": "integer", "example": 0 }, "DATASET_READS": { "type": "integer", "example": 0 }, "DATASET_WRITES": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_READS": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_WRITES": { "type": "integer", "example": 1 }, "KEY_VALUE_STORE_LISTS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_READS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_WRITES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_INTERNAL_GBYTES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_EXTERNAL_GBYTES": { "type": "integer", "example": 0 }, "PROXY_RESIDENTIAL_TRANSFER_GBYTES": { "type": "integer", "example": 0 }, "PROXY_SERPS": { "type": "integer", "example": 0 } } }, "usageTotalUsd": { "type": "number", "example": 0.00005 }, "usageUsd": { "type": "object", "properties": { "ACTOR_COMPUTE_UNITS": { "type": "integer", "example": 0 }, "DATASET_READS": { "type": "integer", "example": 0 }, "DATASET_WRITES": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_READS": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_WRITES": { "type": "number", "example": 0.00005 }, "KEY_VALUE_STORE_LISTS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_READS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_WRITES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_INTERNAL_GBYTES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_EXTERNAL_GBYTES": { "type": "integer", "example": 0 }, "PROXY_RESIDENTIAL_TRANSFER_GBYTES": { "type": "integer", "example": 0 }, "PROXY_SERPS": { "type": "integer", "example": 0 } } } } } } } } } } ```