API REST per sfocare volti e targhe nelle foto

L’API Watermarkly Blur rileva e sfoca automaticamente targhe e volti nelle immagini.

Questo servizio è completamente ospitato sull’infrastruttura AWS e garantisce la privacy senza utilizzare i file dei clienti per l’addestramento dei modelli di IA.
Utilizziamo AWS Lambda, che ci consente di gestire migliaia di richieste parallele in modo affidabile e di offrire il servizio in diverse regioni del mondo.

Caratteristiche

• Rileva e sfoca automaticamente targhe e volti nelle immagini.
• Consente di sostituire le targhe con il logo del proprio progetto.
• Ridimensiona, ritaglia o converte le immagini elaborate opzionalmente.
• Supporta fino a 500 richieste al secondo.
• Elabora le immagini in parallelo per una maggiore efficienza.
• Dimensione massima dell’immagine supportata: 6000x6000 pixel.

Se hai bisogno di un’elaborazione più veloce, del supporto per immagini più grandi o di un tasso di richieste più elevato, contattaci a api-support@watermarkly.com.

L’API ti consente di sostituire le targhe con il logo della tua azienda.

Endpoint API

Regioni

Attualmente, offriamo l’API in due regioni:

• Europa: https://blur-api-eu1.watermarkly.com/ (eu-north-1)
• Stati Uniti: https://blur-api-us1.watermarkly.com/ (us-east-2)

Sei libero di utilizzare l’endpoint che preferisci. Puoi usare il secondo endpoint come riserva nel caso in cui una regione AWS vada offline. Se hai bisogno dell’API in un’altra regione, faccelo sapere.

Metodi di richiesta

Puoi inviare immagini per l’elaborazione utilizzando richieste GET o POST.
Se le tue immagini sono pubblicamente disponibili, consigliamo l’uso delle richieste GET, poiché sono leggermente più veloci rispetto alle richieste POST.

Sfocare un’immagine con una richiesta GET (Consigliato)

GET https://blur-api-eu1.watermarkly.com/blur/?url={image_url}

or

GET https://blur-api-us1.watermarkly.com/blur/?url={image_url}

Il servizio scarica l’immagine da image_url e la elabora.

Richiesta

• Metodo: GET
• Parametri della query URL:
  • url (Obbligatorio): L’URL completo dell’immagine da elaborare.
  • blur_intensity (Opzionale): Un valore float tra 0.0 e 20.0 che regola l’intensità della sfocatura. Predefinito: 1.0. 0.0 disabilita la sfocatura.
  • file_size (Opzionale): Specifica la dimensione del file di output desiderata in byte. Il servizio tenterà di restituire un’immagine che non superi questa dimensione.
  • width (Opzionale): Specifica la larghezza desiderata dell’immagine di output.
  • height (Opzionale): Specifica l’altezza desiderata dell’immagine di output.
  • format (Opzionale): Specifica il formato dell’immagine di output. Valori possibili: JPEG, PNG, WEBP.
  • logo_url (Opzionale): L’URL di un file logo da posizionare sulle targhe. Può essere un URL HTTP o un URL dati. Assicurati che l’URL sia correttamente codificato prima di inviarlo come parametro di richiesta.
  • logo_size (Opzionale): Specifica la dimensione del logo come valore tra 0.1 e 1.0.
  • plate_screws (Opzionale): Aggiunge viti alle targhe. Funziona solo insieme al parametro logo_url.

Risposta

Risposta riuscita: (HTTP Status: 200) Il servizio restituisce l’immagine elaborata in uno dei seguenti formati: JPEG, PNG, WEBP.

Risposta di errore: (HTTP Status: 500, 403)

{
  "message": "Error message"
}

Sfocare un’immagine con una richiesta POST

POST https://blur-api-eu1.watermarkly.com/blur/

or

POST https://blur-api-us1.watermarkly.com/blur/

Invia un’immagine per l’elaborazione.

Richiesta

• Metodo: POST
• Content-Type: application/octet-stream
• Intestazioni:
  • x-api-key: La tua chiave API
• Parametri della query:
  • blur_intensity (Opzionale): Un valore float tra 0.0 e 20.0 che regola l’intensità della sfocatura. Valore predefinito: 1.0. Impostare 0.0 disattiva la sfocatura.
  • file_size (Opzionale): Specifica la dimensione desiderata del file di output in byte. Il servizio tenterà di restituire un’immagine che non superi questa dimensione.
  • width (Opzionale): Specifica la larghezza desiderata dell’immagine di output.
  • height (Opzionale): Specifica l’altezza desiderata dell’immagine di output.
  • format (Opzionale): Specifica il formato desiderato dell’immagine di output. Valori possibili: JPEG, PNG, WEBP.
  • logo_url (Opzionale): L’URL di un file logo da posizionare sulle targhe. Può essere un URL HTTP o un URL dati. Assicurarsi che l’URL sia correttamente codificato prima di inviarlo come parametro di richiesta.
  • logo_size (Opzionale): Specifica la dimensione del logo con un valore compreso tra 0.1 e 1.0.
  • plate_screws (Opzionale): Aggiunge viti alle targhe. Funziona solo in combinazione con il parametro logo_url.

