Is there an API that tells me which celebrity I look like?

This endpoint is the closest thing to it, with one important difference: it answers in a picture, not a name. Send one portrait in image_url and you get back one generated image of the closest celebrity look-alike. No field in the response holds a name, a ranked list or a percentage, so a product that wants to print a name has to decide on one itself.

Why does the Celebrity Look-Alike API not return a name or a similarity score?

Because there is no classification step behind it whose label we could pass through — the endpoint generates a frame, it does not look anyone up in a list. Adding a name field would mean shipping a claim about a real person on the strength of a resemblance. The wording in your interface is yours to write and yours to answer for.

How many fields does the Celebrity Look-Alike API take?

One. image_url is required and it is the entire request body; additionalProperties is false, so any other key is rejected rather than ignored. There is no prompt, no seed, no resolution and no output format to send. If a result disappoints, the only thing you can change is the photograph.

Can I send a group photo or a picture with more than one face?

Send one face per request. With several people in frame the endpoint has no way to know which one you meant, so the result is arbitrary rather than wrong in a way you can correct. Crop to a single face first. Heavy profile angles, sunglasses, other occlusions, motion blur and very small faces are the other common reasons a match degrades.

What makes a photo fail with invalid_request?

A photo the endpoint cannot work with is turned away as invalid_request before any generation starts — that class is for problems the caller can fix, not for a generation that went wrong. In practice it means the face is too small in frame, too heavily occluded, or at too steep an angle. A tighter crop of the same subject usually clears it.

Is there a synchronous call, or do I have to poll?

There is no synchronous mode. Submitting returns a task id, and you read that task until it reports a terminal state. Build it as a background job with a placeholder on screen rather than a blocking call inside a page load. A task that never becomes terminal is closed at the endpoint's 1,800-second ceiling instead of hanging open.

Do I need consent to send someone's photo to a face similarity API?

Yes. Send only portraits of people who knew what the photo was for and agreed to it, which in practice means the user's own photo, taken in your product, for this feature. Consent has to be in place before the file reaches your storage, because it cannot be added afterwards. Never send a photo of a public figure. Individual requests are not reviewed, so that check sits with you.

Can I use this to identify someone or verify an identity?

No. Never route identification, identity verification or monitoring of any kind through this endpoint, and never keep the inputs as a face database. It produces a picture, not a determination about a person, and it is not built, tested or offered as a recognition system. When you decide whether a use is allowed, judge it as strictly as you would judge face recognition.

Can I present the result as a fact about the person in the photo?

No. The output is a generated image, not a finding, and it carries no name or score precisely because there is nothing behind it that could be presented as one. Caption it as a generated resemblance, keep it out of anything that reads as an identity claim, and never attach a real person's name to it as a statement of fact.

How long are the photo and the result kept?

The image you send is deleted after 1 day and the generated result after 14 days. Those are the platform's own retention windows, and they are shorter than most product lifecycles, so copy anything you plan to show again into your own storage while you are handling the terminal poll. Your own retention policy is a separate decision.

How is the Celebrity Look-Alike API billed, and am I charged for a match I would not have picked?

It is billed per request on a single flat tier, so one request is one charge and nothing in the photo changes the amount. A completed generation is charged even when the resemblance is not the one you would have chosen; there is no 'only if it is a good match' condition. A photo turned away as invalid_request never becomes a generation, so there is nothing to bill. The current amount is on the price panel above.

Celebrity Look-Alike API

spicyapi/look-alike-v1/edit

Celebrity Look-Alike takes one portrait and returns a generated image of the closest celebrity match, with no prompt and no parameters. The photo must show a single clear, roughly frontal face, and the result carries no name or score.

From $0.05/image

Run model View API

Output

Ready for a new run

Example result

Animate

Edit

Split into layers

Introduction

It takes a single portrait and returns a generated image of the closest celebrity look-alike. There is no prompt and no parameter surface: the photo is the entire input.

The request is one image URL, billed per request. It is built as a one-call feature for entertainment and social products, not as an identification tool.

Key features & highlights

One photo in, one frame back — there is nothing else to send

The whole request is a single image URL. There is no prompt, no seed, no size and no strength, so the picture you upload is the only thing that moves the result. Submit it and poll for the frame, the same shape as every other media call in this catalog, and the per-request price stays the same whoever comes back in the frame.

A generated frame, not a name and not a score

The response carries one image and nothing else: no celebrity name, no ranked list of candidates, no similarity percentage. Whatever sits next to the frame is copy you wrote, not a claim the model made, and that is the safer way round. Build the moment on the frame itself — show it, let people share it, and resist putting a number beside it.

When you decide whether you may use it, treat it as face recognition

