Remini is a great consumer app — but it has no public REST API. If you need to restore old, damaged, or blurry photos inside your own application, PixelAPI's photo restoration API is the best free alternative to Remini. One HTTP call, results in under 2 minutes, $0.020 per image. 300 free credits included, no credit card required.
Remini is a subscription consumer app (iOS / Android) with no published REST API, no webhooks, and no SDK. If you are building a photo-archive digitizer, an ancestry app, a heritage photo restoration service, or any pipeline that processes old photos at scale, you cannot use Remini programmatically.
PixelAPI provides a production REST API for the same underlying task: detecting and reconstructing damaged or missing detail in old photos, repairing compression artifacts, sharpening degraded images, and applying face enhancement to portraits — all in a single authenticated HTTP call that returns a download URL.
The best free alternative to Remini for a developer team is an API that processes photos programmatically, integrates with your backend, and charges per call rather than per seat. PixelAPI fits that description: 300 free credits to start, $0.020 per image afterward, and SDKs in six languages.
Sign up, copy your key from the dashboard, and POST your image. The endpoint queues the job and returns a generation_id; poll until status=completed, then download the restored JPEG from output_url.
# Step 1 — submit the image for restoration
curl -X POST https://api.pixelapi.dev/v1/photo-restore/generate \
-H "Authorization: Bearer YOUR_API_KEY" \
-F "file=@old_family_photo.jpg" \
-F "mode=full" \
-F "restore_faces=true"
# {"generation_id": "abc-123", "status": "processing", "estimated_seconds": 120}
# Step 2 — poll until completed (typically 25-90 s)
curl https://api.pixelapi.dev/v1/photo-restore/abc-123 \
-H "Authorization: Bearer YOUR_API_KEY"
# {"status": "completed", "output_url": "https://api.pixelapi.dev/outputs/images/..."}
pip install pixelapi
---
from pixelapi import PixelAPI
client = PixelAPI(api_key="YOUR_API_KEY")
result = client.photo_restore(image="old_family_photo.jpg", restore_faces=True)
result.save("restored.jpg") # restored JPEG downloaded automatically
npm install pixelapi
---
import { PixelAPI } from "pixelapi";
const client = new PixelAPI({ apiKey: process.env.PIXELAPI_KEY });
const result = await client.photoRestore({ image: "./old_family_photo.jpg", restoreFaces: true });
await result.save("restored.jpg"); // polls and downloads automatically
composer require pixelapi/pixelapi
---
<?php
use PixelAPI\Client;
$client = new Client(getenv("PIXELAPI_KEY"));
$result = $client->photoRestore(["image" => "old_family_photo.jpg", "restore_faces" => true]);
file_put_contents("restored.jpg", $result->getBody());
gem install pixelapi
---
require "pixelapi"
client = PixelAPI::Client.new(api_key: ENV["PIXELAPI_KEY"])
result = client.photo_restore(image: "old_family_photo.jpg", restore_faces: true)
File.binwrite("restored.jpg", result.body)
go get github.com/pixelapi/pixelapi-go
---
import "github.com/pixelapi/pixelapi-go"
client := pixelapi.New("YOUR_API_KEY")
result, err := client.PhotoRestore("old_family_photo.jpg", pixelapi.RestoreOptions{RestoreFaces: true})
if err != nil { panic(err) }
result.Save("restored.jpg")
The table below compares PixelAPI against Remini and the most commonly compared photo and face restoration services. Remini, MyHeritage, and Fotor have no developer REST API — they are consumer products only. PixelAPI is the managed, pay-per-call API alternative.
| Provider | Developer API | Free tier | Per-image cost | Managed / no-infra |
|---|---|---|---|---|
| PixelAPI | ✓ REST + SDKs | 300 credits, no card | $0.020 | ✓ Fully managed |
| Remini | ✕ Consumer app only | Limited in-app credits | Subscription (~$4.99/week) | N/A — no API |
| MyHeritage | ✕ Consumer service only | Limited free plan | Subscription (see myheritage.com/pricing) | N/A — no developer API |
| VanceAI Restore | ✓ REST API | Some trial credits | See vanceai.com/pricing | ✓ Managed |
| fal.ai (full restoration) | ✓ REST API | Credit-based trial | ~$0.040 | ✓ Managed |
Pricing verified from each provider's public pricing page, November 2026. Remini pricing from iOS App Store listing. MyHeritage pricing from myheritage.com/pricing. fal.ai price from fal.ai pricing page. PixelAPI price from api.pixelapi.dev/v1/pricing/live.
The API returns a download URL (output_url) for the restored image as a JPEG. Resolution is preserved — no internal downsampling. Store the URL for 24 hours or download immediately to your own storage.
The default mode processes the entire photo: repairing degradation, removing artifacts, and sharpening detail across the full frame. Not just faces — landscapes, buildings, documents, and mixed-subject photos all benefit.
Pass restore_faces=true (the default) and the pipeline applies an additional enhancement pass on detected faces within the image — sharpening portrait subjects without a separate API call.
If a job fails or times out (10-minute watchdog), credits are automatically refunded — you are never charged for a broken result. The error_message field on the poll response explains what went wrong.
POST returns a generation_id immediately (HTTP 202). Poll GET /v1/photo-restore/{generation_id} until status=completed. All SDKs poll and download automatically — no manual retry code needed.
Accepts photos up to 30 MB — covers most high-resolution scans from flatbed and document scanners. Larger files can be downscaled before upload without meaningful quality loss for restoration tasks.
These production workflows all use POST /v1/photo-restore/generate as a core step. Each guide walks through the full setup:
Batch-restore entire portrait session archives. Automate old negative scans through photo restoration before delivery.
Fix blurry and motion-affected faces in bulk after high-volume event shoots.
Restore historical family photos for sharing. Sharpen low-resolution scans before posting.
Enhance heritage product lifestyle shots and historical brand imagery at scale.
Restore archive campaign photos, tear sheets, and editorial scans from print.
Revive archival brand photography for reuse in modern campaigns and ads.
Enhance agent headshots and clean up old property-listing portrait photos.
Restore historical author portraits and archival press photographs for publishing.
Sharpen faces in digitized portraits and antique photographs for print-quality output.
More photo restoration use-case guides: all industries →
Trigger photo restoration on seller profile photo upload via Shopify webhook.
No-code restoration workflow — trigger from Google Drive, Dropbox, or Airtable.
Drag-and-drop photo restoration module in Make scenarios.
Enhance portrait photos on Webflow CMS upload via webhook.
Server-side photo restoration in Next.js API routes. Full example with polling.
Restore member profile photos in Wix using Velo backend automation.
Remini is a consumer app with no REST API. PixelAPI is a developer-first managed API with per-call billing and 300 free credits.
Topaz is desktop software. PixelAPI is a REST endpoint — no installation, embeddable in any server-side stack.
Same image quality class. PixelAPI offers a free tier with no credit card required.
Fotor is a web app. PixelAPI plugs directly into your CI pipeline, mobile app backend, or bulk-processing script.
Rate limits by plan: 20 req/min (3 parallel) on free trial; 60/min (10 parallel) on Starter; 120/min (20 parallel) on Pro; 300/min (50 parallel) on Scale. See parallel processing docs for concurrent batch patterns. Exceeding the limit returns HTTP 429 with a Retry-After header. Recommended: exponential backoff starting at 2 s, doubling each retry up to 30 s. The Python and Node SDKs handle this automatically.
# Python SDK — automatic retry on 429 from pixelapi import PixelAPI client = PixelAPI(api_key="...", max_retries=4) result = client.photo_restore(image="photo.jpg") # retries on 429 automatically
Common error codes:
402 insufficient_credits — top up credits from the dashboard. Credits are pre-checked before processing begins.413 — input exceeds 30 MB. Downscale the image before uploading.429 rate_limit_exceeded — slow down; use Retry-After from the response header.503 photo_restore_temporarily_unavailable — backend under maintenance; you are not charged. Retry after a few minutes.PixelAPI's photo restoration API. Unlike Remini (iOS/Android only, no REST API), PixelAPI gives developers a production endpoint at POST /v1/photo-restore/generate. New accounts get 300 free credits — roughly 15 full restorations — with no credit card required.
No. Remini is a consumer mobile app. It does not publish a REST API, webhooks, or SDKs for third-party developers. For programmatic photo restoration, you need a dedicated API service.
$0.020 per image (20 credits at $0.001 per credit on the Starter plan). New accounts start with 300 free credits. Pricing is at parity with comparable managed-API services (October 2026 audit).
POST your image to https://api.pixelapi.dev/v1/photo-restore/generate with an Authorization: Bearer YOUR_API_KEY header and form fields file, mode=full, and restore_faces=true. The endpoint returns a generation_id; poll GET /v1/photo-restore/{generation_id} until status=completed, then download from output_url. See the Quick Start section for 6-language examples.
Old, damaged, degraded, blurry, and compression-artifact-heavy photos. Set restore_faces=true (default) to also apply face enhancement to any portraits in the image. Use cases include family photo archives, ancestry research, old wedding photos, damaged print scans, and low-quality historical images.
Processing typically takes 25-90 seconds on a warm backend. The endpoint is asynchronous — POST the image to get a generation_id immediately, then poll until complete. The response includes an estimated_seconds field. A 10-minute watchdog auto-fails and refunds credits if no result arrives.
Open-source restoration tools are free to self-host, but require model downloads, a Python environment, and your own compute capacity. PixelAPI is fully managed — no model management, no procurement, no cold-start delays. At $0.020 per image, it is often competitive with the total cost of cloud GPU compute plus engineering time.
Yes. Pass restore_faces=true (default) in the form data. The pipeline applies additional face enhancement as part of the full photo restoration pass — no separate API call required.
Yes. pip install pixelapi (Python) and npm install pixelapi (Node.js). Official clients also available for PHP (Composer), Ruby (Gem), and Go (go get github.com/pixelapi/pixelapi-go). All SDKs handle authentication, job polling, 429 retry-with-backoff, and binary image download automatically.
The API returns a URL (output_url) pointing to the restored image as a JPEG. Download the file with any HTTP client. The URL is valid for 24 hours; store it in your own storage if you need permanent access.
If the job fails or times out (10-minute watchdog), status is set to failed and credits are automatically refunded — you are never charged for a failed restoration. The error_message field explains the failure reason.
20 req/min (3 parallel) on the free trial; 60 req/min (10 parallel) on Starter; 120 req/min (20 parallel) on Pro; 300 req/min (50 parallel) on Scale. Exceeding limits returns HTTP 429 with a Retry-After header. Python and Node SDKs retry automatically. Email support@pixelapi.dev for higher throughput on batch workloads.