Get Images API

Retrieve a list of your uploaded images with pagination and filtering options.

Endpoint

http

GET /get/

Authentication

Required. Include your API key in the Authorization header.

Query Parameters

Parameter	Type	Default	Description
`page`	Integer	1	Page number for pagination
`page_size`	Integer	10	Number of items per page
`tags`	Array	-	Filter by specific tags (can be used multiple times)

Response

json

{
  "page": 1,
  "page_size": 10,
  "objects": [
    "https://files.reimage.dev/abc123/xyz789/",
    "https://files.reimage.dev/abc123/abc456/"
  ],
  "urls": [
    "https://files.reimage.dev/abc123/xyz789/original.webp",
    "https://files.reimage.dev/abc123/abc456/original.webp"
  ],
  "thumbnails": [
    "https://files.reimage.dev/abc123/xyz789/h-200_w-200.webp",
    "https://files.reimage.dev/abc123/abc456/h-200_w-200.webp"
  ]
}

Code Examples

javascript

async function getImages(page = 1, pageSize = 10) {
  const response = await fetch(
    `https://api.reimage.dev/get/?page=${page}&page_size=${pageSize}`,
    {
      headers: {
        'Authorization': `Bearer ${process.env.REIMAGE_API_KEY}`
      }
    }
  );

  return await response.json();
}

// Usage
const images = await getImages(1, 20);
console.log(`Retrieved ${images.urls.length} images`);

// Display thumbnails
images.thumbnails.forEach(url => {
  console.log(url);
});

python

import requests
import os

def get_images(page=1, page_size=10):
    """Retrieve paginated list of images"""
    headers = {
        'Authorization': f'Bearer {os.environ.get("REIMAGE_API_KEY")}'
    }
    params = {
        'page': page,
        'page_size': page_size
    }

    response = requests.get(
        'https://api.reimage.dev/get/',
        headers=headers,
        params=params
    )
    response.raise_for_status()

    return response.json()

# Usage
result = get_images(page=1, page_size=20)
print(f"Page {result['page']}: {len(result['urls'])} images")

for url in result['thumbnails']:
    print(url)

php

<?php
function getImages($page = 1, $pageSize = 10) {
    $apiKey = getenv('REIMAGE_API_KEY');
    $url = "https://api.reimage.dev/get/?page=$page&page_size=$pageSize";

    $ch = curl_init($url);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_HTTPHEADER, [
        'Authorization: Bearer ' . $apiKey
    ]);

    $response = curl_exec($ch);
    curl_close($ch);

    return json_decode($response, true);
}

// Usage
$result = getImages(1, 20);
echo "Retrieved " . count($result['urls']) . " images\n";

foreach ($result['thumbnails'] as $thumbnail) {
    echo $thumbnail . "\n";
}
?>

package main

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "os"
)

type ImagesResponse struct {
    Page       int      `json:"page"`
    PageSize   int      `json:"page_size"`
    Objects    []string `json:"objects"`
    URLs       []string `json:"urls"`
    Thumbnails []string `json:"thumbnails"`
}

func getImages(apiKey string, page, pageSize int) (*ImagesResponse, error) {
    url := fmt.Sprintf("https://api.reimage.dev/get/?page=%d&page_size=%d", page, pageSize)

    req, err := http.NewRequest("GET", url, nil)
    if err != nil {
        return nil, err
    }

    req.Header.Set("Authorization", "Bearer "+apiKey)

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()

    var result ImagesResponse
    if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
        return nil, err
    }

    return &result, nil
}

func main() {
    apiKey := os.Getenv("REIMAGE_API_KEY")
    result, err := getImages(apiKey, 1, 20)

    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }

    fmt.Printf("Page %d: %d images\n", result.Page, len(result.URLs))
    for _, url := range result.Thumbnails {
        fmt.Println(url)
    }
}

rust

use reqwest::header::{HeaderMap, HeaderValue, AUTHORIZATION};
use serde::{Deserialize, Serialize};

