Easy Image Optimizer

Under maintenance

Pricing

$15.00 / 1,000 results

Try for free

Go to Apify Store

Easy Image Optimizer

Under maintenance

Try for free

Convert and optimize images from ANY website instantly. Perfect for developers, creators, and anyone who needs fast, reliable image optimization without the hassle!

Pricing

$15.00 / 1,000 results

Rating

5.0

(1)

Developer

abdelouahed

Maintained by Community

Actor stats

Bookmarked

Total users

Monthly active users

11 days ago

Last modified

.env.apify.example

# Apify Actor Environment Variables
# Copy these to your Apify actor configuration

# Required: Base URL of your VPS optimizer API
VPS_BASE_URL=http://h8swosc0oo0c8wwokkkkk00g.144.24.194.211.sslip.io:3000/api/v1

# Required: API key for authenticating with your VPS
VPS_API_KEY=WYwfEDS1IiZ3iGXwradItR43EpC5TCih

# Optional: Download endpoint path (default: /download)
VPS_DOWNLOAD_ENDPOINT=/download

# Optional: Status endpoint path (default: /status)
VPS_STATUS_ENDPOINT=/status

# Optional: Request timeout in milliseconds (default: 300000)
REQUEST_TIMEOUT=300000

.gitignore

storage
node_modules
.venv

actor.js

