Image Text Remover

Remove visible text and captions from images and receive image results in your Apify storage. Background reconstruction quality depends on the image; review important outputs before using them.

The first-run form contains one demo image with text. Replace or clear that sample when adding your own URLs or uploaded files. API calls must provide their own images; an explicitly empty input is rejected.

MCP and AI agents

Use this Actor when the user wants visible text or captions removed from an image they supply. The output is an edited PNG, not OCR or a permanent CDN link.

Select apivault_labs/image-text-remover in the Actor's API → MCP tab, or connect an authenticated MCP client to:

https://mcp.apify.com/?tools=apivault_labs/image-text-remover

The direct tool is apivault_labs--image-text-remover. Keep the Apify token in the client's secure authentication configuration. Public source data does not remove the requirement for Apify authentication and applicable run charges. Read tools/list before calling: wrapper fields can differ from the Actor input schema.

Small Actor input:

{
  "workflow": "urls",
  "imageUrls": [
    "https://example.com/your-image-with-caption.png"
  ],
  "processingMode": "quality",
  "maxRetries": 1,
  "timeout": 300
}

Send this object as the direct tool's arguments. Its current wrapper also accepts waitSecs: 45. waitSecs controls how long the tool waits; it is not the Actor run timeout. If the run is still active, poll its returned run ID with get-actor-run; do not start a duplicate. Once terminal, use get-dataset-items with the returned dataset ID and a small limit/field selection, then get-key-value-store-record with the returned store ID and required record key. Missing IDs/records must be reported, not replaced with another run's storage.

Provide an accessible JPG/PNG/WebP URL or a supported data URI. Local filesystem paths and bare base64 are not accepted. API/MCP input must contain its own image; an empty API request does not use the Console demo. Allow at least 2048 MB memory and sufficient run time. If the direct tool does not expose runtime controls, use the Actor Console or the hosted generic call tool after inspecting its current schema. The CPU worker count remains one. Read rows, SUMMARY and FAILED_IMAGES; partial, no_results, stopReason and unattempted determine completion. RETRY_INPUT may contain signed URLs/image bytes: keep it private, never echo it into a public reply, and deduplicate delivered inputs before retrying.

Agent request: “Remove the caption from my supplied image. Return the authenticated PNG result, explain SUMMARY, and visually inspect the edit before calling it complete.”

Keep the first run small. Increase limits only for the requested scope, check current Pricing and cap runtime/spend using controls actually supported by your run client. Distinguish source errors, filtered emptiness and partial delivery; a completed tool call alone does not establish successful data collection.

Download result PNGs through authorized Apify storage access and inspect the actual image. Synthesis can leave text or alter covered details. Describe visual quality honestly and never present storage links as permanent public hosting.

Pricing

$0.01 per processed PNG delivered to the default Dataset ($10 per 1,000 results), plus actual Apify platform usage paid by the user, including compute and storage. The start event costs $0.00005 per GB of run memory, with a minimum of one event. Failed images and automatic retries do not add result events, but their resource usage still costs money. A delivered image is not a guarantee that every text fragment was removed.

Input

{
  "imageUrls": ["https://example.com/image-with-caption.png"],
  "processingMode": "quality",
  "maxConcurrency": 3,
  "maxRetries": 2,
  "timeout": 300
}

Supply 1-500 public JPG, PNG or WebP URLs, up to 25 MB and 25 megapixels each. Alternatively, upload files from your computer in Upload images (imageFiles) or pass an image directly as a data URI in imageUrls:

{
  "workflow": "auto",
  "imageFiles": [],
  "imageUrls": ["data:image/png;base64,<base64 image bytes>"],
  "timeout": 300
}

workflow accepts auto (default), uploads, urls, or combined. Auto and Combined merge uploaded files first, then URLs/base64, and remove exact duplicate input strings. Uploads and URLs/base64 share a total limit of 500 unique images; empty input fails without a demo. Uploads-only and URLs-only ignore the other field. The upload editor provides file references, not local filesystem paths. For JSON/API clients, use accessible URLs or data:image/png|jpeg|webp;base64,...; bare base64, filesystem paths, SVG and raw multipart requests to the Actor run endpoint are not supported. Apify's own input-size limits also apply; use the upload editor for larger images instead of a large inline JSON payload.

Exact duplicate URLs are processed once. No manual mask or text coordinates are required. Built-in AI detects text and reconstructs the masked background inside the Actor. No external processing key, guest allowance or processing proxy is required. Only input downloads and Apify storage transfers need network access. Use 2048 MB memory or more. CPU inference runs one image at a time to bound memory; maxConcurrency remains accepted for compatibility but does not increase the built-in processing worker count. Allow sufficient run time for large batches. The 500-image input limit does not guarantee 500 successful results; a 500-image cloud benchmark has not been performed.

processingMode accepts quality (default: reconstruct each text region) or fast (one whole-image pass). Quality takes longer and can still leave artifacts. Images above 2000px on the longest edge are resized proportionally; smaller images keep their dimensions. The output PNG must fit within 10 MB. Stylized, very small, low-contrast or rotated text may remain. Areas covered by text are synthesized, so original face details, texture and other hidden content cannot be guaranteed. Pixels outside the detected mask are preserved after input normalization/resizing.

Temporary processing errors retry up to maxRetries additional times (default 2, configurable 0-3), with exponential backoff within the same per-image timeout of 60-600 seconds. Invalid images and no-text detections do not retry or produce paid result rows. Completed or uncertain Dataset writes are never automatically repeated. The Actor stops at the result charge limit and keeps undelivered inputs in private RETRY_INPUT. SUMMARY reports the processing backend, actual workers, first-pass successes and retry counts; each delivered row includes attempts.

Results

The Output tab exposes Processed images, Processing summary and Failed images. The Dataset table shows the processed PNG link, input index, delivery status, dimensions, attempts and source type. Download links require authorized Apify storage access. Recovery input is kept separately in the private RETRY_INPUT record.

Successful images produce a Dataset row containing success, inputIndex, sourceType (url, upload, base64), sourceUrl, resultUrl, sessionId, width and height. sessionId is an Actor-generated identifier. The PNG is saved in the run's key-value store before the row is delivered. Download it through your Apify account; storage access and retention follow Apify's settings. These are not permanent CDN links.

Base64 payloads are omitted from output; uploads use [uploaded image] as their source reference. URL query strings and fragments are omitted from source output to avoid copying signed-link credentials. inputIndex is the zero-based index in the merged, deduplicated processing list, not the original field's index.

Failed images do not produce billable Dataset rows. FAILED_IMAGES holds input indexes and short error codes, with a neutral request stage and httpStatus when available. No provider response body or credentials are included. SUMMARY records delivery counts and peak active workers, status (complete, partial, no_results), stopReason, and unattempted images. A successful partial run does not mean all inputs finished. Progress is checkpointed after each image. RETRY_INPUT contains failed and undelivered images in a ready-to-run input object; an empty list means there is nothing to retry. Keep this record private because it can contain original signed URLs or inline image bytes. When the platform deadline is available, workers stop taking new images before it and reserve finalization time. A run with no delivered images fails. An unchanged image is reported as NO_IMAGE_CHANGE. If the detector finds no text, the image is reported as NO_TEXT_DETECTED and does not produce a paid result row.

Text over detailed backgrounds can leave artifacts or lose covered details. Use images you own or have permission to edit.