Nano Banana Pro API какое ограничение на размер одного изображения? Полный

Поддерживаемые MIME-типы и форматы

Nano Banana Pro API принимает следующие форматы изображений:

# Поддерживаемые MIME-типы
SUPPORTED_MIME_TYPES = [
    "image/png",      # PNG - лучше для скриншотов, графики
    "image/jpeg",     # JPEG/JPG - оптимально для фотографий
    "image/webp",     # WebP - современный формат с хорошим сжатием
    "image/heic",     # HEIC - формат Apple (iPhone/iPad)
    "image/heif"      # HEIF - расширенная версия HEIC
]

Какой формат выбрать?

Совет: Если у вас PNG размером 10MB с фотографией, конвертируйте в JPEG quality=85 — получите ~2-3MB без видимой потери качества.

Требования к соотношению сторон

API поддерживает 10 стандартных соотношений сторон:

Таблица соотношений сторон

Практический совет: Перед загрузкой проверьте соотношение сторон командой:

from PIL import Image

img = Image.open("your_image.jpg")
width, height = img.size
aspect_ratio = width / height

print(f"Размер: {width}x{height}")
print(f"Соотношение сторон: {aspect_ratio:.2f}")

# Проверка на близость к стандартным
standard_ratios = {
    "1:1": 1.0,
    "3:2": 1.5,
    "4:3": 1.33,
    "16:9": 1.78,
    "21:9": 2.33
}

for name, ratio in standard_ratios.items():
    if abs(aspect_ratio - ratio) < 0.05:  # допуск 5%
        print(f"✓ Подходит под {name}")
        break

Решения для изображений, превышающих лимит

Когда ваше изображение весит больше 7MB, есть 3 проверенных способа сжатия:

Способ 1: Python + Pillow (программное сжатие)

from PIL import Image
import os