1const { Actor } = require('apify');
2const express = require('express');
3const fetch = require('node-fetch');
4const { Dataset } = require('apify');
5
6Actor.main(async () => {
7    const input = await Actor.getInput();
8
9    // VPS Configuration - Hardcoded for this actor
10    const VPS_BASE_URL = 'http://h8swosc0oo0c8wwokkkkk00g.144.24.194.211.sslip.io:3000/api/v1';
11    const VPS_DOWNLOAD_ENDPOINT = '/download';
12    const VPS_STATUS_ENDPOINT = '/status';
13    const VPS_API_KEY = 'WYwfEDS1IiZ3iGXwradItR43EpC5TCih';
14    const REQUEST_TIMEOUT = 300000;
15
16    const app = express();
17    app.use(express.json());
18
19    // Health check endpoint
20    app.get('/health', (req, res) => {
21        res.json({ status: 'ok', timestamp: new Date().toISOString() });
22    });
23
24    // Proxy endpoint for submitting download jobs
25    app.post('/run', async (req, res) => {
26        try {
27            const { imageUrl, width, height, quality = 80, format = 'webp' } = req.body;
28
29            if (!imageUrl) {
30                return res.status(400).json({
31                    success: false,
32                    error: 'imageUrl is required'
33                });
34            }
35
36            const vpsUrl = `${VPS_BASE_URL}${VPS_DOWNLOAD_ENDPOINT}`;
37            const requestBody = {
38                url: imageUrl,
39                width,
40                height,
41                quality,
42                format
43            };
44
45            console.log(`🚀 Optimizing image: ${imageUrl.substring(0, 50)}...`);
46
47            const response = await fetch(vpsUrl, {
48                method: 'POST',
49                headers: {
50                    'Content-Type': 'application/json',
51                    'Authorization': `Bearer ${VPS_API_KEY}`,
52                    'User-Agent': 'Apify-Proxy/1.0'
53                },
54                body: JSON.stringify(requestBody),
55                timeout: REQUEST_TIMEOUT
56            });
57
58            const responseData = await response.json();
59
60            
61            // Forward the exact response from VPS
62            res.status(response.status).json(responseData);
63
64        } catch (error) {
65                        res.status(500).json({
66                success: false,
67                error: 'Failed to connect to VPS API',
68                details: error.message
69            });
70        }
71    });
72
73    // Proxy endpoint for checking job status
74    app.get('/status/:jobId', async (req, res) => {
75        try {
76            const { jobId } = req.params;
77
78            if (!jobId) {
79                return res.status(400).json({
80                    success: false,
81                    error: 'jobId is required'
82                });
83            }
84
85            const vpsUrl = `${VPS_BASE_URL}${VPS_STATUS_ENDPOINT}/${jobId}`;
86
87          
88            const response = await fetch(vpsUrl, {
89                method: 'GET',
90                headers: {
91                    'Authorization': `Bearer ${VPS_API_KEY}`,
92                    'User-Agent': 'Apify-Proxy/1.0'
93                },
94                timeout: REQUEST_TIMEOUT
95            });
96
97            const responseData = await response.json();
98
99            
100            // Forward the exact response from VPS
101            res.status(response.status).json(responseData);
102
103        } catch (error) {
104                        res.status(500).json({
105                success: false,
106                error: 'Failed to connect to VPS API',
107                details: error.message
108            });
109        }
110    });
111
112    // Main actor execution based on input
113    if (input) {
114        const { action, imageUrl, jobId, width, height, quality, format } = input;
115
116        if (action === 'submit') {
117            if (!imageUrl) {
118                throw new Error('imageUrl is required for submit action');
119            }
120
121            const vpsUrl = `${VPS_BASE_URL}${VPS_DOWNLOAD_ENDPOINT}`;
122            const requestBody = {
123                url: imageUrl,
124                width,
125                height,
126                quality,
127                format
128            };
129
130            console.log(`📤 Submitting image for async optimization...`);
131
132            const response = await fetch(vpsUrl, {
133                method: 'POST',
134                headers: {
135                    'Content-Type': 'application/json',
136                    'Authorization': `Bearer ${VPS_API_KEY}`,
137                    'User-Agent': 'Apify-Proxy/1.0'
138                },
139                body: JSON.stringify(requestBody),
140                timeout: REQUEST_TIMEOUT
141            });
142
143            const result = await response.json();
144
145            if (!response.ok) {
146                throw new Error(`VPS API error: ${result.error || 'Unknown error'}`);
147            }
148
149            await Actor.setValue('OUTPUT', result);
150
151            console.log(`✅ Job submitted! Check status with job ID: ${result.data?.id || 'unknown'}`);
152
153        } else if (action === 'optimize') {
154            if (!imageUrl) {
155                throw new Error('imageUrl is required for optimize action');
156            }
157
158            const vpsUrl = `${VPS_BASE_URL}/optimize`;
159            const requestBody = {
160                url: imageUrl,
161                optimization: {
162                    maxWidth: width || 1200,
163                    maxHeight: height || 1200,
164                    quality: quality || 80,
165                    format: format || 'webp'
166                }
167            };
168
169  
170            const response = await fetch(vpsUrl, {
171                method: 'POST',
172                headers: {
173                    'Content-Type': 'application/json',
174                    'Authorization': `Bearer ${VPS_API_KEY}`,
175                    'User-Agent': 'Apify-Proxy/1.0'
176                },
177                body: JSON.stringify(requestBody),
178                timeout: REQUEST_TIMEOUT
179            });
180
181            const result = await response.json();
182
183    
184            if (!response.ok) {
185                throw new Error(`VPS API error: ${result.message || result.error || 'Unknown error'}`);
186            }
187
188            // Create user-friendly simplified output for optimize
189            const jobData = result.data?.result;
190            const isCompleted = result.data?.status === 'completed' && jobData?.success;
191
192            let userFriendlyResult;
193
194            if (isCompleted) {
195                // Success: Show only what users care about
196                const compressionSaved = jobData.originalSize && jobData.optimizedSize
197                    ? Math.round(((jobData.originalSize - jobData.optimizedSize) / jobData.originalSize) * 100)
198                    : 0;
199
200                userFriendlyResult = {
201                    success: true,
202                    optimizedUrl: jobData.uploadResult?.url || '',
203                    originalSize: jobData.originalSize,
204                    optimizedSize: jobData.optimizedSize,
205                    compressionSaved: `${compressionSaved}%`,
206                    dimensions: {
207                        width: jobData.metadata?.width || 0,
208                        height: jobData.metadata?.height || 0
209                    },
210                    format: jobData.contentType?.replace('image/', '') || 'webp'
211                };
212            } else {
213                // Failed or processing: Simple status
214                userFriendlyResult = {
215                    success: false,
216                    error: result.data?.error || jobData?.error || 'Image optimization failed'
217                };
218            }
219
220            await Actor.setValue('OUTPUT', userFriendlyResult);
221
222            // Save successful optimizations to dataset
223            if (userFriendlyResult.success) {
224                const dataset = await Dataset.open();
225                await dataset.pushData({
226                    optimizedUrl: userFriendlyResult.optimizedUrl,
227                    originalSize: userFriendlyResult.originalSize,
228                    optimizedSize: userFriendlyResult.optimizedSize,
229                    compressionSaved: userFriendlyResult.compressionSaved,
230                    dimensions: userFriendlyResult.dimensions,
231                    format: userFriendlyResult.format,
232                    success: userFriendlyResult.success,
233                    processedAt: new Date().toISOString()
234                });
235
236                console.log(`✅ Success! ${userFriendlyResult.compressionSaved} smaller (${userFriendlyResult.optimizedSize} bytes)`);
237                console.log(`🔗 Optimized image: ${userFriendlyResult.optimizedUrl}`);
238            } else {
239                console.log(`❌ Failed: ${userFriendlyResult.error}`);
240            }
241
242
243        } else if (action === 'status') {
244            if (!jobId) {
245                throw new Error('jobId is required for status action');
246            }
247
248            const vpsUrl = `${VPS_BASE_URL}${VPS_STATUS_ENDPOINT}/${jobId}`;
249
250            console.log(`🔍 Checking job status: ${jobId.substring(0, 8)}...`);
251
252            const response = await fetch(vpsUrl, {
253                method: 'GET',
254                headers: {
255                    'Authorization': `Bearer ${VPS_API_KEY}`,
256                    'User-Agent': 'Apify-Proxy/1.0'
257                },
258                timeout: REQUEST_TIMEOUT
259            });
260
261            const result = await response.json();
262
263            if (!response.ok) {
264                throw new Error(`VPS API error: ${result.error || 'Unknown error'}`);
265            }
266
267            // Create user-friendly simplified output
268            const jobData = result.data?.result;
269            const isCompleted = result.data?.status === 'completed' && jobData?.success;
270
271            let userFriendlyResult;
272
273            if (isCompleted) {
274                // Success: Show only what users care about
275                const compressionSaved = jobData.originalSize && jobData.optimizedSize
276                    ? Math.round(((jobData.originalSize - jobData.optimizedSize) / jobData.originalSize) * 100)
277                    : 0;
278
279                userFriendlyResult = {
280                    success: true,
281                    optimizedUrl: jobData.uploadResult?.url || '',
282                    originalSize: jobData.originalSize,
283                    optimizedSize: jobData.optimizedSize,
284                    compressionSaved: `${compressionSaved}%`,
285                    dimensions: {
286                        width: jobData.metadata?.width || 0,
287                        height: jobData.metadata?.height || 0
288                    },
289                    format: jobData.contentType?.replace('image/', '') || 'webp'
290                };
291            } else {
292                // Failed or processing: Simple status
293                userFriendlyResult = {
294                    success: false,
295                    error: jobData?.error || 'Image optimization failed'
296                };
297            }
298
299            await Actor.setValue('OUTPUT', userFriendlyResult);
300
301            // Save successful optimizations to dataset
302            if (userFriendlyResult.success) {
303                const dataset = await Dataset.open();
304                await dataset.pushData({
305                    optimizedUrl: userFriendlyResult.optimizedUrl,
306                    originalSize: userFriendlyResult.originalSize,
307                    optimizedSize: userFriendlyResult.optimizedSize,
308                    compressionSaved: userFriendlyResult.compressionSaved,
309                    dimensions: userFriendlyResult.dimensions,
310                    format: userFriendlyResult.format,
311                    success: userFriendlyResult.success,
312                    processedAt: new Date().toISOString()
313                });
314
315                console.log(`✅ Job completed! ${userFriendlyResult.compressionSaved} compression achieved`);
316            } else {
317                console.log(`⏳ Job still processing...`);
318            }
319
320              }
321    } else {
322        // Start HTTP server for direct API calls
323        const port = process.env.PORT || 3000;
324        await new Promise((resolve) => {
325            app.listen(port, () => {
326                            resolve();
327            });
328        });
329    }
330});