Risposta

Risposta positiva: (HTTP Status: 200) Il servizio restituisce l’immagine elaborata in uno dei seguenti formati: JPEG, PNG, WEBP.

Risposta di errore: (HTTP Status: 500, 403)

{
  "message": "Error message"
}

Dettagli del processo

• Le immagini elaborate non vengono archiviate sui nostri server.
• Il servizio accetta immagini nei formati JPEG, PNG, WEBP, AVIF, HEIC/HEIF.
• Le immagini AVIF e HEIF verranno convertite in JPEG, a meno che non venga specificato un altro formato.
• Dimensione massima dell’immagine in ingresso:
  • Richieste GET: 20MB o 6000x6000 pixel.
  • Richieste POST: 6MB o 6000x6000 pixel.
• Limiti dell’API:
  • 500 richieste parallele
  • 500 richieste al secondo
  • 100.000 richieste al giorno
• Se hai bisogno di limiti più elevati, contattaci all’indirizzo api-support@watermarkly.com.

Sicurezza e privacy

• Le richieste API richiedono l’autenticazione tramite una chiave API.
• I file dei clienti non vengono utilizzati per l’addestramento dei modelli di IA.
• Tutto il trattamento avviene sull’infrastruttura AWS. Possiamo implementare l’API in una regione a tua scelta gratuitamente.

Esempi di utilizzo

Python

import requests
import urllib.parse

API_KEY = 'your_api_key'
API_URL = 'https://blur-api-eu1.watermarkly.com/blur/'

input_path = ''       # Local image path
output_path = ''      # Local output path

# Blur image using POST request
with open(input_path, 'rb') as image_file:
    response = requests.post(API_URL, headers={'x-api-key': API_KEY}, data=image_file)
    if response.status_code == 429:
        # API rate limit exceeded, wait a little
        time.sleep(0.1)
        response = requests.post(API_URL, headers={'x-api-key': API_KEY}, data=image_file)
# Save the processed image locally
with open(output_path, 'wb') as f:
    f.write(response.content)


# Blur image using GET request
encoded_url = urllib.parse.quote("https://nikitin.io/eqe.jpg", safe='')
response = requests.get(API_URL + "?url=" + encoded_url, headers={'x-api-key': API_KEY})
# Save the response locally
with open(output_path, 'wb') as f:
    f.write(response.content)

NodeJS

import { promises as fs } from "node:fs";

const API_KEY = 'your_api_key';
const API_URL = 'https://blur-api-eu1.watermarkly.com/blur/';

// Helper function to pause execution for the given number of milliseconds
const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));

(async () => {
  // Blur image using POST request
  try {
    const inputPath = 'input_path_here';   // Replace with your actual input path
    const outputPath = 'output_path_here'; // Replace with your actual output path

    // Read image file as binary data asynchronously
    const imageData = await fs.readFile(inputPath);

    let response = await fetch(API_URL, {
      method: 'POST',
      headers: {
        'x-api-key': API_KEY,
        'Content-Type': 'application/octet-stream'
      },
      body: imageData
    });

    if (response.status === 429) {
      // API rate limit exceeded, wait a little
      await sleep(100); // sleep for 0.1 seconds
      response = await fetch(API_URL, {
        method: 'POST',
        headers: {
          'x-api-key': API_KEY,
          'Content-Type': 'application/octet-stream'
        },
        body: imageData
      });
    }
    // Save the processed image locally asynchronously
    const arrayBuffer = await response.arrayBuffer();
    const buffer = Buffer.from(arrayBuffer);
    await fs.writeFile(outputPath, buffer);
  } catch (error) {
    console.error('Error during POST request:', error);
  }

  // Blur image using GET request
  try {
    const outputPath = 'output_path_here'; // Replace with your actual output path
    const encodedUrl = encodeURIComponent("https://nikitin.io/eqe.jpg"); // Encode URL
    const response = await fetch(`${API_URL}?url=${encodedUrl}`, {
      method: 'GET',
      headers: {
        'x-api-key': API_KEY
      }
    });
    // Save the response locally asynchronously
    const arrayBuffer = await response.arrayBuffer();
    const buffer = Buffer.from(arrayBuffer);
    await fs.writeFile(outputPath, buffer);
  } catch (error) {
    console.error('Error during GET request:', error);
  }
})();