DEV Community: API Crest

Editing Product Photos with Python: Multipart Uploads, Base64 Images, and Safe Retries

API Crest — Wed, 14 Oct 2026 12:42:01 +0000

Disclosure: I work on API Crest, the API platform used below. I checked the endpoint and parameters against the public API documentation on October 14, 2026. This is a documentation-based walkthrough: I did not execute paid generation requests, benchmark latency, or verify output quality or prices.

A product-photo editing pipeline starts with an existing image. The tricky engineering parts are uploading files, decoding the response, and not accidentally paying twice when a client times out. This guide demonstrates API Crest's synchronous image-editing route using Python and cURL. It differs from the platform's asynchronous media-generation endpoint.

1. Endpoint and preparation

The API docs document:

Base URL: https://api.vv666.ai
Image-edit endpoint: POST /v1/images/edits
Model ID: gpt-image-2.5 (a provider-documented ID)
Auth: Authorization: Bearer API_KEY
Multipart image field: repeated image[]
Required text fields: model, prompt
Default response: data[0].b64_json; an optional response_format=url also exists.

These are documented API Crest values, not universal guarantees of all OpenAI-compatible APIs. Check the live model catalog and account pricing before spending credits.

Install Python requests and place your secret in a local environment variable:

python -m pip install requests
export APICREST_API_KEY="YOUR_API_KEY"

In PowerShell, use $env:APICREST_API_KEY = "YOUR_API_KEY". Never hard-code or publish a live key.

2. Multipart cURL request

If you own or are authorized to process product.png:

curl --request POST "https://api.vv666.ai/v1/images/edits" \
  --header "Authorization: Bearer APICREST_API_KEY" \
  --form "model=gpt-image-2.5" \
  --form "image[]=@product.png" \
  --form "prompt=Place this product on a clean wooden desk in morning light. Keep its packaging colors and label as close to the reference as possible." \
  --form "size=1536x1024" \
  --form "quality=high" \
  --form "response_format=b64_json"

cURL builds the multipart boundary automatically; do not set Content-Type: application/json for this upload. A prompt cannot guarantee text, logo or packaging fidelity: manually review generated commercial assets.

3. Python: send one edit and save the image

This script deliberately does not automatically retry a possibly billable POST.

import base64
import os
from pathlib import Path

import requests

source = Path("product.png")
if not source.is_file():
    raise FileNotFoundError(source)

endpoint = "https://api.vv666.ai/v1/images/edits"
headers = {"Authorization": f"Bearer {os.environ['APICREST_API_KEY']}"}

with source.open("rb") as image:
    response = requests.post(
        endpoint,
        headers=headers,
        files={"image[]": (source.name, image, "image/png")},
        data={
            "model": "gpt-image-2.5",
            "prompt": "Place this product on a wooden desk in morning light. Preserve packaging as closely as possible.",
            "size": "1536x1024",
            "quality": "high",
            "response_format": "b64_json",
        },
        timeout=(15, 360),  # illustrative connect/read timeouts; not an SLA
    )

task_id = response.headers.get("X-Task-Id")
if task_id:
    print("Task ID:", task_id)

if not response.ok:
    try:
        error = response.json().get("error", {})
        if isinstance(error, dict) and error.get("task_id"):
            print("Task ID for follow-up:", error["task_id"])
    except (ValueError, AttributeError):
        pass
    response.raise_for_status()

image_b64 = response.json()["data"][0]["b64_json"]
output = Path("edited.png")
output.write_bytes(base64.b64decode(image_b64, validate=True))
print("Saved:", output.resolve())

The endpoint is synchronous; the 360-second example read timeout is a client choice, not a claimed measurement. With the documented response_format=url, handle data[0].url instead; don't assume those URLs last forever.

4. Two reference images

The documented multipart API accepts repeated image inputs:

--form "image[]=@product.png" \
--form "image[]=@background.png"

To send multiple files in Python requests, pass a list of repeated ("image[]", (filename, stream, mimetype)) entries, not a dictionary with duplicate keys. The docs describe up to 16 references, though individual channels may have lower limits. Validate permissions, file types and sizes.