apify.json.deprecated

{
    "name": "image-optimizer-proxy",
    "version": "1.0.0",
    "buildTag": "latest",
    "actorSpecification": 1,
    "title": "Image Optimizer Proxy",
    "description": "Lightweight proxy to VPS-based image optimization API with CDN bypass capabilities",
    "meta": {
        "templateTitle": "Image Optimizer Proxy"
    },
    "input": "./INPUT_SCHEMA.json",
    "dockerfile": "./Dockerfile",
    "readme": "./README.md",
    "environmentVariables": {
        "schema": {
            "type": "object",
            "properties": {
                "VPS_BASE_URL": {
                    "type": "string",
                    "title": "VPS Base URL",
                    "description": "Base URL of your VPS optimizer API",
                    "default": "http://h8swosc0oo0c8wwokkkkk00g.144.24.194.211.sslip.io:3000/api/v1",
                    "editor": "textfield"
                },
                "VPS_DOWNLOAD_ENDPOINT": {
                    "type": "string",
                    "title": "Download Endpoint",
                    "description": "Endpoint path for submitting optimization jobs",
                    "default": "/download",
                    "editor": "textfield"
                },
                "VPS_STATUS_ENDPOINT": {
                    "type": "string",
                    "title": "Status Endpoint",
                    "description": "Endpoint path for checking job status",
                    "default": "/status",
                    "editor": "textfield"
                },
                "VPS_API_KEY": {
                    "type": "string",
                    "title": "VPS API Key",
                    "description": "API key for authenticating with VPS",
                    "editor": "textfield"
                },
                "REQUEST_TIMEOUT": {
                    "type": "integer",
                    "title": "Request Timeout (ms)",
                    "description": "Timeout for requests to VPS",
                    "default": 300000,
                    "editor": "numberfield"
                }
            },
            "required": ["VPS_BASE_URL", "VPS_API_KEY"]
        }
    }
}

DATASET_SCHEMA.json