The input is always a real person's face, which puts this endpoint under likeness and biometric rules that nothing else in this catalog touches. Biometric data is separately regulated in the European Union and in parts of the United States, and the consent bar there can be high. Send only photos the subject knowingly agreed to — never a public figure's, never images taken from somewhere else — and never use it for identification, verification, surveillance or to build a face database. Nothing that comes back is a factual statement about a real person; uploaded source images are deleted after one day and generated results after 14.

Request parameters

Request parameters for Celebrity Look-Alike · Image Editing
Parameter	Required	Description
`image_url`	Yes	One clear, roughly frontal portrait with a single visible face. Group shots, profiles, sunglasses and motion blur are where the match degrades or the call fails. at least 1 characters

Pricing

$0.05 / request

A match you would not have picked is still a completed request and is charged.

Use cases

One upload, one frame to share

Use this endpoint when the product moment is a single photo upload followed by a generated frame to share. Send the portrait as image_url, poll the task and show the image that comes back; there is no name or score to display beside it.

Entertainment and social features

The 'which celebrity do you look like' interaction, as one API call behind a photo upload. It is a shareable moment inside a consumer app rather than a production tool.

Campaign mechanics

A lightweight interactive step in a marketing flow — upload a selfie, get a frame back to share. One call per participant keeps the cost predictable.

Photo and beauty apps

A novelty feature alongside existing portrait tools. It needs no prompt engineering and no parameter surface, so it drops into an app with a single form field.

Explore key use-case tutorials

Prompt guide & pro tips

Expect an image, not a verdict

The endpoint returns a generated frame, not a name, a ranking or a similarity score. If your product needs a label, you have to present the frame itself — the API gives you nothing else to display.

Send one clear, frontal portrait

A single well-lit face, roughly facing the camera, filling a reasonable part of the frame. Group shots, heavy profiles, sunglasses, motion blur and very small faces are where the match degrades or the call fails outright.

Check the result before iterating

One face per image, roughly frontal and clearly lit. Profile angles, occlusion (sunglasses, hands, hair across the face), motion blur and very small faces degrade the match or fail the call. There is no prompt, no mask, no strength and no seed: if the output is wrong, the only fix is a different photo. The response is an image and nothing else — no name, no ranking, no confidence value.

API quick start

# Generate the idempotency key once; reuse it when retrying after a lost response.
export SPICY_IDEMPOTENCY_KEY="${SPICY_IDEMPOTENCY_KEY:-$(uuidgen)}"
curl -X POST https://api.spicyapi.ai/api/v1/jobs/createTask \
  -H "Authorization: Bearer $SPICY_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $SPICY_IDEMPOTENCY_KEY" \
  -d '{
  "model": "spicyapi/look-alike-v1/edit",
  "input": {
    "image_url": "https://example.com/reference.png"
  }
}'

# Copy data.taskId from the response into TASK_ID, then poll the status.
TASK_ID="TASK_ID_FROM_RESPONSE"
curl "https://api.spicyapi.ai/api/v1/jobs/recordInfo?taskId=$TASK_ID" \
  -H "Authorization: Bearer $SPICY_API_KEY"

See the API reference for authentication, the complete schema, polling, and error handling.

Related models and next tasks

Missing the model you need?

Tell us what to add and where you would use it. Requests go to the people who decide what gets onboarded next.

One image field, no parameters, one generated frame back

The Celebrity Look-Alike edit API takes a single portrait in image_url and returns one generated image of the closest celebrity look-alike. That field is the entire request body: there is no prompt, no seed, no resolution and no output format, and additionalProperties is false, so any other key fails validation. The response carries the image and nothing else — no name, no candidate list, no similarity score.

Open the playground

Request body: image_url (string, required) is the whole body — one property, and no prompt, seed, resolution or output format to send
Input URL: Must resolve straight to the image file, open without a login, and stay live until the task finishes
Response: One generated image. No celebrity name, no candidate list, no similarity score
Call pattern: Asynchronous: submit, keep the task id, poll to a terminal state. Task ceiling 1,800 seconds
Retention: The photo you send is deleted after 1 day, the generated result after 14 days
Consent: Every input is a real person's face. Send only portraits the subject agreed to

Schema: One property, and every other key is a validation errorThe request schema defines image_url and sets additionalProperties to false. A leftover prompt string, or a strength value copied from another endpoint's payload, comes back as a validation error naming the field, and no task is created from it. Nothing is queued, and nothing is quietly dropped on the way through.
Response: The name and the score are absent on purposeThere is no classification step behind this endpoint whose label could be passed through: it generates a frame, it does not look anyone up in a list. So the response holds no celebrity name, no ranked shortlist and no confidence value. Whatever caption your interface shows is yours to write and yours to stand behind.
Consent: The input is a real person's face on every single callNothing else in this request is sensitive; the photograph is. In practice the only safe source is the user's own portrait, taken inside your product, for this feature, with consent captured before the file reaches your storage. When you decide whether you may run it at all, judge it as strictly as you would judge face recognition — even though this endpoint recognises nobody.

What the Celebrity Look-Alike API does well

