Delete API

Delete an image and all its associated transformed versions from storage.

Endpoint

DELETE /delete/<object_id>

Authentication

Required.

Response

Success

{
  "message": "Image deleted successfully"
}

Status Code: 200 OK

Error Responses

Image Not Found

{
  "error": "Image not found"
}

Status Code: 404 Not Found

Server Error

{
  "error": "Internal server error"
}

Status Code: 500 Internal Server Error

Code Examples

JavaScript

async function deleteImage(objectId) {
  const response = await fetch(
    `https://api.reimage.dev/delete/${objectId}`,
    {
      method: 'DELETE',
      headers: {
        'Authorization': `Bearer ${process.env.REIMAGE_API_KEY}`
      }
    }
  );

  if (!response.ok) {
    const error = await response.json();
    throw new Error(error.error || 'Delete failed');
  }

  return await response.json();
}

// Usage
const result = await deleteImage('xyz789');
console.log(result.message); // "Image deleted successfully"

Python

import requests
import os

def delete_image(object_id):
    """Delete an image by object ID"""
    url = f'https://api.reimage.dev/delete/{object_id}'
    headers = {
        'Authorization': f'Bearer {os.environ.get("REIMAGE_API_KEY")}'
    }

    response = requests.delete(url, headers=headers)

    if response.status_code == 404:
        raise Exception('Image not found')
    elif response.status_code != 200:
        raise Exception(f'Delete failed: {response.status_code}')

    return response.json()

# Usage
result = delete_image('xyz789')
print(result['message'])

PHP

<?php
function deleteImage($objectId) {
    $apiKey = getenv('REIMAGE_API_KEY');
    $url = "https://api.reimage.dev/delete/$objectId";

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

    $response = curl_exec($ch);
    $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);

    if ($httpCode === 404) {
        throw new Exception('Image not found');
    } elseif ($httpCode !== 200) {
        throw new Exception("Delete failed with status: $httpCode");
    }

    return json_decode($response, true);
}

// Usage
$result = deleteImage('xyz789');
echo $result['message'];
?>

Go

package main

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

type DeleteResponse struct {
    Message string `json:"message,omitempty"`
    Error   string `json:"error,omitempty"`
}

func deleteImage(apiKey, objectID string) (*DeleteResponse, error) {
    url := fmt.Sprintf("https://api.reimage.dev/delete/%s", objectID)

    req, err := http.NewRequest("DELETE", 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 DeleteResponse
    body, _ := io.ReadAll(resp.Body)
    json.Unmarshal(body, &result)

    if resp.StatusCode == 404 {
        return nil, fmt.Errorf("image not found")
    } else if resp.StatusCode != 200 {
        return nil, fmt.Errorf("delete failed: %s", result.Error)
    }

    return &result, nil
}

func main() {
    apiKey := os.Getenv("REIMAGE_API_KEY")
    result, err := deleteImage(apiKey, "xyz789")

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

    fmt.Println(result.Message)
}

Rust

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

#[derive(Debug, Deserialize)]
struct DeleteResponse {
    message: Option<String>,
    error: Option<String>,
}

async fn delete_image(
    api_key: &str,
    object_id: &str,
) -> Result<String, Box<dyn std::error::Error>> {
    let url = format!("https://api.reimage.dev/delete/{}", object_id);

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

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

    let status = response.status();
    let result = response.json::<DeleteResponse>().await?;

    if status == 404 {
        return Err("Image not found".into());
    } else if !status.is_success() {
        return Err(result.error.unwrap_or("Delete failed".to_string()).into());
    }

    Ok(result.message.unwrap_or("Deleted successfully".to_string()))
}

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

    println!("{}", message);
    Ok(())
}

What Gets Deleted

When you delete an image, the following are removed:

1. Original file from cloud storage
2. All transformed versions (cached thumbnails, resized versions, etc.)
3. Database record with metadata
4. AI-generated captions (if any)
5. Storage quota is freed up

Confirmation Example (React)

function DeleteImageButton({ objectId, onDeleted }) {
  const [deleting, setDeleting] = useState(false);

  const handleDelete = async () => {
    if (!confirm('Are you sure you want to delete this image?')) {
      return;
    }

    setDeleting(true);

    try {
      const response = await fetch(
        `https://api.reimage.dev/delete/${objectId}`,
        {
          method: 'DELETE',
          headers: {
            'Authorization': `Bearer ${process.env.REACT_APP_REIMAGE_API_KEY}`
          }
        }
      );

      if (!response.ok) {
        throw new Error('Delete failed');
      }

      onDeleted(objectId);
    } catch (error) {
      alert('Failed to delete image');
    } finally {
      setDeleting(false);
    }
  };

  return (
    <button onClick={handleDelete} disabled={deleting}>
      {deleting ? 'Deleting...' : 'Delete'}
    </button>
  );
}

Bulk Delete Example

async function deleteMultipleImages(objectIds) {
  const results = await Promise.allSettled(
    objectIds.map(id => deleteImage(id))
  );

  const successful = results.filter(r => r.status === 'fulfilled').length;
  const failed = results.filter(r => r.status === 'rejected').length;

  console.log(`Deleted: ${successful}, Failed: ${failed}`);

  return results;
}

// Usage
await deleteMultipleImages(['xyz789', 'abc456', 'def123']);

Important Notes

• Deletion is permanent and cannot be undone
• Only the image owner can delete it
• CDN cached versions may take up to 24 hours to clear
• Storage quota is updated immediately

Next Steps

• Upload API - Upload new images
• Get Images API - Retrieve images
• Update API - Modify image metadata