Products

SIGN UPLOG IN
MODERATION
Image ModerationVideo ModerationText Moderation
REDACTION
Image Redaction
    Video Redaction
      REFERENCE
      Vision ModelsText Models
        FAQ

        Models / Face Analysis

        Face Age & Minor Detection API BETA

        Table of contents

        Overview

        The Face Age model is useful to estimate the age group of people appearing in photographs.

        The estimation is based on face analysis, meaning that the age group will be computed only for people whose face is sufficiently visible in the photo.

        This model will not return an age group for artificial faces (such as illustrations, statues, dolls...)

        Real vs Artificial faces

        The model works by detecting human faces and determining if they are real or artificial.

        The age group information will only be returned for real faces:

        • Real Faces: Real human faces, including those seen in reflections (e.g., mirrors) or within photos. Minor alterations from filters or post-processing are acceptable
          faces
          Image (real) 0 Image (real) 1 Image (real) 2
        • Artificial Faces: Any artificially created face, whether as a representation (2D) or a physical object (3D)
          artificial_faces
          • 2D representations: Drawings, paintings, animations, 3D renders, obvious AI-generated faces, or real faces altered to appear artificial
          • 3D objects: Statues, dolls, masks, mannequins, or figurines
          Image (artificial) 0 Image (artificial) 1 Image (artificial) 2 Image (artificial) 3 Image (artificial) 4

        Minor Detection

        For each human face that is not artificial, the model will return a faces.attributes.age.minor value. This represents the probability that a detected face belongs to a person who is a minor (under 18 years of age).

        The value is a float between 0 and 1. Values close to 1 indicate a high confidence that the face belongs to a minor. Values close to 0 indicate a high confidence that the face belongs to an adult.

        Use the model (images)

        If you haven't already, create an account to get your own API keys.

        Profile picture analysis

        Let's say you want to analyze the following image:

        You can either share a URL to the image, or upload the raw binary image.

        Option 1: Send image URL

        Here's how to proceed if you choose to share the image URL:

        
curl -X GET -G 'https://api.sightengine.com/1.0/check.json' \
    -d 'models=face-age' \
    -d 'api_user={api_user}&api_secret={api_secret}' \
    --data-urlencode 'url=https://sightengine.com/assets/img/examples/example7.jpg'


        
# this example uses requests
import requests
import json

params = {
  'url': 'https://sightengine.com/assets/img/examples/example7.jpg',
  'models': 'face-age',
  'api_user': '{api_user}',
  'api_secret': '{api_secret}'
}
r = requests.get('https://api.sightengine.com/1.0/check.json', params=params)

output = json.loads(r.text)


        
$params = array(
  'url' =>  'https://sightengine.com/assets/img/examples/example7.jpg',
  'models' => 'face-age',
  'api_user' => '{api_user}',
  'api_secret' => '{api_secret}',
);

// this example uses cURL
$ch = curl_init('https://api.sightengine.com/1.0/check.json?'.http_build_query($params));
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$response = curl_exec($ch);
curl_close($ch);

$output = json_decode($response, true);


        
// this example uses axios
const axios = require('axios');

axios.get('https://api.sightengine.com/1.0/check.json', {
  params: {
    'url': 'https://sightengine.com/assets/img/examples/example7.jpg',
    'models': 'face-age',
    'api_user': '{api_user}',
    'api_secret': '{api_secret}',
  }
})
.then(function (response) {
  // on success: handle response
  console.log(response.data);
})
.catch(function (error) {
  // handle error
  if (error.response) console.log(error.response.data);
  else console.log(error.message);
});

        See request parameter description

        ParameterTypeDescription
        mediabinaryimage to analyze
        modelsstringcomma-separated list of models to apply
        api_userstringyour API user id
        api_secretstringyour API secret

        Option 2: Send raw image

        Here's how to proceed if you choose to upload the raw image:

        
curl -X POST 'https://api.sightengine.com/1.0/check.json' \
    -F 'media=@/path/to/image.jpg' \
    -F 'models=face-age' \
    -F 'api_user={api_user}' \
    -F 'api_secret={api_secret}'


        
# this example uses requests
import requests
import json

params = {
  'models': 'face-age',
  'api_user': '{api_user}',
  'api_secret': '{api_secret}'
}
files = {'media': open('/path/to/image.jpg', 'rb')}
r = requests.post('https://api.sightengine.com/1.0/check.json', files=files, data=params)

output = json.loads(r.text)


        
$params = array(
  'media' => new CurlFile('/path/to/image.jpg'),
  'models' => 'face-age',
  'api_user' => '{api_user}',
  'api_secret' => '{api_secret}',
);

// this example uses cURL
$ch = curl_init('https://api.sightengine.com/1.0/check.json');
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, $params);
$response = curl_exec($ch);
curl_close($ch);