The entire request body is one field
image_url is required, nothing else is accepted, and that is the complete list. There is no template to render and no dynamic field table to maintain: one string variable dropped into a JSON object covers every call this endpoint will ever take, whether the photo is a phone selfie or a studio headshot.
Nothing to tune means nothing to mis-tune
No prompt to write, no seed to pin, no resolution or output format to pick. The only lever you have is the photograph itself, so when a result disappoints, the fix is a different shot — tighter crop, more even light, face squarer to the camera — rather than a sweep through parameters that do not exist.
One face per request, by design
The endpoint takes one portrait and has no way of being told which person in a frame you meant, so a group shot is the wrong input rather than a harder one. Cropping to a single face before you submit removes the most common cause of a match nobody in the room agrees with.
One task, one image
A finished task exposes a single generated image from platform storage, and there is no count or batch field to ask for more. Ten portraits means ten tasks, each with its own id, its own poll state and its own charge, which keeps one unusable photo from stalling the other nine.
Asynchronous, with a 1,800-second ceiling
Submitting answers with a task id rather than an image, and you read that task until it reports a terminal state. There is no synchronous mode to fall back on. A task that never becomes terminal is closed at the endpoint's 1,800-second ceiling instead of hanging open indefinitely.
Two retention clocks to plan around
The photo you send is deleted after 1 day and the generated result after 14 days. Neither number is an obstacle to work around — they are the reason to pull a frame you intend to keep into your own storage on the way past, and the reason a share card cannot point at our URL forever.

Who Celebrity Look-Alike is for

Consumer product teams
A feature that asks the user for nothing but a photo
There is no prompt box to design, no style picker to explain, and no failure mode where someone writes something unusable. The interaction is upload, wait, see a frame, which is why the whole feature fits behind one button and a placeholder — and why the hard design work is the consent screen in front of it.
Backend integration engineers
A schema small enough to hardcode instead of templating
With one string to populate, the request body needs no field registry, no schema-driven form generator and no validation layer of your own. What remains is plumbing: a URL that resolves to bytes, an idempotency key on the create, a poll loop, and a copy step before the retention window closes.
Privacy and legal review
A decision that belongs before launch, not after
Biometric data is separately and strictly regulated in the European Union and in several US states, and that obligation sits with you rather than with us. Settle three things in writing first: where consent is captured, how long the photo lives on your own side, and who is accountable for the words shown next to the result.
Teams retrofitting an existing upload flow
Where the new obligations land in a pipeline you already run
If portraits already move through your product, the endpoint itself is a small addition and the additions that matter are elsewhere. Consent has to be captured before the file reaches your storage, because it cannot be added afterwards, and our 1-day and 14-day clocks change nothing about your own retention policy.

How to call the Celebrity Look-Alike API

Capture consent before the photo exists in your storage
Consent sits one step earlier than the URL, and it cannot be backfilled. Decide what the subject is agreeing to, record that they agreed, and keep that record joined to the photo. This is the step that determines whether the rest of the integration is allowed to run at all.
Stage a URL that returns the image file itself
image_url is a string, so the link has to resolve straight to the image bytes and open without a login. A page the photo is embedded in is not a photo. If your storage hands out short-lived signed URLs, check the link is still valid at submit time and keep it live until the task finishes.
Send the one-field body with an idempotency key
Build the body from image_url alone, and strip anything left over from another endpoint's payload, because additionalProperties is false. Attach an Idempotency-Key: if the connection drops and your client retries, the key returns the original task instead of opening a second one with a second charge.
Poll the task id until it is terminal
The submit response carries the id and nothing else, so read the task until it reports a terminal state. Do not hold a user-facing request open waiting for it — hand the browser a placeholder and fill it in when the poll lands, and treat the 1,800-second ceiling as the outer bound of the loop.
Copy the frame, then write the caption yourself
The result URL points at platform storage and that file is deleted after 14 days, so pull anything destined for a gallery or a share card into your own bucket on the way past. The response carries nothing to label the image with, so every word next to it is a claim you are making.

Celebrity Look-Alike worked examples

A one-button feature inside a consumer app
The user takes a portrait in the app, ticks a consent box that says exactly what the photo will be used for, and the client stores it in your own bucket. Your backend submits one field, shows a placeholder, and swaps in the frame when the poll returns. Parameter surface exposed to the user: none.
A queue of portraits that survives a dropped connection
A batch runner sends one task per portrait, each with an Idempotency-Key derived from the stored photo's id. When a submit is interrupted and the runner retries, the key returns the original task rather than opening a second one, so a restarted batch does not pay twice for a portrait it already sent.
A gallery that outlives the 14-day window
A product that lets users come back to earlier results cannot link our asset URLs, because those files are deleted after 14 days. The working shape is a copy step in the same worker that handles the terminal poll: fetch once, store in your own bucket, record your own URL, and never read ours again.