User API

Retrieve information about your account, including storage usage and subscription details.

Endpoint

http

GET /user/

Authentication

Required.

Response

json

{
  "name": "John Doe",
  "bucket_id": "abc123",
  "avatar": "https://example.com/avatar.jpg",
  "image_count": 150,
  "storage_used": 524288,
  "storage_limit": 10485760,
  "video_storage_used": 45.5,
  "video_storage_limit": 120,
  "transform_count": 3542,
  "subscription_tier": 1
}

Response Fields

Field	Type	Description
`name`	String	Account holder's name
`bucket_id`	String	Your unique bucket/directory identifier
`avatar`	String	URL to profile avatar
`image_count`	Integer	Total number of images uploaded
`storage_used`	Number	Storage used in kilobytes
`storage_limit`	Number	Storage limit in kilobytes based on tier
`video_storage_used`	Number	Video storage used in minutes
`video_storage_limit`	Number	Video storage limit in minutes
`transform_count`	Integer	Total number of transformations generated
`subscription_tier`	Integer	Subscription level (0=Free, 1=Pro, 2=Enterprise)

Code Examples

javascript

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

  if (!response.ok) {
    throw new Error(`Failed to get user info: ${response.status}`);
  }

  return await response.json();
}

// Usage
const user = await getUserInfo();
console.log(`Name: ${user.name}`);
console.log(`Storage: ${user.storage_used} / ${user.storage_limit} KB`);
console.log(`Images: ${user.image_count}`);

// Calculate storage percentage
const storagePercent = (user.storage_used / user.storage_limit * 100).toFixed(2);
console.log(`Storage usage: ${storagePercent}%`);

python

import requests
import os

def get_user_info():
    """Retrieve user account information"""
    headers = {
        'Authorization': f'Bearer {os.environ.get("REIMAGE_API_KEY")}'
    }

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

    return response.json()

# Usage
user = get_user_info()
print(f"Name: {user['name']}")
print(f"Storage: {user['storage_used']} / {user['storage_limit']} KB")
print(f"Images: {user['image_count']}")

# Calculate storage percentage
storage_percent = (user['storage_used'] / user['storage_limit']) * 100
print(f"Storage usage: {storage_percent:.2f}%")

php

<?php
function getUserInfo() {
    $apiKey = getenv('REIMAGE_API_KEY');
    $url = 'https://api.reimage.dev/user/';

    $ch = curl_init($url);
    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 !== 200) {
        throw new Exception("Failed to get user info: $httpCode");
    }

    return json_decode($response, true);
}

// Usage
$user = getUserInfo();
echo "Name: " . $user['name'] . "\n";
echo "Storage: " . $user['storage_used'] . " / " . $user['storage_limit'] . " KB\n";
echo "Images: " . $user['image_count'] . "\n";

// Calculate storage percentage
$storagePercent = ($user['storage_used'] / $user['storage_limit']) * 100;
echo "Storage usage: " . number_format($storagePercent, 2) . "%\n";
?>

package main

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

type UserInfo struct {
    Name               string  `json:"name"`
    BucketID           string  `json:"bucket_id"`
    Avatar             string  `json:"avatar"`
    ImageCount         int     `json:"image_count"`
    StorageUsed        float64 `json:"storage_used"`
    StorageLimit       float64 `json:"storage_limit"`
    VideoStorageUsed   float64 `json:"video_storage_used"`
    VideoStorageLimit  float64 `json:"video_storage_limit"`
    TransformCount     int     `json:"transform_count"`
    SubscriptionTier   int     `json:"subscription_tier"`
}