$output = json_decode($response, true);


        
// this example uses axios and form-data
const axios = require('axios');
const FormData = require('form-data');
const fs = require('fs');

data = new FormData();
data.append('media', fs.createReadStream('/path/to/image.jpg'));
data.append('models', 'face-age');
data.append('api_user', '{api_user}');
data.append('api_secret', '{api_secret}');

axios({
  method: 'post',
  url:'https://api.sightengine.com/1.0/check.json',
  data: data,
  headers: data.getHeaders()
})
.then(function (response) {
  // on success: handle response
  console.log(response.data);
})
.catch(function (error) {
  // handle error
  if (error.response) console.log(error.response.data);
  else console.log(error.message);
});

        See request parameter description

        ParameterTypeDescription
        mediabinaryimage to analyze
        modelsstringcomma-separated list of models to apply
        api_userstringyour API user id
        api_secretstringyour API secret

        API response

        The API will then return a JSON response with the following structure:

                          
                  
{
    "status": "success",
    "request": {
        "id": "req_gcTp4s63IAAni0lFOT7KK",
        "timestamp": 1714997478.552115,
        "operations": 1
    },
    "faces": [
        {
            "x1": 0.435,
            "y1": 0.2439,
            "x2": 0.5675,
            "y2": 0.4991,
            "attributes": {
                "age": {
                    "minor": 0.01,
                }
            }
        }
    ],
    "artificial_faces": [],
    "media": {
        "id": "med_gcTpqyOZ18IMsiMe4Ar28",
        "uri": "https://sightengine.com/assets/img/examples/example7.jpg"
    }
}

        Use the model (videos)

        Face analysis in videos

        Option 1: Short video

        Here's how to proceed to analyze a short video (less than 1 minute):

        
curl -X POST 'https://api.sightengine.com/1.0/video/check-sync.json' \
  -F 'media=@/path/to/video.mp4' \
  -F 'models=face-age' \
  -F 'api_user={api_user}' \
  -F 'api_secret={api_secret}'


        
# this example uses requests
import requests
import json

params = {
  # specify the models you want to apply
  'models': 'face-age',
  'api_user': '{api_user}',
  'api_secret': '{api_secret}'
}
files = {'media': open('/path/to/video.mp4', 'rb')}
r = requests.post('https://api.sightengine.com/1.0/video/check-sync.json', files=files, data=params)

output = json.loads(r.text)


        
$params = array(
  'media' => new CurlFile('/path/to/video.mp4'),
  // specify the models you want to apply
  'models' => 'face-age',
  'api_user' => '{api_user}',
  'api_secret' => '{api_secret}',
);

// this example uses cURL
$ch = curl_init('https://api.sightengine.com/1.0/video/check-sync.json');
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, $params);
$response = curl_exec($ch);
curl_close($ch);

$output = json_decode($response, true);


        
// this example uses axios and form-data
const axios = require('axios');
const FormData = require('form-data');
const fs = require('fs');

data = new FormData();
data.append('media', fs.createReadStream('/path/to/video.mp4'));
// specify the models you want to apply
data.append('models', 'face-age');
data.append('api_user', '{api_user}');
data.append('api_secret', '{api_secret}');

axios({
  method: 'post',
  url:'https://api.sightengine.com/1.0/video/check-sync.json',
  data: data,
  headers: data.getHeaders()
})
.then(function (response) {
  // on success: handle response
  console.log(response.data);
})
.catch(function (error) {
  // handle error
  if (error.response) console.log(error.response.data);
  else console.log(error.message);
});

        See request parameter description

        ParameterTypeDescription
        mediabinaryimage to analyze
        modelsstringcomma-separated list of models to apply
        intervalfloatframe interval in seconds, out of 0.5, 1, 2, 3, 4, 5 (optional)
        api_userstringyour API user id
        api_secretstringyour API secret

        Option 2: Long video

        Here's how to proceed to analyze a long video. Note that if the video file is very large, you might first need to upload it through the Upload API.

        
curl -X POST 'https://api.sightengine.com/1.0/video/check.json' \
  -F 'media=@/path/to/video.mp4' \
  -F 'models=face-age' \
  -F 'callback_url=https://yourcallback/path' \
  -F 'api_user={api_user}' \
  -F 'api_secret={api_secret}'


        
# this example uses requests
import requests
import json

params = {
  # specify the models you want to apply
  'models': 'face-age',
  # specify where you want to receive result callbacks
  'callback_url': 'https://yourcallback/path',
  'api_user': '{api_user}',
  'api_secret': '{api_secret}'
}
files = {'media': open('/path/to/video.mp4', 'rb')}
r = requests.post('https://api.sightengine.com/1.0/video/check.json', files=files, data=params)

