papaiapi

Available Models

Base URLs

Authentication

OpenAI style:

Authorization: Bearer sk_live_your_api_key_here

Gemini style:

?key=sk_live_your_api_key_here
# or header:
x-goog-api-key: sk_live_your_api_key_here

Endpoints

{
  "url": "https://papaiapi.com/temp/abc123.wav"
}

Gemini API Endpoints

Direct Gemini API Proxy /v1direct

A transparent proxy in front of Google's generativelanguage.googleapis.com. Anything you'd send to the Google endpoint, send to /v1direct instead and we forward it through a rotated pool of Gemini API keys + US residential proxies. You get every official Gemini model and feature (text, multimodal, function calling, streaming, long context, thinking, etc.) with no quota of your own — billed per request through your papaiapi balance.

Base URL & Auth

BASE_URL  https://papaiapi.com/v1direct
HEADER    x-goog-api-key: sk_live_your_api_key_here
# or:     Authorization: Bearer sk_live_your_api_key_here
# or:     ?key=sk_live_your_api_key_here

The path you send is forwarded verbatim to Google. So:

POST  https://papaiapi.com/v1direct/v1beta/models/gemini-2.5-flash:generateContent
   →  https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash:generateContent

Pricing

$0.50 per 1,000 requests, regardless of model or response size. (No token-based billing — flat rate.)

Quickstart

# Install Google's official agent CLI
npm install -g @google/gemini-cli

# Point it at papaiapi instead of Google's endpoint
export GOOGLE_GEMINI_BASE_URL="https://papaiapi.com/v1direct"
export GEMINI_API_KEY="sk_live_your_api_key_here"

# Done — same CLI, same agent, your papaiapi balance pays
gemini -m gemini-2.5-flash --yolo -p "List the .ts files here and tell me how many"
gemini -m gemini-2.5-pro -i "Refactor this codebase"

import { GoogleGenAI } from '@google/genai';

const ai = new GoogleGenAI({
  apiKey: 'sk_live_your_api_key_here',
  httpOptions: { baseUrl: 'https://papaiapi.com/v1direct' },
});

// Generate
const result = await ai.models.generateContent({
  model: 'gemini-2.5-flash',
  contents: 'What is 17 times 23?',
});
console.log(result.text);

// Stream
const stream = await ai.models.generateContentStream({
  model: 'gemini-2.5-flash',
  contents: 'Write a haiku about proxies.',
});
for await (const chunk of stream) {
  process.stdout.write(chunk.text);
}

// Function calling
const tools = [{ functionDeclarations: [{
  name: 'get_weather',
  description: 'Get the weather for a city',
  parameters: { type: 'object', properties: { city: { type: 'string' } } },
}]}];
const fc = await ai.models.generateContent({
  model: 'gemini-2.5-flash',
  contents: 'What is the weather in Tokyo?',
  config: { tools },
});
console.log(fc.functionCalls);

from google import genai
from google.genai import types

client = genai.Client(
    api_key="sk_live_your_api_key_here",
    http_options=types.HttpOptions(base_url="https://papaiapi.com/v1direct"),
)

# Generate
result = client.models.generate_content(
    model="gemini-2.5-flash",
    contents="What is 17 times 23?",
)
print(result.text)

# Stream
for chunk in client.models.generate_content_stream(
    model="gemini-2.5-flash",
    contents="Write a haiku about proxies.",
):
    print(chunk.text, end="")

# generateContent
curl -X POST "https://papaiapi.com/v1direct/v1beta/models/gemini-2.5-flash:generateContent" \
  -H "x-goog-api-key: sk_live_your_api_key_here" \
  -H "Content-Type: application/json" \
  -d '{
    "contents": [{"parts": [{"text": "What is 17 times 23?"}]}]
  }'

# streamGenerateContent (SSE)
curl -N -X POST "https://papaiapi.com/v1direct/v1beta/models/gemini-2.5-flash:streamGenerateContent?alt=sse" \
  -H "x-goog-api-key: sk_live_your_api_key_here" \
  -H "Content-Type: application/json" \
  -d '{
    "contents": [{"parts": [{"text": "Count from 1 to 5."}]}]
  }'

# List models
curl "https://papaiapi.com/v1direct/v1beta/models" \
  -H "x-goog-api-key: sk_live_your_api_key_here"

How rotation works

Every request picks a random (key, US residential proxy) pair. On any of:

• 429 / quota exhausted → key cooled off 5 min, retried with a fresh pair
• 403 "denied access" / API_KEY_INVALID → key permanently invalidated, retried with a fresh pair
• 5xx upstream error → retried with a fresh pair (no key penalty)
• Network / proxy fetch failure → retried with a fresh pair

Up to 8 retries per request. After that, Google's actual error response is forwarded back to you verbatim. You're charged only on a final 2xx — failures cost you nothing.

Video Artifact Removal /v1/videos/artifact-removal

Per-frame alpha-blend inversion for videos. You supply a source video, a reference PNG of the overlay you want to remove (logo, subtitle burn-in, timestamp, network bug, etc.), and the pixel position. We extract raw frames with ffmpeg, reverse the alpha blend on the artifact region of each frame, and re-encode with the original audio.

The math is the same alpha-blend inverse used in the existing image watermark remover — generalised for arbitrary reference assets and applied per-frame: original = (output − α·logo) / (1 − α), with α taken from the reference image.

Endpoint

POST https://papaiapi.com/v1/videos/artifact-removal
Authorization: Bearer sk_live_your_api_key_here
Content-Type: multipart/form-data

Multipart fields

* Alternatively send a JSON body with video_url and reference_url as publicly-accessible HTTPS URLs.

Response

{
  "id": "vid_1700000000_abc123",
  "url": "https://papaiapi.com/temp/<outputfile>.mp4",
  "duration_seconds": 12.5,
  "frames_processed": 300,
  "processing_ms": 5400,
  "output_bytes": 2456789,
  "cost": 0.125
}

Output URLs expire after 1 hour. Download promptly if you need to keep them.

Pricing

$0.01 per second of source video. A 30-second clip costs $0.30. Failed requests (bad input, processing error) cost $0.

Limits

• Max source duration: 5 minutes (configurable per-account on request).
• Max file size: 100 MB per file (source video + reference).
• Sync endpoint — request returns when processing completes (typical 0.5–3× real-time depending on resolution).

Preparing the reference asset

You need one PNG showing what to remove. Two formats work:

1. RGBA (most editors): logo on transparent background, alpha = opacity. White (255,255,255) RGB inside the logo, alpha channel carries the gradient.
2. Brightness-encoded: opaque PNG, black background, logo drawn in white. The brightness value at each pixel = α × 255.

If you don't have a clean reference, the simplest capture: render a black-background sample of whatever produces the overlay, crop the artifact region, save as PNG.

Quick test

# Remove a 130x40 logo at corner (1100, 640) of a 1280x720 video
curl -X POST "https://papaiapi.com/v1/videos/artifact-removal" \
  -H "Authorization: Bearer sk_live_your_api_key_here" \
  -F "video=@input.mp4" \
  -F "reference=@logo.png" \
  -F 'position={"x":1100,"y":640}'

Caveats

• Pixels where α ≈ 1 (fully opaque points) are mathematically unrecoverable — they get capped near the logo color. Most real-world artifacts are partially transparent (α ≈ 0.6–0.85 in the strokes) and recover cleanly.
• Re-encoding to H.264 reintroduces small chroma compression artifacts — the cleaned region will be slightly softer than the rest. Use a high reference resolution and the lowest crf you can afford if quality matters.
• Position is fixed across the whole video. If the artifact moves or animates, this technique doesn't apply — you'd want per-frame detection (out of scope for this endpoint).

Code Examples

from openai import OpenAI

client = OpenAI(
    base_url="https://papaiapi.com/v1",
    api_key="sk_live_your_api_key_here"
)

# Simple request
response = client.chat.completions.create(
    model="gemini-flash",
    messages=[{"role": "user", "content": "Hello!"}]
)
print(response.choices[0].message.content)

# Streaming
stream = client.chat.completions.create(
    model="gemini-flash",
    messages=[{"role": "user", "content": "Write a poem"}],
    stream=True
)
for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="")

# Simple request
curl -X POST "https://papaiapi.com/v1/chat/completions" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer sk_live_your_api_key_here" \
  -d '{
    "model": "gemini-flash",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'

# Streaming
curl -X POST "https://papaiapi.com/v1/chat/completions" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer sk_live_your_api_key_here" \
  -d '{
    "model": "gemini-flash",
    "messages": [{"role": "user", "content": "Hello!"}],
    "stream": true
  }'

import OpenAI from 'openai';

const client = new OpenAI({
  baseURL: 'https://papaiapi.com/v1',
  apiKey: 'sk_live_your_api_key_here'
});

