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.

Photo text removal for content and design teams

Use this image text remover to create a text-free candidate from a photo you are allowed to edit, then inspect the PNG before publication. It detects text and reconstructs the covered area. It does not recover the original pixels behind lettering, preserve the exact hidden object or guarantee that all writing disappears.

Use case	Useful workflow	Review requirement
Prepare a product-photo layout	Remove a visible caption, then add your own approved design externally	Check product edges, texture and reconstructed areas
Adapt a marketing image	Process an authorized captioned image	Check that important logos, labels or detail were not lost
Build an editing queue	Submit a small URL batch and inspect ordered results	Track inputIndex, failed images and delivered count
Edit a private asset	Use the upload control or an appropriate accessible input	Keep input and output storage authorized
Compare processing modes	Try quality or fast for a representative image	Judge visible artifacts; speed does not prove fidelity

The output is a reconstructed image, not OCR text, a translation or an editable design document. Table/CSV export describes the image results; the actual edited assets are PNG records in the run's storage.

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.

Start a controlled image-editing workflow

Allocate at least 2048 MB and allow time for CPU inference. Use the existing prefilled demonstration first if you want to inspect the workflow without preparing an image. Replace or clear that demo before adding your own inputs. In API requests, specify your actual images; an empty input is not a request to manufacture a demonstration result.

The examples below use OpenCV’s public Sudoku sample, a photograph with printed digits. It demonstrates an accessible text-bearing image input; it is not a measured quality benchmark or a product-photo result. Replace it with an authorized image for your own use. Text detection and reconstruction can still fail, and a schema-valid request does not guarantee a delivered image.

Use quality reconstruction for one image

{
  "workflow": "urls",
  "imageUrls": [
    "https://raw.githubusercontent.com/opencv/opencv/4.10.0/samples/data/sudoku.png"
  ],
  "processingMode": "quality",
  "timeout": 300,
  "maxRetries": 0
}

Run with at least 2048 MB in the Apify run options. The sample contains printed digits; incomplete detection or an explicit failure is still possible. Keep one image for the first test and inspect FAILED_IMAGES if nothing is delivered.

Try the faster whole-image reconstruction mode

{
  "workflow": "urls",
  "imageUrls": [
    "https://raw.githubusercontent.com/opencv/opencv/4.10.0/samples/data/sudoku.png"
  ],
  "processingMode": "fast",
  "maxConcurrency": 1,
  "timeout": 300,
  "maxRetries": 0
}

Fast changes reconstruction mode, not the number of CPU workers. It may leave more visible artifacts. Compare visual quality on an image you own rather than assuming equivalence with quality mode.

Combine the two input channels explicitly

{
  "workflow": "combined",
  "imageFiles": [],
  "imageUrls": [
    "https://raw.githubusercontent.com/opencv/opencv/4.10.0/samples/data/sudoku.png"
  ],
  "processingMode": "quality",
  "maxConcurrency": 1,
  "maxRetries": 1,
  "timeout": 600
}

This copyable URL-only instance uses the combined workflow; add uploads with the Console file editor when needed. Do not put a local filesystem path into imageFiles. Upload and URL/base64 inputs share the combined unique-image limit.

Let automatic workflow select supplied inputs

{
  "workflow": "auto",
  "imageUrls": [
    "https://raw.githubusercontent.com/opencv/opencv/4.10.0/samples/data/sudoku.png"
  ],
  "processingMode": "quality",
  "maxConcurrency": 1,
  "maxRetries": 0,
  "timeout": 180
}

Auto combines the supported sources. A shorter per-image deadline can produce an explicit timeout instead of a result. An attempt that returns no deliverable PNG does not create a paid result row; startup and resource use can still occur.

Review and download the actual PNG

Use inputIndex to associate each row with its original input, then download resultUrl using your authorized Apify storage access. Check dimensions, that the file opens as a PNG, and the visible text area at normal size. Also inspect nearby texture, product contours and faces. A changed image or a successful model call is not proof that every letter was removed cleanly.

Images above 2000 pixels on the longest edge are resized before processing. A 600-pixel source is not upscaled into a high-resolution original. Resizing and input normalization affect the comparison baseline; claims about preserving pixels outside a detected mask refer to that normalized image. Detailed or repetitive backgrounds can be difficult even when the output is valid.

Keep only the outputs your workflow accepts. Storage URLs are not permanent public hosting links. Download approved assets within your account's retention period, and retain the original privately if you need a later manual edit. Do not put signed input URLs or the private RETRY_INPUT record into a shared spreadsheet.

Batch costs, partial results and common questions

What is billed? One successfully delivered processed PNG produces one $0.01 primary result event ($10 per 1,000). The start event is $0.00005 per GB, with a one-event minimum; at the recommended 2 GB it is $0.0001. Compute/storage and other platform usage are additional. One delivered image therefore has $0.0101 in event fees at 2 GB, before usage. These event examples are not an all-in processing quote.

Does maxConcurrency process five images at once? No. The built-in model uses one processing worker to bound memory. Raising the compatibility option does not create a five-worker inference service. The input limit of 500 unique images is not a measured 500-image throughput guarantee.

What if there is no text? NO_TEXT_DETECTED does not deliver an unchanged paid image. NO_IMAGE_CHANGE also reports failure instead of billing a successful result. Inspect FAILED_IMAGES and SUMMARY; distinguish no text, a timeout, an invalid format and a processing failure.

Can I retry a partial batch? RETRY_INPUT contains failed and undelivered inputs. Review the reasons before using it in a new run. Do not resubmit successful images just because another image failed; delivering them again creates new result events. Uncertain Dataset writes are not automatically repeated by the Actor.

Can it remove every watermark or restore hidden detail? There is no completeness or authenticity guarantee. The detected region is synthesized. Use assets you own or are permitted to edit and review the result for the intended use. The Actor does not establish ownership, generate source licences or recover an original unmarked photograph.

Can an agent validate quality from the Dataset row alone? No. It can verify delivery, dimensions and diagnostics, but visual acceptance requires viewing the actual output. Existing community integrations below provide automation paths; their availability does not increase model quality or create public storage permissions.

n8n and developer integrations

Use this Actor in your automation or application with the existing community integrations below. An Apify account and API token are required; Actor and platform charges follow the current pricing.

• n8n community node: n8n-nodes-apivault-image-text-remover. Install package name n8n-nodes-apivault-image-text-remover in a self-hosted n8n instance that permits community packages.
• Python client and examples: GitHub.
• n8n source and usage: GitHub.

These are community packages. Publication on npm does not establish n8n verification or availability in n8n Cloud. Review the linked package README for supported inputs and setup.