Flux 2 Pro API in JavaScript — Quick Start Guide 2026
Build production-ready AI image generation in minutes using Flux 2 Pro via NexaAPI on RapidAPI.
Introduction
Flux 2 Pro is one of the most advanced text-to-image generation models available in 2026, delivering photorealistic, high-resolution images with exceptional prompt adherence. Developed by Black Forest Labs, it excels at complex compositions, fine details, and artistic styles that rival human-created artwork.
While the official Flux 2 Pro API costs $0.06 per image, NexaAPI provides the same model at just $0.02 per image — that's 3x cheaper. NexaAPI is available on RapidAPI, making it easy to integrate into any JavaScript or TypeScript project with a single API key.
In this guide, you'll learn how to integrate Flux 2 Pro into your Node.js or browser-based application using the native Fetch API, with no extra dependencies required for Node 18+.
Prerequisites
- Node.js 18+ (for native fetch support) or any modern browser
- npm or yarn package manager
- A free RapidAPI account to get your API key
- Basic knowledge of JavaScript async/await
Installation
No special SDK is required. If you're using Node.js 18+, the native fetch API is built-in. For older Node versions, install node-fetch:
# For Node.js 18+, no installation needed! # For older Node.js versions: npm install node-fetch # TypeScript users (optional type definitions): npm install --save-dev @types/node
Subscribe to the Flux 2 Pro API on RapidAPI and copy your x-rapidapi-key from the dashboard.
Quick Start
Here's a complete, working example to generate your first image with Flux 2 Pro:
// flux2pro-generate.js
// Works with Node.js 18+ (native fetch) or browser environments
const RAPIDAPI_KEY = 'YOUR_RAPIDAPI_KEY'; // Replace with your key
const API_HOST = 'flux-2-pro.p.rapidapi.com';
const generateImage = async (prompt, options = {}) => {
const response = await fetch(`https://${API_HOST}/generate`, {
method: 'POST',
headers: {
'x-rapidapi-key': RAPIDAPI_KEY,
'x-rapidapi-host': API_HOST,
'Content-Type': 'application/json'
},
body: JSON.stringify({
prompt,
width: options.width || 1024,
height: options.height || 1024,
steps: options.steps || 28,
guidance: options.guidance || 3.5,
...options
})
});
if (!response.ok) {
const error = await response.json();
throw new Error(`API Error ${response.status}: ${error.message}`);
}
const data = await response.json();
console.log('✅ Image generated successfully!');
console.log('Image URL:', data.url);
return data;
};
// Example usage
generateImage('a breathtaking mountain landscape at golden hour, photorealistic, 8K detail')
.then(result => {
console.log('Result:', result);
})
.catch(err => console.error('Error:', err));TypeScript version with full type safety:
// flux2pro-generate.ts
interface Flux2ProOptions {
width?: number;
height?: number;
steps?: number;
guidance?: number;
seed?: number;
output_format?: 'jpeg' | 'png' | 'webp';
}
interface Flux2ProResponse {
url: string;
width: number;
height: number;
seed: number;
timings?: Record<string, number>;
}
const RAPIDAPI_KEY = process.env.RAPIDAPI_KEY!;
const API_HOST = 'flux-2-pro.p.rapidapi.com';
export async function generateFlux2ProImage(
prompt: string,
options: Flux2ProOptions = {}
): Promise<Flux2ProResponse> {
const response = await fetch(`https://${API_HOST}/generate`, {
method: 'POST',
headers: {
'x-rapidapi-key': RAPIDAPI_KEY,
'x-rapidapi-host': API_HOST,
'Content-Type': 'application/json',
},
body: JSON.stringify({ prompt, ...options }),
});
if (!response.ok) {
throw new Error(`HTTP ${response.status}: ${response.statusText}`);
}
return response.json() as Promise<Flux2ProResponse>;
}Advanced Usage
Flux 2 Pro supports a rich set of parameters for fine-grained control over image generation:
// Advanced configuration example
const advancedGenerate = async () => {
const result = await generateImage(
'a futuristic cityscape at night, neon lights, rain-soaked streets, cyberpunk aesthetic',
{
width: 1440, // Up to 2048px
height: 960, // Landscape format
steps: 40, // More steps = higher quality (20-50)
guidance: 4.5, // Prompt adherence (1-10, higher = more literal)
seed: 42, // Reproducible results
output_format: 'png', // 'jpeg', 'png', or 'webp'
}
);
return result;
};
// Batch generation with rate limiting
const batchGenerate = async (prompts) => {
const results = [];
for (const prompt of prompts) {
const result = await generateImage(prompt);
results.push(result);
// Respect rate limits: add delay between requests
await new Promise(resolve => setTimeout(resolve, 500));
}
return results;
};
// Save image to disk (Node.js)
import { writeFileSync } from 'fs';
const saveImage = async (prompt, filename) => {
const result = await generateImage(prompt);
const imageResponse = await fetch(result.url);
const buffer = await imageResponse.arrayBuffer();
writeFileSync(filename, Buffer.from(buffer));
console.log(`Saved to ${filename}`);
};Key Parameters Reference
| Parameter | Type | Default | Description |
|---|---|---|---|
| prompt | string | required | Text description of the image |
| width | number | 1024 | Output width in pixels |
| height | number | 1024 | Output height in pixels |
| steps | number | 28 | Inference steps (20-50) |
| guidance | number | 3.5 | Prompt guidance scale |
| seed | number | random | Seed for reproducibility |
Pricing Comparison
NexaAPI offers Flux 2 Pro at a fraction of the official price. Here's how the costs compare for typical usage:
| Provider | Price per Image | 100 Images | 1,000 Images | Savings |
|---|---|---|---|---|
| NexaAPI (RapidAPI) | $0.02 | $2.00 | $20.00 | 3x cheaper |
| Official Black Forest Labs | $0.06 | $6.00 | $60.00 | — |
💡 Pro tip: At scale, the savings are massive. Generating 10,000 images costs $200 with NexaAPI vs $600 officially — saving you $400 every month.
Frequently Asked Questions
Q: Is NexaAPI's Flux 2 Pro the same model as the official one?
Yes, NexaAPI provides access to the exact same Flux 2 Pro model from Black Forest Labs. The only difference is the pricing — NexaAPI acts as a cost-efficient proxy, passing through the same API capabilities at a lower price point.
Q: How do I handle rate limits in production?
Implement exponential backoff with retry logic. When you receive a 429 status code, wait progressively longer between retries (e.g., 1s, 2s, 4s). For high-volume applications, consider using a queue system like Bull or BullMQ to manage concurrent requests.
Q: Can I use Flux 2 Pro in a browser (frontend) application?
Technically yes, but it's strongly recommended to make API calls from your backend to protect your RapidAPI key. In a Next.js app, use API routes or Server Actions. In Express, create a proxy endpoint that forwards requests to RapidAPI without exposing your key to clients.
Start Generating Images Now
Get access to Flux 2 Pro at $0.02/image — 3x cheaper than official pricing. Subscribe on RapidAPI and start building in minutes.
🚀 Subscribe to Flux 2 Pro on RapidAPINo credit card required to start • Free tier available