// Simple request
const response = await client.chat.completions.create({
  model: 'gemini-flash',
  messages: [{ role: 'user', content: 'Hello!' }]
});
console.log(response.choices[0].message.content);

// Streaming
const stream = await client.chat.completions.create({
  model: 'gemini-flash',
  messages: [{ role: 'user', content: 'Write a poem' }],
  stream: true
});
for await (const chunk of stream) {
  if (chunk.choices[0].delta.content) {
    process.stdout.write(chunk.choices[0].delta.content);
  }
}

Response Format

Chat Completion

{
  "id": "chatcmpl-abc123",
  "object": "chat.completion",
  "created": 1234567890,
  "model": "gemini-flash",
  "choices": [{
    "index": 0,
    "message": {
      "role": "assistant",
      "content": "Hello! How can I help you?"
    },
    "finish_reason": "stop"
  }],
  "usage": {
    "prompt_tokens": 0,
    "completion_tokens": 0,
    "total_tokens": 0
  }
}

Streaming Response (OpenAI)

data: {"id":"chatcmpl-abc","choices":[{"delta":{"role":"assistant"},"index":0}]}

data: {"id":"chatcmpl-abc","choices":[{"delta":{"content":"Hello"},"index":0}]}

data: {"id":"chatcmpl-abc","choices":[{"delta":{"content":"!"},"index":0}]}

data: {"id":"chatcmpl-abc","choices":[{"delta":{},"finish_reason":"stop","index":0}]}

data: [DONE]

Image Generation

{
  "created": 1234567890,
  "data": [{
    "url": "https://papaiapi.com/temp/abc123.jpg",
    "revised_prompt": "your original prompt"
  }]
}

Note: Image URLs expire after 1 hour. Download images promptly if you need to keep them.

Image Generation Examples

from openai import OpenAI

client = OpenAI(
    base_url="https://papaiapi.com/v1",
    api_key="sk_live_your_api_key_here"
)

# Grok (default)
response = client.images.generate(
    prompt="A cat wearing a tiny hat",
    n=1
)
print(response.data[0].url)

# Gemini Image
response = client.images.generate(
    model="gemini-image",
    prompt="A sunset over mountains"
)
print(response.data[0].url)

# Flow Image (NanoBanana Pro 2K, landscape)
response = client.images.generate(
    model="nanobananapro2k",
    prompt="A futuristic cityscape",
    size="1792x1024"
)
print(response.data[0].url)

# Grok (default)
curl -X POST "https://papaiapi.com/v1/images/generations" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer sk_live_your_api_key_here" \
  -d '{
    "prompt": "A cat wearing a tiny hat"
  }'

# Gemini Image
curl -X POST "https://papaiapi.com/v1/images/generations" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer sk_live_your_api_key_here" \
  -d '{
    "model": "gemini-image",
    "prompt": "A sunset over mountains"
  }'

# Flow Image (NanoBanana Pro 2K, portrait)
curl -X POST "https://papaiapi.com/v1/images/generations" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer sk_live_your_api_key_here" \
  -d '{
    "model": "nanobananapro2k",
    "prompt": "A futuristic cityscape",
    "size": "1024x1792"
  }'

import OpenAI from 'openai';

const client = new OpenAI({
  baseURL: 'https://papaiapi.com/v1',
  apiKey: 'sk_live_your_api_key_here'
});

// Grok (default)
const response = await client.images.generate({
  prompt: 'A cat wearing a tiny hat'
});
console.log(response.data[0].url);

// Gemini Image
const geminiResponse = await client.images.generate({
  model: 'gemini-image',
  prompt: 'A sunset over mountains'
});
console.log(geminiResponse.data[0].url);

// Flow Image (NanoBanana Pro 2K, landscape)
const flowResponse = await client.images.generate({
  model: 'nanobananapro2k',
  prompt: 'A futuristic cityscape',
  size: '1792x1024'
});
console.log(flowResponse.data[0].url);

Voice Generation Examples

import requests

response = requests.post(
    "https://papaiapi.com/v1/audio/speech",
    headers={
        "Authorization": "Bearer sk_live_your_api_key_here",
        "Content-Type": "application/json"
    },
    json={
        "model": "gemini-voice",
        "input": "Hello, welcome to our podcast!"
    }
)
data = response.json()
print(data["url"])  # WAV file URL

