Migrate from the OpenAI image API to PixelFireman

You are already generating images with OpenAI (DALL·E 3 or gpt-image-1). PixelFireman is a standard REST image API with Bearer auth, so for most integrations you change the base URL and one response-reading line. This page maps every request parameter and response field, calls out what is different, and gives you a working before/after example.

The short version: keep your prompt, point at https://pixelfireman.com/v1/images, send your pf_live_ key, and read data.image instead of data.data[0].url. Branch on format (url vs svg) and read creditsUsed to track spend.

Why switch

• Cost. A 1024×1024 image is 1 credit. At the $50 Pro pack that is about $0.00625 per image, roughly 6× cheaper than OpenAI’s standard image rate of $0.04 (DALL·E 3, 1024×1024, standard quality). Credits are prepaid and never expire.
• Same workload, lower cost. Generate images for the same publishing workload, articles, blogs, news, SEO pages, directory listings and feeds, at a lower cost.
• No SDK lock-in. It is one POST with a JSON body. Any HTTP client works.
• Vector mode. Ask for flat SVG logos/icons with mode: "draw", something the OpenAI image API does not return.

Request parameter mapping

OpenAI’s POST /v1/images/generations maps to PixelFireman’s POST /v1/images:

Authentication mapping

Both use a Bearer header, so this line barely changes:

PixelFireman also accepts x-api-key: pf_live_... as an alternative. Get your key in the account dashboard.

Response field mapping

OpenAI nests the result under data[]. PixelFireman returns a flat object, read image directly and lead on creditsUsed for billing.

Before / after: a working example

The same “generate and save a PNG” task, in Node 18+ fetch.

import fs from "node:fs";
import OpenAI from "openai";

const openai = new OpenAI({
  apiKey: process.env.OPENAI_API_KEY,
});

const r = await openai.images.generate({
  model: "dall-e-3",
  prompt: "a red fox sitting in autumn leaves",
  size: "1024x1024",
  n: 1,
});

const url = r.data[0].url;
const img = await fetch(url);
const buf = Buffer.from(await img.arrayBuffer());
fs.writeFileSync("output.png", buf);
console.log("Saved output.png");

import fs from "node:fs";

const API_KEY = process.env.PF_API_KEY;

const res = await fetch(
  "https://pixelfireman.com/v1/images", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    prompt: "a red fox sitting in autumn leaves",
    mode: "generate",
    size: "1024x1024",
  }),
});

if (!res.ok) {
  const e = await res.json().catch(() => ({}));
  throw new Error(`HTTP ${res.status}: ${e.error}`);
}

const data = await res.json();
console.log("credits used:", data.creditsUsed,
            "left:", data.usage.creditsLeft);

if (data.format === "url") {
  const img = await fetch(data.image);
  const buf = Buffer.from(await img.arrayBuffer());
  fs.writeFileSync("output.png", buf);
} else {
  fs.writeFileSync("output.svg", data.image);
}
console.log("Saved output");

The real changes: no SDK, the endpoint URL, read data.image (not data.data[0].url), and branch on data.format. Everything else is your existing prompt and size.

Unsupported features & how to handle them

Error handling mapping

Both return a JSON body on error. OpenAI nests it under error.message; PixelFireman returns a flat { "error": "..." }. Status codes line up closely:

A migration-friendly read: OpenAI code that checks res.ok and reads err.error.message should read err.error (a string) on PixelFireman. Billing never happens on a failed, blocked, or unauthorised request.

Quality tradeoffs, stated plainly

PixelFireman photo generation runs on FLUX.1 [schnell], a different model from DALL·E 3 / gpt-image-1. Honest expectations:

• Great fit: article heroes, blog illustrations, news thumbnails, SEO and listing imagery, social feeds, product mockups, placeholder/visual-filler at volume, anywhere you need a fitting image fast and cheap.
• Different, not strictly better or worse: composition and literal prompt-following differ between models. Expect to tweak a few prompts when you switch.
• Where premium models can still win: dense text rendering inside the image, highly cinematic or stylised art direction, and some complex multi-subject scenes. For those, keep a premium model on that specific path and use PixelFireman for the high-volume rest.
• Vector art: for flat logos and icons, mode: "draw" returns clean SVG, which OpenAI’s image API does not do.

The goal is not “identical output”, it is generating images for the same publishing workload at a lower cost.

Pricing at a glance

A 1024×1024 image is 1 credit; credits scale with megapixels (rounded up, min 1). Best rate ($0.00625 / image) is on the $50 Pro pack. Prepaid, no subscription, credits never expire. The 6× comparison is against OpenAI’s standard $0.04 image rate (DALL·E 3, 1024×1024, standard quality, as of October 2026).