output = json.loads(r.text)


        
$params = array(
  'media' => new CurlFile('/path/to/video.mp4'),
  // specify the models you want to apply
  'models' => 'face-age',
  // specify where you want to receive result callbacks
  'callback_url' => 'https://yourcallback/path',
  'api_user' => '{api_user}',
  'api_secret' => '{api_secret}',
);

// this example uses cURL
$ch = curl_init('https://api.sightengine.com/1.0/video/check.json');
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, $params);
$response = curl_exec($ch);
curl_close($ch);

$output = json_decode($response, true);


        
// this example uses axios and form-data
const axios = require('axios');
const FormData = require('form-data');
const fs = require('fs');

data = new FormData();
data.append('media', fs.createReadStream('/path/to/video.mp4'));
// specify the models you want to apply
data.append('models', 'face-age');
// specify where you want to receive result callbacks
data.append('callback_url', 'https://yourcallback/path');
data.append('api_user', '{api_user}');
data.append('api_secret', '{api_secret}');

axios({
  method: 'post',
  url:'https://api.sightengine.com/1.0/video/check.json',
  data: data,
  headers: data.getHeaders()
})
.then(function (response) {
  // on success: handle response
  console.log(response.data);
})
.catch(function (error) {
  // handle error
  if (error.response) console.log(error.response.data);
  else console.log(error.message);
});

        See request parameter description

        ParameterTypeDescription
        mediabinaryimage to analyze
        callback_urlstringcallback URL to receive moderation updates (optional)
        modelsstringcomma-separated list of models to apply
        intervalfloatframe interval in seconds, out of 0.5, 1, 2, 3, 4, 5 (optional)
        api_userstringyour API user id
        api_secretstringyour API secret

        Option 3: Live-stream

        Here's how to proceed to analyze a live-stream:

        
curl -X GET -G 'https://api.sightengine.com/1.0/video/check.json' \
    --data-urlencode 'stream_url=https://domain.tld/path/video.m3u8' \
    -d 'models=face-age' \
    -d 'callback_url=https://your.callback.url/path' \
    -d 'api_user={api_user}' \
    -d 'api_secret={api_secret}'


        
# if you haven't already, install the SDK with 'pip install sightengine'
from sightengine.client import SightengineClient
client = SightengineClient('{api_user}','{api_secret}')
output = client.check('face-age').video('https://domain.tld/path/video.m3u8', 'https://your.callback.url/path')


        
// if you haven't already, install the SDK with 'composer require sightengine/client-php'
use \Sightengine\SightengineClient;
$client = new SightengineClient('{api_user}','{api_secret}');
$output = $client->check(['face-age'])->video('https://domain.tld/path/video.m3u8', 'https://your.callback.url/path');


        
// if you haven't already, install the SDK with 'npm install sightengine --save'
var sightengine = require('sightengine')('{api_user}', '{api_secret}');
sightengine.check(['face-age']).video('https://domain.tld/path/video.m3u8', 'https://your.callback.url/path').then(function(result) {
    // The API response (result)
}).catch(function(err) {
    // Handle error
});

        See request parameter description

        ParameterTypeDescription
        stream_urlstringURL of the video stream
        callback_urlstringcallback URL to receive moderation updates (optional)
        modelsstringcomma-separated list of models to apply
        intervalfloatframe interval in seconds, out of 0.5, 1, 2, 3, 4, 5 (optional)
        api_userstringyour API user id
        api_secretstringyour API secret

        Moderation result

        The Moderation result will be provided either directly in the request response (for sync calls, see below) or through the callback URL your provided (for async calls).

        Here is the structure of the JSON response with moderation results for each analyzed frame under the data.frames array:

                    
                  
{
  "status": "success",
  "request": {
    "id": "req_gmgHNy8oP6nvXYaJVLq9n",
    "timestamp": 1717159864.348989,
    "operations": 21
  },
  "data": {
    "frames": [
      {
      "info": {
        "id": "med_gmgHcUOwe41rWmqwPhVNU_1",
        "position": 0
      },
      "faces": [
        {
          "x1": 0.435,
          "y1": 0.2439,
          "x2": 0.5675,
          "y2": 0.4991,
          "attributes": {
            "age": {
              "minor": 0.01
            }
          }
        }
        ],
      "artificial_faces": [],
      },
      ...
    ]
  },
  "media": {
    "id": "med_gmgHcUOwe41rWmqwPhVNU",
    "uri": "yourfile.mp4"
  },
}

        Any other needs?

        See our full list of Image/Video models for details on other filters and checks you can run on your images and videos. You might also want to check our Text models to moderate text-based content: messages, reviews, comments, usernames...

        Was this page helpful?