# Generate voice audio
curl -X POST "https://papaiapi.com/v1/audio/speech" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer sk_live_your_api_key_here" \
  -d '{
    "model": "gemini-voice",
    "input": "Hello, welcome to our podcast!"
  }'

const response = await fetch('https://papaiapi.com/v1/audio/speech', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer sk_live_your_api_key_here',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    model: 'gemini-voice',
    input: 'Hello, welcome to our podcast!'
  })
});
const data = await response.json();
console.log(data.url); // WAV file URL

File Analysis (Gemini Files)

Analyze documents, images, and videos with Gemini AI. Upload a file and provide a prompt.

Endpoint

Request (Multipart Upload)

Send a file via multipart/form-data with a file field and prompt field.

Request (URL)

Or send JSON with file_url (publicly accessible URL) and prompt.

Response

Returns an OpenAI-compatible chat completion response with the analysis in choices[0].message.content.

File Analysis Examples

# Upload a file
curl -X POST "https://papaiapi.com/v1/files/chat" \
  -H "Authorization: Bearer sk_live_your_api_key_here" \
  -F "file=@document.pdf" \
  -F "prompt=Summarize this document"

# Or use a file URL
curl -X POST "https://papaiapi.com/v1/files/chat" \
  -H "Authorization: Bearer sk_live_your_api_key_here" \
  -H "Content-Type: application/json" \
  -d '{
    "file_url": "https://example.com/document.pdf",
    "prompt": "Summarize this document"
  }'

import requests

# Upload a file
with open('document.pdf', 'rb') as f:
    response = requests.post(
        'https://papaiapi.com/v1/files/chat',
        headers={'Authorization': 'Bearer sk_live_your_api_key_here'},
        files={'file': f},
        data={'prompt': 'Summarize this document'}
    )
print(response.json()['choices'][0]['message']['content'])

const form = new FormData();
form.append('file', fs.createReadStream('document.pdf'));
form.append('prompt', 'Summarize this document');

const response = await fetch('https://papaiapi.com/v1/files/chat', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer sk_live_your_api_key_here',
  },
  body: form
});
const data = await response.json();
console.log(data.choices[0].message.content);

Gemini SDK Examples

import google.generativeai as genai

genai.configure(
    api_key="sk_live_your_api_key_here",
    transport="rest",
    client_options={"api_endpoint": "papaiapi.com"}
)

model = genai.GenerativeModel('gemini-flash')
response = model.generate_content("Hello!")
print(response.text)

# Generate content
curl -X POST "https://papaiapi.com/v1beta/models/gemini-flash:generateContent?key=sk_live_your_api_key_here" \
  -H "Content-Type: application/json" \
  -d '{
    "contents": [{
      "parts": [{"text": "Hello!"}]
    }]
  }'

# Streaming
curl -X POST "https://papaiapi.com/v1beta/models/gemini-flash:streamGenerateContent?key=sk_live_your_api_key_here" \
  -H "Content-Type: application/json" \
  -d '{
    "contents": [{
      "parts": [{"text": "Write a poem"}]
    }]
  }'

import { GoogleGenerativeAI } from '@google/generative-ai';

const genAI = new GoogleGenerativeAI('sk_live_your_api_key_here', {
  baseUrl: 'https://papaiapi.com/v1beta'
});

const model = genAI.getGenerativeModel({ model: 'gemini-flash' });
const result = await model.generateContent('Hello!');
console.log(result.response.text());

Gemini Response Format

{
  "candidates": [{
    "content": {
      "parts": [{"text": "Hello! How can I help you?"}],
      "role": "model"
    },
    "finishReason": "STOP",
    "index": 0
  }],
  "usageMetadata": {
    "promptTokenCount": 0,
    "candidatesTokenCount": 0,
    "totalTokenCount": 0
  }
}

Gemini Streaming Response

data: {"candidates":[{"content":{"parts":[{"text":"Hello"}],"role":"model"},"index":0}]}

data: {"candidates":[{"content":{"parts":[{"text":"!"}],"role":"model"},"index":0}]}

data: {"candidates":[{"content":{"parts":[{"text":""}],"role":"model"},"finishReason":"STOP","index":0}]}

Rate Limits

Error Codes

OpenAI Error Format

{
  "error": {
    "message": "Insufficient balance",
    "type": "insufficient_balance",
    "code": 402
  }
}

Gemini Error Format

{
  "error": {
    "code": 402,
    "message": "Insufficient balance",
    "status": "FAILED_PRECONDITION"
  }
}