Open an image from a URL, bytes or a base64 string

import io
from PIL import Image

data = open("photo.jpg", "rb").read()      # bytes from anywhere: a database, a socket, an API...
img = Image.open(io.BytesIO(data))
print(type(data).__name__, len(data), "->", img.format, img.size)

bytes 239040 -> JPEG (1600, 1067)

import io
import requests
from PIL import Image

url = "https://images-assets.nasa.gov/image/Artemis%20II%20at%20the%20pad%20sunset%2001282026_1/Artemis%20II%20at%20the%20pad%20sunset%2001282026_1~small.jpg"
resp = requests.get(url, timeout=30)
resp.raise_for_status()                              # fail loudly on 403/404 instead of later
img = Image.open(io.BytesIO(resp.content))
print(img.format, img.size)

import io
from urllib.request import Request, urlopen
from PIL import Image

req = Request("https://example.com/image.jpg", headers={"User-Agent": "my-app/1.0"})
with urlopen(req, timeout=30) as resp:              # standard library only, no requests needed
    img = Image.open(io.BytesIO(resp.read()))

import base64
import io
from PIL import Image

# A base64 string as you might receive it in JSON from an API or a browser
b64 = base64.b64encode(open("logo.png", "rb").read()).decode("ascii")
print("payload starts:", b64[:24], "...", len(b64), "characters")

img = Image.open(io.BytesIO(base64.b64decode(b64)))
print(img.format, img.mode, img.size)

payload starts: iVBORw0KGgoAAAANSUhEUgAA ... 5256 characters
PNG RGBA (600, 360)

import base64
import io
import re
from PIL import Image

data_uri = "data:image/png;base64," + base64.b64encode(open("logo.png", "rb").read()).decode()


def open_data_uri(uri):
    match = re.match(r"data:image/[\w.+-]+;base64,(.*)", uri, re.DOTALL)
    if not match:
        raise ValueError("not a base64 image data URI")
    return Image.open(io.BytesIO(base64.b64decode(match.group(1))))


print(open_data_uri(data_uri).size)

(600, 360)

import base64
import binascii

b64 = base64.b64encode(open("logo.png", "rb").read()).decode()
broken = b64.rstrip("=")[:-1]          # e.g. truncated by a form field or a log line
try:
    base64.b64decode(broken, validate=True)
except binascii.Error as e:
    print("binascii.Error:", e)

binascii.Error: Invalid base64-encoded string: number of data characters (5253) cannot be 1 more than a multiple of 4

import io
from PIL import Image

class SlowStream(io.RawIOBase):
    """Stands in for a network stream that cannot seek (like a raw HTTP response)."""
    def __init__(self, data):
        self._buf = io.BytesIO(data)
    def readable(self):
        return True
    def readinto(self, b):
        chunk = self._buf.read(len(b))
        b[:len(chunk)] = chunk
        return len(chunk)

stream = SlowStream(open("photo.jpg", "rb").read())
print("seekable:", stream.seekable())
img = Image.open(stream)            # Pillow reads it into memory when it cannot seek
print(img.format, img.size)

seekable: False
JPEG (1600, 1067)

import io
from PIL import Image

MAX_BYTES = 10 * 1024 * 1024        # refuse files over 10 MB
MAX_PIXELS = 40_000_000             # and images over 40 megapixels


def safe_open(data):
    if len(data) > MAX_BYTES:
        raise ValueError("file too large")
    img = Image.open(io.BytesIO(data))
    if img.width * img.height > MAX_PIXELS:   # checked from the header, before decoding
        raise ValueError(f"image too large: {img.size}")
    img.load()
    return img


print(safe_open(open("photo.jpg", "rb").read()).size)

(1600, 1067)