Skip to content

Create/Transform API ​

Generate transformed versions of images on-the-fly using URL-based transformations.

Endpoint ​

http
GET /create/<dirname>/<object_id>/<transformations>.<format>

How It Works ​

  1. Access an image with transformation parameters in the URL
  2. If the transformed version exists, it's served from cache
  3. If not, it's generated on-the-fly, cached, and returned
  4. Subsequent requests serve the cached version instantly

URL Structure ​

https://api.reimage.dev/create/{dirname}/{object_id}/{transformations}.{format}

Examples ​

/create/abc123/xyz789/w-800.webp
/create/abc123/xyz789/h-400_w-600.png
/create/abc123/xyz789/h-200_w-200_bg-remove.webp

Authentication ​

Not required for image retrieval - images are publicly accessible via their URLs.

Best Practice

For production use, access transformed images through the CDN URLs instead:

https://files.reimage.dev/{dirname}/{object_id}/{transformations}.{format}

Transformation Parameters ​

Resize Transformations ​

ParameterDescriptionExample
w-{width}Resize to specific width (maintains aspect ratio)w-800
h-{height}Resize to specific height (maintains aspect ratio)h-600
h-{height}_w-{width}Resize to exact dimensions (may crop)h-400_w-600

Format Conversion ​

Specify the format as the file extension:

  • .webp - WebP (recommended for web)
  • .avif - AVIF (modern, smaller file size)
  • .png - PNG (lossless)
  • .jpg or .jpeg - JPEG

Background Removal ​

ParameterDescription
bg-removeRemove background from image

Sprite Sheets ​

ParameterDescription
sprite-sheetConvert animated GIF to sprite sheet

Code Examples ​

Generate Responsive Images ​

javascript
function getResponsiveUrls(objectUrl) {
  return {
    thumbnail: `${objectUrl}w-200.webp`,
    small: `${objectUrl}w-400.webp`,
    medium: `${objectUrl}w-800.webp`,
    large: `${objectUrl}w-1200.webp`,
    xlarge: `${objectUrl}w-1920.webp`
  };
}

// Usage after upload
const { object_url } = await uploadImage(file);
const urls = getResponsiveUrls(object_url);

console.log(urls.thumbnail); // ...w-200.webp
console.log(urls.large); // ...w-1200.webp
python
def get_responsive_urls(object_url):
    """Generate responsive image URLs"""
    return {
        'thumbnail': f'{object_url}w-200.webp',
        'small': f'{object_url}w-400.webp',
        'medium': f'{object_url}w-800.webp',
        'large': f'{object_url}w-1200.webp',
        'xlarge': f'{object_url}w-1920.webp'
    }

# Usage
urls = get_responsive_urls(object_url)
print(urls['thumbnail'])
php
<?php
function getResponsiveUrls($objectUrl) {
    return [
        'thumbnail' => $objectUrl . 'w-200.webp',
        'small' => $objectUrl . 'w-400.webp',
        'medium' => $objectUrl . 'w-800.webp',
        'large' => $objectUrl . 'w-1200.webp',
        'xlarge' => $objectUrl . 'w-1920.webp'
    ];
}

$urls = getResponsiveUrls($objectUrl);
echo $urls['thumbnail'];
?>
go
func getResponsiveURLs(objectURL string) map[string]string {
    return map[string]string{
        "thumbnail": objectURL + "w-200.webp",
        "small":     objectURL + "w-400.webp",
        "medium":    objectURL + "w-800.webp",
        "large":     objectURL + "w-1200.webp",
        "xlarge":    objectURL + "w-1920.webp",
    }
}
rust
use std::collections::HashMap;

fn get_responsive_urls(object_url: &str) -> HashMap<&'static str, String> {
    let mut urls = HashMap::new();
    urls.insert("thumbnail", format!("{}w-200.webp", object_url));
    urls.insert("small", format!("{}w-400.webp", object_url));
    urls.insert("medium", format!("{}w-800.webp", object_url));
    urls.insert("large", format!("{}w-1200.webp", object_url));
    urls.insert("xlarge", format!("{}w-1920.webp", object_url));
    urls
}

React Responsive Image Component ​

jsx
function ResponsiveImage({ objectUrl, alt }) {
  const srcSet = `
    ${objectUrl}w-400.webp 400w,
    ${objectUrl}w-800.webp 800w,
    ${objectUrl}w-1200.webp 1200w,
    ${objectUrl}w-1920.webp 1920w
  `;

  return (
    <img
      src={`${objectUrl}w-800.webp`}
      srcSet={srcSet}
      sizes="(max-width: 768px) 100vw, (max-width: 1200px) 50vw, 33vw"
      alt={alt}
      loading="lazy"
    />
  );
}

Background Removal ​

javascript
// Original image
const original = `${objectUrl}original.jpg`;

// With background removed
const noBg = `${objectUrl}bg-remove.png`;

// Resized with background removed
const noBgResized = `${objectUrl}w-800_bg-remove.png`;

Format Conversion ​

javascript
// Convert to different formats
const webp = `${objectUrl}original.webp`;  // WebP
const avif = `${objectUrl}original.avif`;  // AVIF
const png = `${objectUrl}original.png`;    // PNG
const jpg = `${objectUrl}original.jpg`;    // JPEG

Transformation Examples ​

Product Thumbnails ​

# Square thumbnails
https://files.reimage.dev/abc123/xyz789/h-200_w-200.webp

Hero Images ​

# Large, optimized for web
https://files.reimage.dev/abc123/xyz789/w-1920.webp

Profile Pictures ​

# Small, circular crop
https://files.reimage.dev/abc123/xyz789/h-150_w-150.webp

Transparent Product Images ​

# Background removed, resized
https://files.reimage.dev/abc123/xyz789/w-800_bg-remove.png

Storage Backends ​

Images can be served from different backends:

Google Cloud Storage (Default) ​

https://files.reimage.dev/{dirname}/{object_id}/{transformations}.{format}

Cloudflare R2 ​

Add ?backend=r2 query parameter when uploading to use R2 storage:

https://storage.reimage.dev/{dirname}/{object_id}/{transformations}.{format}

Video Handling ​

Videos (object IDs starting with vid-) are redirected to HLS streaming:

/create/{dirname}/vid-xyz789/anything
→ Redirects to: https://stream.mux.com/{playback_id}.m3u8

Cloudinary Migration ​

If migrating from Cloudinary, use the fromCloudinary parameter:

/create/{dirname}/{object_id}/original?fromCloudinary=https://cloudinary.com/...

This will fetch from Cloudinary and cache in Reimage storage.

Caching ​

  • Transformed images are cached indefinitely
  • First request generates the transformation
  • Subsequent requests serve from cache instantly
  • CDN caching for even faster delivery

Best Practices ​

  1. Use WebP format for best compression and quality
  2. Generate multiple sizes for responsive images
  3. Use CDN URLs in production (files.reimage.dev)
  4. Lazy load images to improve page performance
  5. Use appropriate sizes - don't request larger than needed

Next Steps ​

Released under the MIT License.