What a Art Restoration Tool actually does
Restores damaged, aged, or degraded images by combining AI inpainting, super-resolution upscaling, B&W colorization, and face restoration into a browser-based workflow.
An AI art restoration tool runs uploaded photos or scans through a pipeline of three to four specialized models: an inpainting model fills cracks, tears, and missing areas; a super-resolution model adds detail at 4× or 8× scale; a colorization model reintroduces plausible color to B&W originals; and a face-restoration model reconstructs degraded portrait details. Each workflow is triggered via a browser upload, processed in a Supabase Edge Function, and returned as a before/after pair stored on Cloudflare R2. Stable Diffusion 3.5 Large with ControlNet and FLUX.2 inpainting variants handle the fill work; Real-ESRGAN handles the upscale; DeOldify handles colorization.
The market opportunity is narrow but high-margin. There is no commercial white-label SaaS in this category — Adobe Photoshop Neural Filters is desktop-only, VanceAI and MyHeritage are consumer-facing with no reseller tier, and Hotpot.ai offers an API but no dashboard product. Auction houses currently pay $200–800 per photo for human-supervised restoration. An AI tool charging $30 per restoration at ~$0.05 COGS clears 99% gross margin at a credible quality bar for catalog work. The buyer is a photo-studio operator, museum digitization vendor, or small auction house — not a Series A founder.
AI capabilities involved
Crack, scratch, and tear inpainting
Super-resolution upscaling (4×–8×)
B&W photo colorization
Damaged portrait face restoration
Missing-area generative fill
Who uses this
- Independent photo-studio operators who offer restoration as a paid service to families and estates
- Small and mid-size auction houses needing consistent catalog-quality restoration across lots
- Museum and archive digitization teams processing large volumes of historical photographs
- Family-history and genealogy services bundling restoration with scanning packages
- SaaS founders who want a niche AI image product in a category with zero white-label competition
SaaS alternatives on the market
Real products you can sign up for today — with current 2026 pricing, honest pros and cons.
VanceAI Photo Restorer
Individual users restoring a handful of family photos for personal use
3 images free
$4.95/mo (monthly credits)
Pros
- +Simple one-click interface covering inpaint, sharpen, and denoise in a single pass.
- +Web-based — no software installation required.
- +Accepts JPEG, PNG, and WebP input up to 2,000px on the paid tier.
Cons
- −No white-label or reseller tier — consumer product only.
- −Output is limited to 2× upscale on lower plans; TIFF export not available.
- −API access is not publicly documented — cannot be embedded in a client-facing workflow.
- −Branding on output is not removable on free or low-tier plans.
Hotpot.ai Photo Restoration
A developer who wants a managed API to avoid self-hosting Replicate but is comfortable building the entire UI and business logic layer
Limited free restorations with watermark
$0.15/credit (pay-as-you-go)
Pros
- +Offers an API endpoint — the only tool in this list that can be integrated into a custom dashboard.
- +Covers inpainting, colorization, and face enhancement in separate API calls.
- +Per-credit pricing is predictable for variable workloads.
Cons
- −API has no SaaS white-label dashboard — you must build your own front-end regardless.
- −Per-credit cost of $0.15 is 3× more expensive than Replicate's Stable Diffusion path for equivalent quality.
- −Documentation is sparse; rate limits and SLA are not publicly stated.
- −No multi-tenant account management — you build that layer yourself.
The AI stack
A production art restoration pipeline chains four specialized models, each optimized for a different type of image damage. The cost per full restoration (inpaint + upscale + optional colorize + optional face restore) is ~$0.05, dominated by the inpainting model, not storage.
Inpainting (crack/scratch/tear fill)
Fills missing or damaged pixels with contextually plausible content using diffusion-based inpainting
Stable Diffusion 3.5 Large via Replicate
~$0.02–0.04/imagePaid-tier professional restoration where mask precision matters
FLUX.2 inpaint (FAL.ai)
$0.03 at 1024² outputDefault production layer where ease-of-integration matters more than per-cent cost savings
Our pick: Use FLUX.2 inpaint via FAL.ai as the default — simpler integration with comparable quality. Switch to SD 3.5 Large + ControlNet only if your buyer specifically needs mask-precision control.
Super-resolution upscaling
Increases image resolution 4×–8× to produce archival-quality output from low-res originals
Real-ESRGAN (Replicate)
~$0.0025/imagePhotographic restoration on any tier; default choice for 95% of use cases
Topaz Gigapixel API
Subscription-based (contact for API pricing)Premium-tier museum or fine-art buyers who specify Gigapixel by name
Our pick: Real-ESRGAN on Replicate for all standard workflows. Offer Topaz Gigapixel as a premium add-on for museum clients at 3× the standard price — the quality difference is visible at 8× upscale on canvas-texture originals.
B&W colorization
Adds plausible natural color to black-and-white or faded photographs
DeOldify (Replicate)
~$0.005/imageFamily photograph colorization at high volume where per-image cost must stay under $0.01
Stable Diffusion SDXL colorize LoRA (Replicate)
~$0.02/imageArt auction clients who need historically accurate colorization with documented prompt instructions
Our pick: DeOldify as the default colorization layer. Offer the SDXL LoRA as a 'historical accuracy' add-on at $10 extra per image — the prompt-control advantage justifies the premium for auction and archival buyers.
Face restoration
Reconstructs degraded or blurry portrait details using GAN-based face-enhancement models
GFPGAN (Replicate)
~$0.005/imageVolume processing of family portrait archives where speed matters
CodeFormer (Replicate)
~$0.005/imagePremium portrait restoration where identity preservation is the client's top priority
Our pick: GFPGAN as default; expose a 'high-fidelity' toggle in the UI that switches to CodeFormer for an additional processing fee of $5.
Reference architecture
The pipeline is a sequential four-step Edge Function chain: upload to R2, inpaint, upscale, optional colorize/face-restore, deliver before/after pair. The hardest engineering challenge is reliable mask generation for the inpainting step — automating damage detection so the user doesn't have to draw masks manually.
User uploads original image and selects workflows
Lovable/React frontendUser drags a JPEG, PNG, or TIFF onto the upload zone and checks which workflows to apply (Restore, Colorize, Upscale, Face-Restore). File is posted directly to Supabase Storage (R2-backed) and a job record is inserted into the `restoration_jobs` table.
Damage-area mask generation
Supabase Edge Function (mask-detect)An OpenCV-based script (or Replicate's SAM2 segment-anything model at ~$0.005/image) auto-generates an inpaint mask by detecting dark linear artifacts, discoloration, and missing regions. The mask PNG is stored alongside the original in R2.
Inpainting pass
Supabase Edge Function → FAL.ai FLUX.2 inpaint APIThe Edge Function posts the original image + mask to the FLUX.2 inpaint endpoint. The result is stored in R2 under `jobs/{id}/inpainted.png`. Job status updates to `inpainted` in Supabase.
Super-resolution upscaling
Supabase Edge Function → Replicate Real-ESRGANThe inpainted image is posted to Real-ESRGAN on Replicate with scale=4. Output is stored as `jobs/{id}/upscaled.png`. For TIFF output, Sharp converts after download.
Optional colorization
Supabase Edge Function → Replicate DeOldifyIf the user selected colorization, the upscaled image is passed to DeOldify. DeOldify processes grayscale inputs; if the source was already color, this step is skipped. Output: `jobs/{id}/colorized.png`.
Optional face restoration
Supabase Edge Function → Replicate GFPGANIf the user selected face restoration, GFPGAN runs on the latest output in the chain. The fidelity weight is set to 0.7 by default (editable per tenant). Output: `jobs/{id}/face-restored.png`.
Before/after delivery and billing deduct
Supabase DB + frontendJob status is updated to `complete`. The frontend polls the `restoration_jobs` row and displays a side-by-side slider with the original and the final output. A Stripe credit is deducted from the user's `credit_balance`. Download triggers a signed R2 URL.
Estimated cost per request
~$0.05 per full restoration (FLUX.2 inpaint $0.03 + Real-ESRGAN $0.0025 + DeOldify $0.005 + GFPGAN $0.005 + R2 storage ~$0.002); ~$0.10 if all four workflows are applied in sequence
Cost calculator
Drag the sliders to model your actual usage. The numbers update in real time so you can stress-test economics before writing a single line of code.
Assumes a photo-studio or auction-house product charging per restoration credit. Defaults model 200 restorations/month at $30 each — a single part-time operator's realistic volume.
Estimated monthly cost
$61.50
≈ $738 per year
Calculator notes
- Default 200 restorations/mo at $30 each = $6,000 revenue vs ~$63 COGS = 98.9% gross margin.
- The mask-generation step (SAM2 at ~$0.005/image) is not included above — add ~$1/mo per 200 restorations.
- TIFF conversion via Sharp adds no API cost — it runs inside the Edge Function on the downloaded PNG.
- Storage cost grows with archive volume; after 500GB of before/after pairs, add ~$0.015/GB-month on R2.
Build it yourself with vibe-coding tools
By Sunday night you'll have a working Lovable app where a photo-studio operator or estate client uploads a damaged photo, selects Restore / Colorize / Upscale, pays with a Stripe credit, and downloads the result — all under your brand.
Time to MVP
12–16 hours (1 weekend)
Total cost to MVP
$25 Lovable Pro + $30 Replicate/FAL credits
You'll need
Starter prompt
Build a white-label AI art restoration web app using Vite + React + Supabase + Tailwind CSS. The app has these pages and features: 1. AUTH: Supabase email/password login + registration. After login, redirect to Dashboard. 2. DASHBOARD: Show the user's credit balance (integer, stored in `profiles.credit_balance` in Supabase). Show a list of past restoration jobs from `restoration_jobs` table with columns: id, created_at, status (pending/processing/complete/failed), original_url, result_url, workflows_applied (text array). 3. UPLOAD PAGE: A drag-and-drop file upload zone accepting JPEG, PNG, and TIFF up to 20MB. Below the dropzone, four checkboxes: Restore (inpaint cracks/tears), Upscale (4× resolution), Colorize (add color to B&W), Face Restore. A 'Start Restoration' button that is disabled if no credits. On click: (a) upload file to Supabase Storage bucket 'originals', (b) insert a row into `restoration_jobs` with status='pending' and the selected workflows as an array, (c) call the Supabase Edge Function 'process-restoration' with the job ID. 4. EDGE FUNCTION (process-restoration): Accept job_id. Fetch the job row. Call Replicate Real-ESRGAN API if 'upscale' workflow selected, call FAL.ai FLUX.2-inpaint if 'restore' workflow selected, call Replicate DeOldify if 'colorize' selected, call Replicate GFPGAN if 'face_restore' selected. Run sequentially. Store each intermediate result in R2. Update job status to 'complete' and set result_url. Deduct 1 credit from profiles.credit_balance. 5. RESULT PAGE: Show a side-by-side before/after slider (use react-compare-image package). Download button that triggers a signed URL from Supabase Storage. 6. CREDITS PAGE: Stripe payment for credit packs — 10 credits for $15, 25 credits for $30, 100 credits for $100. Use Stripe Checkout. Webhook updates credit_balance on checkout.session.completed. Use Supabase RLS: users can only see their own jobs and profiles. Keep all API keys in Supabase Edge Function secrets, never in client code.
Paste this into Lovable
Follow-up prompts (run in order)
- 1
Wire up the FAL.ai FLUX.2 inpaint API in the process-restoration Edge Function. The function should: (1) download the original image from Supabase Storage as a base64 string, (2) auto-generate a simple damage mask using a threshold filter (bright pixels = undamaged, dark linear artifacts = damaged), (3) POST both image and mask to the FAL.ai flux/flux-2-inpaint endpoint, (4) download the response, upload to Supabase Storage as jobs/{id}/inpainted.png, and update the job row.
- 2
Add Real-ESRGAN 4× upscaling after the inpaint step. Use the Replicate API: POST to `nightmareai/real-esrgan` with the inpainted image URL. Poll the prediction until status is 'succeeded'. Download result and store as jobs/{id}/upscaled.png. If inpainting was not selected, use the original image as input to the upscaler.
- 3
Add the before/after comparison slider to the Result page using the react-compare-image npm package. The left side shows the original image (original_url from the job row). The right side shows the final output (result_url). Below the slider, show a 'Download Full Resolution' button that triggers a Supabase signed URL with 1-hour expiry.
- 4
Add a simple admin page at /admin (protected by a Supabase role check for is_admin=true) that lists all restoration jobs across all users, shows total restorations by day as a simple table, and allows manually adding credits to a user account by entering their email and a credit amount.
- 5
Set up Stripe webhook handling in a new Edge Function 'stripe-webhook'. On checkout.session.completed event: (1) look up the user by customer email, (2) add the purchased credit count to profiles.credit_balance, (3) insert a row into `credit_transactions` with amount, price, and stripe_session_id. Return 200 immediately.
Expected output
A working branded restoration tool where clients upload damaged photos, pay $15–$30 per credit pack, and download restored results within 30–60 seconds — ready to show to your first five paying customers.
Known gotchas
- !Replicate cold starts on less-popular models (DeOldify, GFPGAN) can take 30–60 seconds on the first call of the day — add a loading state with a 'this may take up to 60 seconds' message, or pre-warm models by making a dummy API call every 30 minutes.
- !FAL.ai FLUX.2 inpaint requires a proper binary mask (white = inpaint here, black = keep), not a rough sketch — Lovable's first Edge Function attempt will likely use the wrong mask format; test with a hardcoded mask first.
- !Supabase Storage has a 50MB file size limit on the free tier; switch to Supabase Pro ($25/mo) before accepting TIFF uploads, which can easily exceed this.
- !The react-compare-image package does not work well with TIFF format in browsers — convert TIFF to high-quality JPEG (95%) before storing the result_url that feeds the comparison slider.
- !RLS policy setup in Lovable often misses the edge case where the Edge Function (running as service_role) needs to read the job row but the user row must be checked separately — test this before launch or you'll hit 403 errors in production.
- !Stripe webhook signature verification requires the raw request body, not a parsed JSON — Lovable's default Edge Function handler may accidentally parse the body; add `const rawBody = await req.arrayBuffer()` before any other parsing.
Compliance & risk reality check
AI art restoration compliance is lighter than video or voice generation — you are restoring existing images rather than synthesizing new content. The main concerns are copyright ownership of the restored output and provenance transparency for institutional buyers.
Copyright ownership of AI-restored output
Restoring an image with AI does not transfer copyright to the restorer — the original copyright (or public domain status) carries through to the restored version. A restored version of a copyrighted painting still belongs to the rightsholder. Your tool should not claim copyright over outputs in its ToS.
Mitigation: Add a ToS clause stating: 'Restoration does not grant the platform or operator any copyright interest in the restored image. Users warrant they have the right to process and download the images they upload.' This is standard SaaS language.
AI provenance (C2PA) for museum and archival use
Museums, archives, and auction houses increasingly require C2PA (Coalition for Content Provenance and Authenticity) manifest on AI-processed images to maintain chain-of-custody documentation. The EU AI Act Art. 50 mandates machine-readable labeling on AI-generated content from August 2, 2026, though restoration of existing images is in a gray zone compared to purely synthetic generation.
Mitigation: Embed a simple XMP metadata tag in the output file noting 'AI-processed by [ProductName] on [date]' via Sharp's metadata API. For institutional buyers, offer a downloadable JSON provenance record documenting which models and parameters were applied.
Cultural-heritage data care (NAGPRA-adjacent)
If your tool is used by museum clients to process imagery of Indigenous artifacts, sacred objects, or human remains, NAGPRA (Native American Graves Protection and Repatriation Act) and equivalent international frameworks impose duties of care on access and reproduction. AI restoration of such imagery could be considered reproduction.
Mitigation: Flag this consideration in your onboarding for museum buyers. Recommend they consult their institution's collections management policy before submitting NAGPRA-relevant materials. This is a disclosure responsibility, not a technical one.
Build vs buy: the real math
3–4 weeks
Custom build time
$13,000–$16,000
One-time investment
5–6 months
Breakeven vs buying
At 200 restorations/month at $30 each, monthly revenue is $6,000 and API COGS is ~$63 — a 98.9% gross margin. A RapidDev custom build at $13K–$16K pays back in 2–3 months at that volume. The build-yourself Lovable path costs $25 + API credits and delivers the same economic model, but with more initial iteration time. The honest verdict for this niche: build-yourself first, validate that 100+ clients will pay $30/restoration, and only commission a full custom build when you're at $3,000+/mo in revenue. Model prices are also falling — Real-ESRGAN and GFPGAN Replicate costs have dropped 40% since 2024, making the economics only more favorable over time.
Skip the DIY — RapidDev builds the production version
A Lovable MVP gets you a demo. Production needs auth that doesn't leak data, AI calls that don't bankrupt you, observability when models drift, and code you can audit. That's what we ship.
Discovery call (free)
30 minWe map your exact Art Restoration Tool use case: who uses it, target volume, AI model choice, integrations, compliance scope. You get a detailed scope document and fixed-price quote within 48 hours.
AI-accelerated build
3–4 weeksOur engineers use Claude Code, Lovable, and custom tooling to ship 3–5x faster than agencies. You see weekly progress in a staging environment — not a black box.
Launch + handoff
1 weekWe deploy to your infrastructure, transfer the GitHub repo, set up CI/CD and monitoring, and train your team. You own 100% of the source code, prompts, and model configurations.
What you get
Timeline
3–4 weeks
Investment
$13,000–$16,000
vs SaaS
ROI in 5–6 months
30-min call. Fixed-price quote within 48 hours. No commitment.
Frequently asked questions
How much does it cost to build a white-label AI art restoration tool?
A RapidDev custom build runs $13,000–$16,000 for a 3–4 week project covering auth, credit billing, multi-workflow pipeline (inpaint, upscale, colorize, face restore), and the before/after comparison UI. A Lovable DIY build costs $25/mo for Pro plus ~$30 in Replicate and FAL.ai API credits for the first month. Both paths deliver the same core product; the custom build adds production-grade multi-tenant account management and TIFF export.
How long does it take to ship an AI art restoration product?
A working MVP with the core three workflows (restore, upscale, colorize) takes one weekend on Lovable — roughly 12–16 hours of work including setup. A RapidDev custom build with multi-tenant client accounts, production Stripe billing, and TIFF-quality output takes 3–4 weeks. The longest part of any build is the mask-generation step for inpainting — expect to iterate on that 2–3 times before it handles all damage types reliably.
Is there any white-label AI art restoration SaaS I can resell without building?
No. As of mid-2026 there is no commercial white-label SaaS in this category. VanceAI, MyHeritage Photo Enhancer, and Remini are all consumer-only products with no reseller tier. Hotpot.ai offers a pay-per-call API but no SaaS dashboard — using it still requires building your own front-end. The absence of white-label competition is exactly what makes this a defensible build.
What image types and damage conditions can AI restoration handle reliably?
The current pipeline handles physical damage (scratches, tears, water stains, foxing) via inpainting; resolution/blur issues via upscaling; faded B&W photographs via colorization; and degraded portrait detail via face restoration. It does not reliably reconstruct large missing areas (more than ~20% of image area), does not handle 3D sculptural damage, and struggles with non-photographic media like charcoal or pencil drawings. GFPGAN's face restoration occasionally hallucinates incorrect features on very low-resolution (<100px face crop) inputs.
Can RapidDev build this for my auction house or photo studio?
Yes. RapidDev has shipped 600+ applications including AI image processing pipelines. The standard art restoration build runs $13K–$16K and includes auth, Stripe credit billing, all four restoration workflows, before/after comparison UI, and TIFF export. Book a free 30-minute consultation at rapidevelopers.com to scope your specific requirements.
Do I own the copyright on AI-restored images I produce for clients?
No — restoration does not transfer copyright. The original copyright (or public domain status) of the source image persists through the restoration process. Your ToS should make clear that the platform claims no copyright interest in outputs, and users warrant they have the right to process the images they upload. For auction-house catalog use, standard buyer/seller agreements already cover reproduction rights for catalog purposes.
How does processing time compare to human restoration services?
AI restoration takes 30–90 seconds per image depending on which workflows are applied. Human-supervised restoration takes hours to days and costs $200–800 per image for professional archival work. The quality ceiling for AI remains below expert human restoration for severe damage (missing large areas, complex painting reconstruction) — position AI as a fast, affordable first pass for catalog and family use, not a replacement for museum-grade conservation on irreplaceable originals.
Want the production version?
- Delivered in 3–4 weeks
- You own 100% of the code
- AI cost monitoring built in
30-min call. No commitment.