func getUserInfo(apiKey string) (*UserInfo, error) {
    req, err := http.NewRequest("GET", "https://api.reimage.dev/user/", 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()

    if resp.StatusCode != 200 {
        return nil, fmt.Errorf("failed with status: %d", resp.StatusCode)
    }

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

    return &user, nil
}

func main() {
    apiKey := os.Getenv("REIMAGE_API_KEY")
    user, err := getUserInfo(apiKey)

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

    fmt.Printf("Name: %s\n", user.Name)
    fmt.Printf("Storage: %.2f / %.2f KB\n", user.StorageUsed, user.StorageLimit)
    fmt.Printf("Images: %d\n", user.ImageCount)

    storagePercent := (user.StorageUsed / user.StorageLimit) * 100
    fmt.Printf("Storage usage: %.2f%%\n", storagePercent)
}

rust

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

#[derive(Debug, Deserialize)]
struct UserInfo {
    name: String,
    bucket_id: String,
    avatar: String,
    image_count: u32,
    storage_used: f64,
    storage_limit: f64,
    video_storage_used: f64,
    video_storage_limit: f64,
    transform_count: u32,
    subscription_tier: u8,
}

async fn get_user_info(api_key: &str) -> Result<UserInfo, Box<dyn std::error::Error>> {
    let mut headers = HeaderMap::new();
    headers.insert(
        AUTHORIZATION,
        HeaderValue::from_str(&format!("Bearer {}", api_key))?,
    );

    let client = reqwest::Client::new();
    let response = client
        .get("https://api.reimage.dev/user/")
        .headers(headers)
        .send()
        .await?;

    if !response.status().is_success() {
        return Err(format!("Failed: {}", response.status()).into());
    }

    let user = response.json::<UserInfo>().await?;
    Ok(user)
}

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

    println!("Name: {}", user.name);
    println!("Storage: {:.2} / {:.2} KB", user.storage_used, user.storage_limit);
    println!("Images: {}", user.image_count);

    let storage_percent = (user.storage_used / user.storage_limit) * 100.0;
    println!("Storage usage: {:.2}%", storage_percent);

    Ok(())
}

React Dashboard Example

jsx

import { useState, useEffect } from 'react';

function UserDashboard() {
  const [user, setUser] = useState(null);
  const [loading, setLoading] = useState(true);

  useEffect(() => {
    fetch('https://api.reimage.dev/user/', {
      headers: {
        'Authorization': `Bearer ${process.env.REACT_APP_REIMAGE_API_KEY}`
      }
    })
      .then(res => res.json())
      .then(data => {
        setUser(data);
        setLoading(false);
      });
  }, []);

  if (loading) return <div>Loading...</div>;

  const storagePercent = (user.storage_used / user.storage_limit * 100).toFixed(1);
  const videoPercent = (user.video_storage_used / user.video_storage_limit * 100).toFixed(1);

  return (
    <div>
      <h1>Welcome, {user.name}!</h1>

      <div className="stats">
        <div className="stat">
          <h3>Images</h3>
          <p>{user.image_count.toLocaleString()}</p>
        </div>

        <div className="stat">
          <h3>Transformations</h3>
          <p>{user.transform_count.toLocaleString()}</p>
        </div>

        <div className="stat">
          <h3>Image Storage</h3>
          <progress value={storagePercent} max="100" />
          <p>{storagePercent}% used</p>
          <small>
            {(user.storage_used / 1024).toFixed(2)} MB /
            {(user.storage_limit / 1024).toFixed(2)} MB
          </small>
        </div>

        <div className="stat">
          <h3>Video Storage</h3>
          <progress value={videoPercent} max="100" />
          <p>{videoPercent}% used</p>
          <small>
            {user.video_storage_used} min / {user.video_storage_limit} min
          </small>
        </div>
      </div>

      <p>Bucket ID: <code>{user.bucket_id}</code></p>
      <p>Subscription: {['Free', 'Pro', 'Enterprise'][user.subscription_tier]}</p>
    </div>
  );
}

Subscription Tiers

Tier	Value	Storage Limit	Video Limit
Free	0	100 MB	0 minutes
Pro	1	10 GB	120 minutes
Enterprise	2	Custom	Custom

Use Cases

Check Storage Before Upload

javascript

const user = await getUserInfo();
const fileSizeKB = file.size / 1024;

if (user.storage_used + fileSizeKB > user.storage_limit) {
  alert('Storage limit exceeded! Please upgrade your plan.');
  return;
}

// Proceed with upload
await uploadImage(file);

Display Storage Warning

javascript

const user = await getUserInfo();
const storagePercent = (user.storage_used / user.storage_limit) * 100;

if (storagePercent > 90) {
  showWarning('You are running low on storage!');
}

Next Steps

Upload API - Upload images
Get Images API - Retrieve images
Quick Start - Get started guide

User API ​

Endpoint ​

Authentication ​

Response ​

Response Fields ​

Code Examples ​

React Dashboard Example ​

Subscription Tiers ​

Use Cases ​

Check Storage Before Upload ​

Display Storage Warning ​

Next Steps ​

User API

Endpoint

Authentication

Response

Response Fields

Code Examples

React Dashboard Example

Subscription Tiers

Use Cases

Check Storage Before Upload

Display Storage Warning

Next Steps