5. Timeout and billing safety

A client timeout does not prove that the provider canceled processing. Blindly retrying the same POST could create a second billable edit. Don't implement automatic POST retries without a documented idempotency guarantee.

API Crest documents a response X-Task-Id header, possible error.task_id values, and a status/cost lookup:

GET https://api.vv666.ai/v1/skills/task-status?task_id=YOUR_TASK_ID
Authorization: Bearer YOUR_API_KEY

When is_final=true, the docs describe the settled cost as available in the task result. If the connection drops before any headers, you may have no ID: treat the outcome as unknown, reconcile activity/usage, and avoid infinite retries.

Production checklist:

Secrets: keep keys server-side, redact logs, and restrict access.
Cost: image edits use documented per-image billing; Enhanced channels can cost more. Check live channel/model prices and settled account charges; no invented dollar amounts or savings claims here.
Inputs: validate file type, size, image rights, and user authorization.
Errors: inspect sanitized status/error objects; IP allowlist restrictions may return 403 / ip_not_allowed.
Capabilities: this documented interface does not support mask or n > 1; input_fidelity is ignored.
Visual QA: review logos, ingredient text, labels, proportions, and advertising claims before publication.
Protocol: the asynchronous POST /v1/media/generate workflow is separate from synchronous /v1/images/edits.

6. What to validate yourself

Before integrating with production, make one authorized low-volume request, check that the response can be decoded, record returned task IDs, and examine actual billing. I have not run that paid test for this article.

Docs: API Crest public API documentation · API Crest platform

For developers working with product images, what is hardest: reference fidelity, long-running requests, or avoiding duplicate charges?

Python Tutorial: Chat Completions and Async Image Jobs with API Crest

API Crest — Tue, 13 Oct 2026 09:02:29 +0000

Python Tutorial: Chat Completions and Async Image Jobs with API Crest

Disclosure: I work on API Crest. This walkthrough is based on our published API documentation. It is a getting-started guide, not a claim that I've benchmarked the service or executed the example in this article.

If you're building a small AI app, you may need two very different patterns: a quick request for a text response, and an asynchronous job for image generation. This tutorial shows both patterns using Python, and explains where people often run into trouble.

1. Get an API key and install dependencies

Create an API key from the API Crest developer console, then review the model catalog and pricing before running requests. These requests may consume paid credits.

Install Python dependencies:

python -m pip install anthropic requests

Keep the API key out of source code. Set it as an environment variable in your own shell:

export APICREST_API_KEY="YOUR_API_KEY"

On Windows PowerShell, use $env:APICREST_API_KEY = "YOUR_API_KEY" for the current session.

2. Send a chat message with the Anthropic Python SDK

The API Crest documentation documents the Anthropic-style POST /v1/messages route at https://api.vv666.ai and lists claude-haiku-5-5 as a model ID.

import os
from anthropic import Anthropic

client = Anthropic(
    api_key=os.environ["APICREST_API_KEY"],
    base_url="https://api.vv666.ai",
)

response = client.messages.create(
    model="claude-haiku-5-5",
    max_tokens=256,
    messages=[
        {"role": "user", "content": "Explain idempotency in two sentences."}
    ],
)

for block in response.content:
    if getattr(block, "type", None) == "text":
        print(block.text)

The model ID is the provider's documented identifier, not a universal model name. Use the API Crest catalog to confirm current model availability and rates.

The equivalent raw HTTP shape uses a POST /v1/messages request, an API key in an accepted auth header, and JSON fields such as model, messages, and max_tokens.

3. Submit an image generation task and poll for completion

Unlike the chat request above, API Crest's media API documents an asynchronous flow:

POST /v1/media/generate with a model and prompt.
Read the returned task_id.
GET /v1/media/status?task_id=... until is_final is true.
Read result_url for a successful job, or handle an error state.

Here's a minimal example built around the documented gpt-image-2.5 model and media routes:

import os
import time
import requests

BASE = "https://api.vv666.ai"
HEADERS = {"Authorization": f"Bearer {os.environ['APICREST_API_KEY']}"}

created = requests.post(
    f"{BASE}/v1/media/generate",
    headers=HEADERS,
    json={
        "model": "gpt-image-2.5",
        "prompt": "A tiny robot watering a bonsai tree, soft studio lighting",
        "params": {"aspect_ratio": "1:1", "quality": "auto"},
    },
    timeout=30,
)
created.raise_for_status()
task_id = created.json()["task_id"]

for _ in range(20):
    check = requests.get(
        f"{BASE}/v1/media/status",
        headers=HEADERS,
        params={"task_id": task_id},
        timeout=30,
    )
    check.raise_for_status()
    job = check.json()

    if job.get("is_final"):
        if job.get("state") == "success":
            print("Result:", job.get("result_url"))
            break
        raise RuntimeError(f"Generation failed: {job.get('error', job.get('state'))}")

    time.sleep(5)
else:
    print("Job is still pending; keep the task_id and check later.")

A five-second polling interval is only an illustration, not a documented rate-limit recommendation. For production, use sensible retry/backoff logic, persist your task_id, and avoid endlessly polling a failed job.

4. Practical production checklist

Before connecting any AI API to production, I recommend:

Keep keys on the server: never expose them in a public frontend bundle.
Avoid retrying a creation request blindly: if the first response is lost after the job is accepted, a duplicate submission could incur extra cost.
Log the task ID and final status: especially important for images, video, and other long-running jobs.
Budget requests and monitor consumption: model prices and billing units differ.
Handle 403/429/5xx responses: including permission problems, throttling, and transient failures.
Choose the protocol per model: don't assume all model routes share one request schema.

Documentation and feedback

If you're integrating chat and media generation in the same app, what causes you more trouble: keeping usage costs predictable, handling async job states, or normalizing provider APIs?

I'd be interested to hear what you'd add to this checklist.

Show DEV: API Crest — A Unified AI API Platform for Multimodal Apps

API Crest — Mon, 12 Oct 2026 16:44:07 +0000

Show DEV: API Crest — A Unified AI API Platform for Multimodal Apps

Hi DEV! 👋 We're building API Crest, a platform for developers who want to experiment with different AI models without juggling separate dashboards for every use case.

As apps move beyond text into images, video, audio, and agents, an often-overlooked challenge is the integration work: API credentials, request formats, model discovery, usage tracking, and keeping a clear view of costs.

What we built

API Crest combines a developer-facing API platform with a workspace for exploring AI capabilities.

Here's what's available today:

Model discovery: browse options for chat, image, video, and audio workflows.
API access: create API keys and access documentation for the supported protocols and model routes.
Usage visibility: inspect API usage and task logs.
Usage-based billing: review model-specific pricing, with USDT top-ups supported.
Experimentation: explore models before deciding what fits your application.

Model availability, API formats, and prices vary by model, so the model catalog and documentation are the source of truth.

An integration checklist that has helped us

If you're evaluating any multi-model API provider for a real project, I'd suggest starting with five checks:

Pick one narrow workflow. For example, a chat assistant or a single image-generation task. Confirm the exact model ID and request format first.
Handle errors explicitly. Rate limits, failed generations, and timeouts are part of normal production engineering.
Track actual spend. A low-looking model price can still turn into a large monthly bill without usage visibility.
Separate asynchronous media tasks. Video or other long-running generations need clear job states and sensible polling/retry behavior.
Keep credentials server-side. Never ship a live API key inside a browser bundle or public repository.

We've designed API Crest with those day-to-day developer concerns in mind, and we're still learning from the people who use it.

Try it, and tell us what's missing

I'd especially love feedback from indie hackers, SaaS builders, and people working on AI agents.

What's the biggest obstacle when evaluating a new AI API provider? Is it pricing transparency, model compatibility, latency, error handling, payment flexibility, or something else?

I'm happy to answer questions about the platform and learn from what you're building.