def compress_image_for_nano_banana(input_path, output_path, max_size_mb=7):
    """
    Сжимает изображение до указанного размера в MB
    
    Args:
        input_path: путь к исходному файлу
        output_path: путь для сохранения
        max_size_mb: максимальный размер в мегабайтах
    """
    img = Image.open(input_path)
    
    # Конвертируем RGBA в RGB (если есть прозрачность)
    if img.mode == 'RGBA':
        background = Image.new('RGB', img.size, (255, 255, 255))
        background.paste(img, mask=img.split()[3])
        img = background
    
    # Пробуем разные уровни качества
    quality = 95
    max_size_bytes = max_size_mb * 1024 * 1024
    
    while quality > 20:
        img.save(output_path, 'JPEG', quality=quality, optimize=True)
        
        file_size = os.path.getsize(output_path)
        print(f"Качество {quality}: размер {file_size / 1024 / 1024:.2f} MB")
        
        if file_size <= max_size_bytes:
            print(f"✓ Успешно сжато до {file_size / 1024 / 1024:.2f} MB")
            return True
        
        quality -= 5
    
    # Если не получилось - уменьшаем разрешение
    print("⚠ Качество недостаточно, уменьшаем разрешение...")
    img.thumbnail((img.width // 2, img.height // 2), Image.Resampling.LANCZOS)
    img.save(output_path, 'JPEG', quality=85, optimize=True)
    
    final_size = os.path.getsize(output_path)
    print(f"✓ Итоговый размер: {final_size / 1024 / 1024:.2f} MB")
    return True

# Использование
compress_image_for_nano_banana(
    "large_photo.png",  # 15MB PNG
    "compressed.jpg",   # ~3MB JPEG
    max_size_mb=7
)

Преимущества:

• Полный контроль над процессом
• Можно автоматизировать для пакетной обработки
• Работает без интернета

Когда использовать: В production-приложениях, когда нужна автоматизация.

Способ 2: Онлайн-инструменты (быстрое решение)

Для разовых задач удобны онлайн-сервисы:

1. TinyPNG (https://tinypng.com/)

   • Умное сжатие PNG/JPEG
   • Сохраняет визуальное качество
   • До 5MB бесплатно

2. Squoosh (https://squoosh.app/)

   • От команды Google Chrome
   • Работает оффлайн (PWA)
   • Поддержка WebP, AVIF

3. Compressor.io (https://compressor.io/)

   • Сжатие до 90% без потери качества
   • Поддержка JPEG, PNG, GIF, SVG

Пример процесса:

1. Откройте TinyPNG
2. Перетащите ваш 12MB PNG файл
3. Получите сжатый файл ~3MB (потеря качества <5%)
4. Проверьте размер перед загрузкой в API

Способ 3: Командная строка (для продвинутых)

ImageMagick (универсальный)

# Установка (macOS)
brew install imagemagick

# Сжатие JPEG с качеством 85
convert input.jpg -quality 85 output.jpg

# Изменение размера до 2048px по длинной стороне
convert input.jpg -resize 2048x2048\> output.jpg

# Конвертация PNG → JPEG + сжатие
convert input.png -quality 80 output.jpg

# Проверка размера файла
ls -lh output.jpg

FFmpeg (для изображений из видео)

# Установка
brew install ffmpeg

# Извлечение кадра из видео + сжатие
ffmpeg -i video.mp4 -ss 00:00:05 -vframes 1 -q:v 5 frame.jpg
# -q:v 5 = качество (2-31, меньше = лучше)

cwebp (конвертация в WebP)

# Установка
brew install webp

# Конвертация в WebP с качеством 80
cwebp -q 80 input.jpg -o output.webp

# Потери качества (lossy) + изменение размера
cwebp -resize 1920 1080 input.jpg -o output.webp

Практический workflow: обработка изображений перед API

Вот готовый скрипт для обработки любых изображений:

import os
from PIL import Image
import base64

class NanoBananaImageProcessor:
    MAX_SIZE_MB = 7
    SUPPORTED_FORMATS = ['JPEG', 'PNG', 'WEBP']
    
    def __init__(self, image_path):
        self.image_path = image_path
        self.image = Image.open(image_path)
        self.original_size = os.path.getsize(image_path)
        
    def get_file_size_mb(self, path=None):
        """Получить размер файла в MB"""
        target = path or self.image_path
        return os.path.getsize(target) / 1024 / 1024
    
    def check_aspect_ratio(self):
        """Проверка соотношения сторон"""
        width, height = self.image.size
        ratio = width / height
        
        valid_ratios = {
            "1:1": (0.95, 1.05),
            "3:2": (1.45, 1.55),
            "2:3": (0.65, 0.70),
            "4:3": (1.30, 1.37),
            "3:4": (0.73, 0.77),
            "16:9": (1.75, 1.80),
            "9:16": (0.55, 0.58),
            "21:9": (2.30, 2.37),
            "9:21": (0.42, 0.44)
        }
        
        for name, (min_r, max_r) in valid_ratios.items():
            if min_r <= ratio <= max_r:
                return True, name
        
        return False, f"Нестандартное ({ratio:.2f})"
    
    def compress_and_prepare(self, output_path):
        """Основная функция подготовки"""
        print(f"📁 Исходный файл: {self.get_file_size_mb():.2f} MB")
        
        # Проверка соотношения сторон
        is_valid, ratio_name = self.check_aspect_ratio()
        if is_valid:
            print(f"✓ Соотношение сторон: {ratio_name}")
        else:
            print(f"⚠ Предупреждение: {ratio_name}")
        
        # Конвертация RGBA → RGB
        if self.image.mode in ('RGBA', 'LA', 'P'):
            print("🔄 Конвертация в RGB...")
            background = Image.new('RGB', self.image.size, (255, 255, 255))
            if self.image.mode == 'P':
                self.image = self.image.convert('RGBA')
            background.paste(self.image, mask=self.image.split()[-1] if 'A' in self.image.mode else None)
            self.image = background
        
        # Сжатие
        quality = 95
        while quality > 20:
            self.image.save(output_path, 'JPEG', quality=quality, optimize=True)
            size_mb = self.get_file_size_mb(output_path)
            
            if size_mb <= self.MAX_SIZE_MB:
                print(f"✓ Сжато: {size_mb:.2f} MB (качество {quality})")
                return output_path
            
            quality -= 10
        
        # Если не помогло - уменьшаем разрешение
        print("⚠ Уменьшение разрешения...")
        self.image.thumbnail(
            (self.image.width // 2, self.image.height // 2),
            Image.Resampling.LANCZOS
        )
        self.image.save(output_path, 'JPEG', quality=85, optimize=True)
        print(f"✓ Итоговый размер: {self.get_file_size_mb(output_path):.2f} MB")
        
        return output_path
    
    def to_base64(self, image_path):
        """Конвертация в Base64 для API"""
        with open(image_path, 'rb') as f:
            return base64.b64encode(f.read()).decode('utf-8')

# Использование
processor = NanoBananaImageProcessor("my_large_photo.png")
compressed_path = processor.compress_and_prepare("output.jpg")
base64_image = processor.to_base64(compressed_path)

print(f"\n📤 Готово к отправке в Nano Banana Pro API!")
print(f"Base64 длина: {len(base64_image)} символов")

Вывод скрипта:

📁 Исходный файл: 12.45 MB
✓ Соотношение сторон: 16:9
🔄 Конвертация в RGB...
✓ Сжато: 4.23 MB (качество 75)

📤 Готово к отправке в Nano Banana Pro API!
Base64 длина: 5627384 символов

Частые ошибки и их решение

Ошибка: "Image size exceeds 7MB limit"

Причина: Файл слишком большой даже после Base64-кодирования.

Решение:

# До отправки проверяйте размер
import os

file_size_mb = os.path.getsize("image.jpg") / 1024 / 1024
if file_size_mb > 7:
    print(f"❌ Файл {file_size_mb:.2f} MB превышает лимит")
    # Используйте compress_image_for_nano_banana()

Ошибка: "Unsupported aspect ratio"

Причина: Соотношение сторон не входит в список поддерживаемых.

Решение:

from PIL import Image

def crop_to_16_9(input_path, output_path):
    """Обрезка до 16:9"""
    img = Image.open(input_path)
    width, height = img.size
    
    target_ratio = 16 / 9
    current_ratio = width / height
    
    if current_ratio > target_ratio:
        # Слишком широко - обрезаем по ширине
        new_width = int(height * target_ratio)
        left = (width - new_width) // 2
        img = img.crop((left, 0, left + new_width, height))
    else:
        # Слишком высоко - обрезаем по высоте
        new_height = int(width / target_ratio)
        top = (height - new_height) // 2
        img = img.crop((0, top, width, top + new_height))
    
    img.save(output_path)
    print(f"✓ Обрезано до 16:9: {img.size}")

crop_to_16_9("weird_ratio.jpg", "fixed_16_9.jpg")

Ошибка: "Invalid MIME type"

Причина: Формат файла не поддерживается (например, BMP, TIFF).

Решение:

from PIL import Image

def convert_to_supported_format(input_path, output_path="converted.jpg"):
    """Конвертация в поддерживаемый формат"""
    img = Image.open(input_path)
    
    # Конвертация в RGB если необходимо
    if img.mode != 'RGB':
        img = img.convert('RGB')
    
    img.save(output_path, 'JPEG', quality=90)
    print(f"✓ Конвертировано в JPEG: {output_path}")
    return output_path

# BMP → JPEG
convert_to_supported_format("screenshot.bmp", "screenshot.jpg")

Полный пример отправки в API

Объединим всё вместе — готовый код для работы с Nano Banana Pro:

import base64
import requests
from PIL import Image
import os

class NanoBananaProClient:
    def __init__(self, api_key):
        self.api_key = api_key
        self.base_url = "https://api.example.com/v1"  # замените на реальный URL
        
    def prepare_image(self, image_path, max_size_mb=7):
        """Подготовка изображения для API"""
        # Проверка размера
        size_mb = os.path.getsize(image_path) / 1024 / 1024
        
        if size_mb > max_size_mb:
            print(f"⚠ Файл {size_mb:.2f} MB превышает лимит, сжимаем...")
            compressed_path = image_path.replace('.', '_compressed.')
            
            img = Image.open(image_path)
            if img.mode == 'RGBA':
                img = img.convert('RGB')
            
            quality = 90
            while quality > 30:
                img.save(compressed_path, 'JPEG', quality=quality, optimize=True)
                new_size = os.path.getsize(compressed_path) / 1024 / 1024
                
                if new_size <= max_size_mb:
                    print(f"✓ Сжато до {new_size:.2f} MB")
                    image_path = compressed_path
                    break
                quality -= 10
        
        # Конвертация в Base64
        with open(image_path, 'rb') as f:
            image_data = base64.b64encode(f.read()).decode('utf-8')
        
        # Определение MIME-типа
        ext = image_path.lower().split('.')[-1]
        mime_map = {
            'jpg': 'image/jpeg',
            'jpeg': 'image/jpeg',
            'png': 'image/png',
            'webp': 'image/webp',
            'heic': 'image/heic'
        }
        mime_type = mime_map.get(ext, 'image/jpeg')
        
        return {
            "mime_type": mime_type,
            "data": image_data
        }
    
    def generate_image_edit(self, image_path, prompt):
        """Отправка запроса на редактирование изображения"""
        image_data = self.prepare_image(image_path)
        
        payload = {
            "model": "gemini-3-pro-image-preview",
            "prompt": prompt,
            "image": {
                "mime_type": image_data["mime_type"],
                "data": image_data["data"]
            }
        }
        
        headers = {
            "Authorization": f"Bearer {self.api_key}",
            "Content-Type": "application/json"
        }
        
        response = requests.post(
            f"{self.base_url}/generate",
            json=payload,
            headers=headers
        )
        
        if response.status_code == 200:
            print("✓ Запрос успешно выполнен!")
            return response.json()
        else:
            print(f"❌ Ошибка: {response.status_code}")
            print(response.text)
            return None

# Использование
client = NanoBananaProClient(api_key="ваш_api_ключ")

result = client.generate_image_edit(
    image_path="my_photo.jpg",
    prompt="Сделать изображение в стиле акварели"
)

if result:
    print("Результат:", result)

Заключение: чек-лист перед отправкой

Перед каждым API-вызовом проверьте:

• Размер файла ≤ 7MB (для inline-данных) или ≤ 30MB (для Cloud Storage)
• Формат: PNG, JPEG, WebP,

Поддерживаемые форматы изображений в Nano Banana Pro API

Вот таблица с MIME-типами и форматами, которые поддерживает Nano Banana Pro:

Оптимизация совместимости формата JPEG на платформе APIYI

Стоит отметить, что платформа APIYI apiyi.com провела дополнительную оптимизацию совместимости для формата JPEG. Некоторые старые JPEG-файлы могут вызывать проблемы распознавания при прямом обращении к Google API, но при использовании APIYI в качестве прокси эти проблемы совместимости решаются автоматически.

🎯 Рекомендации по формату: для повседневного использования рекомендуем JPEG или WebP — они имеют малый размер и хорошую совместимость. PNG подходит для сценариев, где нужен прозрачный фон. При обращении к Nano Banana Pro через APIYI apiyi.com вы получите улучшенную поддержку совместимости форматов.

Поддерживаемые соотношения сторон в Nano Banana Pro API

Nano Banana Pro поддерживает широкий выбор соотношений сторон для различных сценариев использования:

Решение проблемы превышения лимита размера изображений в Nano Banana Pro API

Когда размер вашего изображения превышает 7 МБ, вот 3 рекомендуемых решения:

Вариант 1: Сжатие через Python (рекомендуется)

Используйте библиотеку Pillow для интеллектуального сжатия с автоматическим уменьшением размера до 7 МБ:

from PIL import Image
import io

def compress_image_for_nano_banana(image_path: str, max_size_mb: float = 7.0) -> bytes:
    """
    压缩图片到 Nano Banana Pro API 限制以下

    Args:
        image_path: 原图路径
        max_size_mb: 最大文件大小(MB)，默认7MB

    Returns:
        压缩后的图片字节数据
    """
    max_size_bytes = max_size_mb * 1024 * 1024

    with Image.open(image_path) as img:
        # 转换为 RGB（处理 RGBA 透明图）
        if img.mode in ('RGBA', 'P'):
            img = img.convert('RGB')

        # 先尝试直接保存
        buffer = io.BytesIO()
        img.save(buffer, format='JPEG', quality=95)

        if buffer.tell() <= max_size_bytes:
            return buffer.getvalue()

        # 逐步降低质量直到满足大小限制
        for quality in range(90, 10, -5):
            buffer = io.BytesIO()
            img.save(buffer, format='JPEG', quality=quality)
            if buffer.tell() <= max_size_bytes:
                print(f"压缩成功: quality={quality}, size={buffer.tell()/1024/1024:.2f}MB")
                return buffer.getvalue()

        # 如果质量压缩不够，同时缩小尺寸
        scale = 0.9
        while scale > 0.3:
            new_size = (int(img.width * scale), int(img.height * scale))
            resized = img.resize(new_size, Image.LANCZOS)
            buffer = io.BytesIO()
            resized.save(buffer, format='JPEG', quality=85)
            if buffer.tell() <= max_size_bytes:
                print(f"压缩成功: scale={scale:.1f}, size={buffer.tell()/1024/1024:.2f}MB")
                return buffer.getvalue()
            scale -= 0.1

        raise ValueError("无法将图片压缩到 7MB 以下")

# 使用示例
compressed_data = compress_image_for_nano_banana("large_image.png")

import requests
import base64
from PIL import Image
import io
from typing import Dict, Any

def compress_image_for_nano_banana(image_path: str, max_size_mb: float = 7.0) -> bytes:
    """压缩图片到指定大小"""
    max_size_bytes = max_size_mb * 1024 * 1024

    with Image.open(image_path) as img:
        if img.mode in ('RGBA', 'P'):
            img = img.convert('RGB')

        # 尝试不同质量级别
        for quality in range(95, 10, -5):
            buffer = io.BytesIO()
            img.save(buffer, format='JPEG', quality=quality)
            if buffer.tell() <= max_size_bytes:
                return buffer.getvalue()

        # 缩小尺寸
        scale = 0.8
        while scale > 0.3:
            new_size = (int(img.width * scale), int(img.height * scale))
            resized = img.resize(new_size, Image.LANCZOS)
            buffer = io.BytesIO()
            resized.save(buffer, format='JPEG', quality=80)
            if buffer.tell() <= max_size_bytes:
                return buffer.getvalue()
            scale -= 0.1

        raise ValueError("无法压缩到 7MB 以下")

def edit_image_with_nano_banana(
    image_path: str,
    prompt: str,
    api_key: str = "YOUR_API_KEY",
    base_url: str = "https://vip.apiyi.com/v1"
) -> Dict[str, Any]:
    """
    使用 Nano Banana Pro 编辑图片

    Args:
        image_path: 原图路径
        prompt: 编辑指令
        api_key: API 密钥
        base_url: API 基础地址

    Returns:
        API 响应结果
    """
    # 检查并压缩图片
    import os
    file_size = os.path.getsize(image_path)

    if file_size > 7 * 1024 * 1024:
        print(f"原图 {file_size/1024/1024:.2f}MB 超过 7MB 限制，开始压缩...")
        image_data = compress_image_for_nano_banana(image_path)
    else:
        with open(image_path, 'rb') as f:
            image_data = f.read()

    # Base64 编码
    image_base64 = base64.b64encode(image_data).decode('utf-8')

    # 调用 API
    response = requests.post(
        f"{base_url}/images/edits",
        json={
            "model": "gemini-3-pro-image-preview",
            "image": image_base64,
            "prompt": prompt
        },
        headers={
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json"
        },
        timeout=(30, 600)  # 连接超时30秒，读取超时600秒
    )

    return response.json()

# 使用示例
if __name__ == "__main__":
    result = edit_image_with_nano_banana(
        image_path="my_photo.jpg",
        prompt="将背景改为海边日落"
    )
    print(result)

Вариант 2: Онлайн-сервисы для сжатия

Если не хотите писать код, можете воспользоваться онлайн-инструментами:

• TinyPNG: tinypng.com — умное сжатие PNG/JPEG
• Squoosh: squoosh.app — открытый инструмент от Google для сжатия изображений
• iLoveIMG: iloveimg.com — поддерживает пакетное сжатие

Вариант 3: Консольные инструменты

Используйте ImageMagick для быстрого сжатия:

# 压缩到指定大小（约 7MB）
convert input.png -quality 85 -define jpeg:extent=7MB output.jpg

# 同时调整尺寸和质量
convert input.png -resize 4096x4096\> -quality 80 output.jpg

Совет: Попробуйте Nano Banana Pro через платформу APIYI (apiyi.com) — там есть бесплатный тестовый лимит, удобно проверить, нормально ли обрабатываются сжатые изображения.

Частые ошибки Nano Banana Pro API и их решение

Часто задаваемые вопросы

Резюме

Ключевые моменты ограничений для изображений в Nano Banana Pro (gemini-3-pro-image-preview) API:

1. Лимит на одно изображение — 7MB: жёсткое ограничение для встроенных данных или загрузки через консоль, Cloud Storage позволяет до 30MB
2. Поддержка 5 форматов: PNG, JPEG, WebP, HEIC, HEIF — GIF/BMP/TIFF не поддерживаются
3. 10 соотношений сторон: от 1:1 до 21:9, охватывающие все основные сценарии использования
4. Решения при превышении лимита: сжатие через Python, онлайн-инструменты или утилиты командной строки

Разобравшись с этими ограничениями, вы сможете эффективнее использовать Nano Banana Pro для редактирования и генерации изображений.

Рекомендуем протестировать Nano Banana Pro через APIYI apiyi.com — платформа предлагает бесплатную квоту и оптимизированную совместимость с форматом JPEG, стоимость обработки одного изображения всего $0.05.

📚 Справочные материалы

⚠️ О формате ссылок: Все внешние ссылки даны в формате Название: domain.com — удобно копировать, но нельзя кликнуть. Так мы сохраняем SEO-вес нашего сайта.

1. Документация Google Gemini API по работе с изображениями: официальные спецификации для входных изображений

   • Ссылка: ai.google.dev/gemini-api/docs/image-understanding
   • Описание: здесь найдёте всё про MIME-типы и ограничения по размеру

2. Требования к входным файлам Firebase AI Logic: подробная информация о спецификациях файлов

   • Ссылка: firebase.google.com/docs/ai-logic/input-file-requirements
   • Описание: полный список поддерживаемых форматов и их ограничений

3. Документация библиотеки Pillow: официальная документация по обработке изображений на Python

   • Ссылка: pillow.readthedocs.io
   • Описание: лучший ресурс для изучения сжатия и конвертации изображений

Автор: команда разработчиков
Обсудим технологии: пишите в комментариях, больше материалов ищите в техническом сообществе APIYI apiyi.com