#[derive(Debug, Deserialize)]
struct ImagesResponse {
    page: u32,
    page_size: u32,
    objects: Vec<String>,
    urls: Vec<String>,
    thumbnails: Vec<String>,
}

async fn get_images(
    api_key: &str,
    page: u32,
    page_size: u32,
) -> Result<ImagesResponse, Box<dyn std::error::Error>> {
    let url = format!(
        "https://api.reimage.dev/get/?page={}&page_size={}",
        page, page_size
    );

    let mut headers = HeaderMap::new();
    headers.insert(
        AUTHORIZATION,
        HeaderValue::from_str(&format!("Bearer {}", api_key))?,
    );

    let client = reqwest::Client::new();
    let response = client
        .get(&url)
        .headers(headers)
        .send()
        .await?;

    let result = response.json::<ImagesResponse>().await?;
    Ok(result)
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("REIMAGE_API_KEY")?;
    let result = get_images(&api_key, 1, 20).await?;

    println!("Page {}: {} images", result.page, result.urls.len());
    for url in result.thumbnails {
        println!("{}", url);
    }

    Ok(())
}

Filter by Tags

Filter images that have specific tags:

http

GET /get/tags?tags=product&tags=featured

JavaScriptPythonPHP

javascript

async function getImagesByTags(tags) {
  const params = new URLSearchParams();
  tags.forEach(tag => params.append('tags', tag));

  const response = await fetch(
    `https://api.reimage.dev/get/?${params}`,
    {
      headers: {
        'Authorization': `Bearer ${process.env.REIMAGE_API_KEY}`
      }
    }
  );

  return await response.json();
}

// Get images with both "product" AND "hero" tags
const images = await getImagesByTags(['product', 'hero']);

python

def get_images_by_tags(tags):
    """Retrieve images filtered by tags"""
    headers = {
        'Authorization': f'Bearer {os.environ.get("REIMAGE_API_KEY")}'
    }
    params = [('tags', tag) for tag in tags]

    response = requests.get(
        'https://api.reimage.dev/get/',
        headers=headers,
        params=params
    )
    return response.json()

# Get images with both "product" AND "hero" tags
result = get_images_by_tags(['product', 'hero'])

php

<?php
function getImagesByTags($tags) {
    $apiKey = getenv('REIMAGE_API_KEY');
    $queryParams = http_build_query(['tags' => $tags]);
    $url = "https://api.reimage.dev/get/?$queryParams";

    $ch = curl_init($url);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_HTTPHEADER, [
        'Authorization: Bearer ' . $apiKey
    ]);

    $response = curl_exec($ch);
    return json_decode($response, true);
}

$result = getImagesByTags(['product', 'hero']);
?>

Complete Pagination Example

javascript

async function getAllImages() {
  const allImages = [];
  let page = 1;
  const pageSize = 100;

  while (true) {
    const response = await fetch(
      `https://api.reimage.dev/get/?page=${page}&page_size=${pageSize}`,
      {
        headers: {
          'Authorization': `Bearer ${process.env.REIMAGE_API_KEY}`
        }
      }
    );

    const data = await response.json();
    allImages.push(...data.urls);

    // If we got fewer results than page_size, we're on the last page
    if (data.urls.length < pageSize) {
      break;
    }

    page++;
  }

  return allImages;
}

Response Field Descriptions

Field	Description
`page`	Current page number
`page_size`	Number of items per page
`objects`	Array of base URLs for each image
`urls`	Array of optimized WebP URLs
`thumbnails`	Array of 200x200 thumbnail URLs

Next Steps

Upload API - Upload new images
Update API - Modify image tags
Delete API - Remove images
Search API - AI-powered semantic search

Get Images API ​

Endpoint ​

Authentication ​

Query Parameters ​

Response ​

Code Examples ​

Filter by Tags ​

Complete Pagination Example ​

Response Field Descriptions ​

Next Steps ​

Get Images API

Endpoint

Authentication

Query Parameters

Response

Code Examples

Filter by Tags

Complete Pagination Example

Response Field Descriptions

Next Steps