[
  {
    "name": "optimizedUrl",
    "type": "string",
    "title": "Optimized Image URL",
    "description": "Direct link to your optimized image file",
    "format": "uri"
  },
  {
    "name": "originalSize",
    "type": "integer",
    "title": "Original File Size",
    "description": "Size of the original image in bytes",
    "format": "number"
  },
  {
    "name": "optimizedSize",
    "type": "integer",
    "title": "Optimized File Size",
    "description": "Size of the optimized image in bytes",
    "format": "number"
  },
  {
    "name": "compressionSaved",
    "type": "string",
    "title": "Compression Saved",
    "description": "Percentage of file size reduction achieved",
    "format": "percentage"
  },
  {
    "name": "dimensions",
    "type": "object",
    "title": "Image Dimensions",
    "description": "Width and height of the optimized image",
    "properties": {
      "width": {
        "type": "integer",
        "title": "Width",
        "description": "Image width in pixels"
      },
      "height": {
        "type": "integer",
        "title": "Height",
        "description": "Image height in pixels"
      }
    }
  },
  {
    "name": "format",
    "type": "string",
    "title": "Image Format",
    "description": "File format of the optimized image",
    "enum": ["webp", "jpeg", "png", "jpg"]
  },
  {
    "name": "success",
    "type": "boolean",
    "title": "Success Status",
    "description": "Whether the image optimization was successful"
  },
  {
    "name": "error",
    "type": "string",
    "title": "Error Message",
    "description": "Error details if optimization failed"
  }
]

Dockerfile

FROM node:20-alpine

# Set working directory
WORKDIR /usr/src/app

# Install required dependencies
RUN npm install apify express node-fetch@2.6.7

# Copy actor files
COPY . ./

# Set the entrypoint
CMD [ "node", "actor.js" ]

.actor/actor.json

{
	"actorSpecification": 1,
	"name": "easy-image-optimizer",
	"version": "1.0",
	"buildTag": "latest",
	"title": "Easy Image Optimizer",
	"description": "Convert and optimize any image from the web - even from protected sites like Midjourney! Just paste the URL and get perfectly optimized images in seconds.",
	"meta": {
		"templateTitle": "Easy Image Optimizer"
	}
}

Image Scraper

rapidtech1898/image-scraper

Scrape Image-Links from any website

Max Pohler

1.0

Image to Prompt Generator 🎨 ✨

easyapi/image-to-prompt-generator

Transform any image into detailed text descriptions using AI. Perfect for content creators, SEO specialists, and developers who need automated image-to-text conversion. Powered by Phot.ai's advanced image recognition technology.

EasyApi

image to image

evoort-solutions-llc/image-to-image

Evoort Solutions LLC

Convert Image to PDF and PDF to Image

akash9078/image-pdf-converter

Convert images (JPG, PNG, BMP, and more) into high-quality PDFs, or extract images from PDF files in seconds. Image–PDF Converter Pro delivers fast, reliable, and professional results for all your document and image conversion needs.

Akash Kumar Naik

Google Images Scraper

hooli/google-images-scraper

Scrape image details from images.google.com. Add your query and number of images and extract image details such as image URL, image source, description, image dimensions, thumbnail, and more. Export scraped data, run the scraper via API, schedule and monitor runs, or integrate with other tools.

Hooli

4.8

Bulk Image Downloader

trudax/bulk-image-downloader

Download all images from a website with this easy-to-use Bulk Image Downloader. Scrape all images from any website by URL to a zip file with a single click.

Gustavo Rudiger

5.0

Google Images Scraper

easyapi/google-images-scraper

Powerful Google Images scraper collect up to 5000 image results per runn with flexible search options, language support. Perfect for visual content research, competitor analysis, and image SEO optimization. 🖼️🔍

EasyApi

141

5.0

Website Image Scraper

gomorrhadev/website-image-scraper

Website Image Scraper is a fast, lightweight tool that crawls websites to extract image URLs (jpg, png, svg) without downloading files or using browsers. It supports recursive crawling, respects robots.txt, and efficiently collects image links for analysis or monitoring or a later download.

F. Gutz

5.0

✨ Instagram Post & Image Scraper, Image Post Downloader

scrapearchitect/instagram-post-image-scraper-image-post-downloader

Scrape Image, Post Metadata & download HD images 🖼️ from any Instagram post! Get FULL metadata: likes ❤️ comments 🗨️ captions 📝 hashtags #, user info 👤 AND deep technical image data 🔍 (codec, dimensions, bitrate!). ✅ marketing & analysis ✨ Instagram Post & Image Scraper, Image Post Downloader

Scrape Architect

Website Image Downloader Pro

powerful_bachelor/website-image-downloader-pro

📸 Website Image Downloader Pro: Extract and download images from any URL! 🚀 Features include image URL extraction, SVG to PNG conversion, downloading, and zipping images. Perfect for market research, AI training, and creating visual archives. 🌐✨ Try it now on Apify! 💾