REST API. Offusca Volti e Targhe nelle Foto

La Blur API di Watermarkly rileva e offusca automaticamente i volti e le targhe nelle immagini. Funziona interamente su infrastruttura AWS e dà priorità alla privacy: i tuoi file non vengono mai utilizzati per addestrare modelli di intelligenza artificiale.
Utilizziamo AWS Lambda per elaborare migliaia di richieste in parallelo, garantendo prestazioni affidabili e disponibilità in più regioni nel mondo.

Provalo Gratis

Vendiamo l’API tramite AWS Marketplace. Costo: $0,01 / richiesta. È disponibile una prova gratuita di 7 giorni.

Caratteristiche Principali

✓ Rileva e offusca automaticamente targhe e volti nelle immagini

✓ Facoltativamente sostituisce le targhe con il logo del tuo progetto o azienda.

✓ Può ridimensionare, ritagliare o convertire le immagini elaborate.

✓ Supporta fino a 500 richieste al secondo.

✓ Elabora le immagini in parallelo per prestazioni più rapide.

✓ Dimensione massima supportata per immagine: 6000 × 6000 pixel.

✓ Le richieste API richiedono autenticazione tramite chiave API.

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

Esempi di Output

Il volto della donna e la targa sono offuscati.

API per offuscare volti e targhe nelle immagini

La targa è stata sostituita con il logo dell’azienda e il volto della donna è offuscato.

API per offuscare volti e targhe nelle immagini

Ottieni l’API

Vendiamo l’API tramite AWS Marketplace. Costo: $0,01 / richiesta. È disponibile una prova gratuita di 7 giorni.

Dettagli di Elaborazione

  • 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 se non viene specificato un altro formato.
  • Dimensione massima dell’immagine in input:
    • Richieste GET: 20MB o 6000x6000 pixel.
    • Richieste POST: 6MB o 6000x6000 pixel.
  • Limiti di frequenza dell’API:
    • 500 richieste in parallelo
    • 500 richieste al secondo
    • 100.000 richieste al giorno

Endpoint API

Regioni

Attualmente, offriamo l’API in due regioni:

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);
  }
})();