Docs / Moderation / Visual Moderation / Gore & Disgusting content Detection

Gore & Disgusting content Detection

gore-2.0

Detect gore, disgusting and horrific imagery, including blood, injuries, guts in Images and Videos

Replaces legacy model gore

Overview

The Gore & Disgusting model helps you determine if an image or video contains gore, horrific or disgusting imagery such as blood, guts, wounds, corpses, skulls and more.

The output of the model is provided in 10 gore classes to help you determine what kind of depiction is in the image or video, and 3 type classes:

Gore classes	Very bloody	very_bloody
	Slightly bloody	slightly_bloody
	Body organ	body_organ
	Serious injury	serious_injury
	Superficial injury	superficial_injury
	Corpse	corpse
	Skull	skull
	Unconscious	unconscious
	Body waste	body_waste
	Other	other
Gore type	Animated gore	animated
	Fake gore	fake
	Real gore	real

Related models

The following 3 models can provide a useful complement to the gore model:

Violence Detection: Detect violent content such as fights, hanging, strangling.
Weapon Detection: Detect firearms, knives and how they are being used in images and videos.
Self-Harm Detection: Detect scenes showing or suggesting self-harm.

Gore classes

Very bloody: Photos and illustrations with large amounts of blood or bleeding
gore.classes.very_bloody
- Open wounds
- Large amounts of blood or blood splatters
- Profuse bloody noses or mouths
- Bleeding from major injuries
This does not include blood in a medical context, such as blood tests, blood donations, or blood transfusions.
Slightly bloody: Photos and illustrations with small amounts of blood or bleeding
gore.classes.slightly_bloody
- Slightly bleeding nose
- Small injuries
- Small amounts of blood on surfaces
This does not include blood in a medical context, such as blood tests, blood donations, or blood transfusions.
Body organ:
gore.classes.body_organ
- Human organs (such as heart, lungs, kidneys, instentine, liver) visible inside the body due to deep cuts or wounds, or during medical surgery
- Preserved human body organs such as brains or lungs, typically used as artifacts in museums or for educational purposes
Serious injury: Major injuries, that typically require urgent care
gore.classes.serious_injury
- Gunshot or stab wounds
- Deep cuts, exposing blood or organs
- Loss of limbs or fingers with bleeding
- Animal attacks and bites that have not healed
Superficial injury: Minor injuries that typically do not require urgent care
gore.classes.superficial_injury
- Small cuts
- Scratches
- Small injuries with limited bleeding
Corpse: Human corpses
gore.classes.corpse
- Human bodies with enough contextual evidence to assume the person is dead
See the unconscious class for cases where the person is assumed to be alive but unconscious. See the serious_injury class for graphic injuries where the person is visibly alive.
Skull: Human skull
gore.classes.skull
- Human skull
- Human skeleton, with a fully or partly visible skull
Unconscious: Person who, based on contextual evidence can be assumed to be alive but unconscious
gore.classes.unconscious
- Person lying down in a place not typically used for sleeping (i.e. not in a bed, tent or sofa)
- Person lying down in a position that evokes unconsciousness (i.e. non-natural position)
This does not include people visibly dead (see corpse class) or having injuries (see serious_injury class).
Body waste:
gore.classes.body_waste
- Urine: person urinating, with urine being visible
- Feces: human feces and animal feces when their aspect is similar to human feces
- Vomit: person vomiting, or in a context that evokes an intention to vomit (such as kneeling over a toilet seat)
Other: Other situations
gore.classes.other
- Dead or suffering animals (except for insects and small fishes)
- Close-ups of eyes or mouths
- Blood displayed in a medical context, such as in a pouch or in a test tube
- Scars with no visible bleeding (i.e. healed scars)
- Symbols and locations that typically evoke death: cemeteries, graves
- Illustrations of horrific or frightening characters, that typically convey evil or danger
Please reach out if you need to differentiate between different aspects within this other class.

Gore type

The Gore type section can be used to differentiate fake gore content from real gore content and gore content appearing in art or illustrations.

Animated gore: Illustrations containing gore depictions
gore.type.animated
- Gore appearing in drawings, paintings, illustrations
- Gore appearing in animations and cartoons
- Gore appearing in digital art and computer-generated designs
- Gore appearing in video game graphics
Fake gore: Photos with fake gore displays
gore.type.fake
- Blood that appears to be fake based on context
- Costumes and accessories that mimick death or injuries, such as in a Halloween setting
- Face filters that evoke scars, blood or injuries
Real gore: Real photographic gore depictions
gore.type.real
- Gore imagery in real photos, where there is no evidence that the gore content is fake
Realistic movie scenes will be flagged as real gore and not as fake gore.

Use the model (images)

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

Detect gore & disgusting content

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

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

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=gore-2.0' \
    -d 'api_user={api_user}&api_secret={api_secret}' \
    --data-urlencode 'url=https://sightengine.com/assets/img/examples/example-fac-1000.jpg'


# this example uses requests
import requests
import json

params = {
  'url': 'https://sightengine.com/assets/img/examples/example-fac-1000.jpg',
  'models': 'gore-2.0',
  '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/example-fac-1000.jpg',
  'models' => 'gore-2.0',
  '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/example-fac-1000.jpg',
    'models': 'gore-2.0',
    '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

Parameter	Type	Description
url	string	URL of the image to analyze
models	string	comma-separated list of models to apply
api_user	string	your API user id
api_secret	string	your API secret

Option 2: Send image file

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


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


# this example uses requests
import requests
import json

params = {
  'models': 'gore-2.0',
  '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' => 'gore-2.0',
  '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', 'gore-2.0');
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

Parameter	Type	Description
media	file	image to analyze
models	string	comma-separated list of models to apply
api_user	string	your API user id
api_secret	string	your API secret

API response

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

                  
                  
{
  "status": "success",
  "request": {
    "id": "req_glra5CGwKiJOgQIKG2xMe",
    "timestamp": 1716968170.907796,
    "operations": 1
  },
  "gore": {
    "prob": 0.01,
    "classes": {
      "very_bloody": 0.01,
      "slightly_bloody": 0.01,
      "body_organ": 0.01,
      "serious_injury": 0.01,
      "superficial_injury": 0.01,
      "corpse": 0.01,
      "skull": 0.01,
      "unconscious": 0.01,
      "body_waste": 0.01,
      "other": 0.01
    },
    "type": {
      "animated": 0.01,
      "fake": 0.01,
      "real": 0.01
    }
  },
  "media": {
    "id": "med_glra5aI8HdK23yzRwsWjs",
    "uri": "https://sightengine.com/assets/img/examples/example-fac-1000.jpg"
  }
}

See response description

Successful Response

Status code: 200, Content-Type: application/json

Field	Type	Description
status	string	status of the request, either "success" or "failure"
request	object	information about the processed request
request.id	string	unique identifier of the request
request.timestamp	float	timestamp of the request in Unix time
request.operations	integer	number of operations consumed by the request
gore	object	results for the model
media	object	information about the media analyzed
media.id	string	unique identifier of the media
media.uri	string	URI of the media analyzed: either the URL or the filename

Error

Status codes: 4xx and 5xx. See how error responses are structured.

Use the model (videos)

Detecting Gore & Disgusting content 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=gore-2.0' \
  -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': 'gore-2.0',
  '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' => 'gore-2.0',
  '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', 'gore-2.0');
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

Parameter	Type	Description
media	file	image to analyze
models	string	comma-separated list of models to apply
interval	float	frame interval in seconds, out of 0.5, 1, 2, 3, 4, 5 (optional)
api_user	string	your API user id
api_secret	string	your 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=gore-2.0' \
  -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': 'gore-2.0',
  # 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' => 'gore-2.0',
  // 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', 'gore-2.0');
// 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

Parameter	Type	Description
media	file	image to analyze
callback_url	string	callback URL to receive moderation updates (optional)
models	string	comma-separated list of models to apply
interval	float	frame interval in seconds, out of 0.5, 1, 2, 3, 4, 5 (optional)
api_user	string	your API user id
api_secret	string	your 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=gore-2.0' \
    -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('gore-2.0').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(['gore-2.0'])->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(['gore-2.0']).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

Parameter	Type	Description
stream_url	string	URL of the video stream
callback_url	string	callback URL to receive moderation updates (optional)
models	string	comma-separated list of models to apply
interval	float	frame interval in seconds, out of 0.5, 1, 2, 3, 4, 5 (optional)
api_user	string	your API user id
api_secret	string	your 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
        },
        "gore": {
          "prob": 0.01,
          "classes": {
            "very_bloody": 0.01,
            "slightly_bloody": 0.01,
            "body_organ": 0.01,
            "serious_injury": 0.01,
            "superficial_injury": 0.01,
            "corpse": 0.01,
            "skull": 0.01,
            "unconscious": 0.01,
            "body_waste": 0.01,
            "other": 0.01
          },
          "type": {
            "animated": 0.01,
            "fake": 0.01,
            "real": 0.01
          }
        },
      },
        ...
    ]
  },
  "media": {
    "id": "med_gmgHcUOwe41rWmqwPhVNU",
    "uri": "yourfile.mp4"
  },
}

You can use the classes under the gore object to determine the gore level of the video.

On this page

Gore & Disgusting content Detection

Overview

Related models

Gore classes

Gore type

Use the model (images)

Detect gore & disgusting content

Option 1: Send image URL

Option 2: Send image file

API response

Successful Response

Error

Use the model (videos)

Detecting Gore & Disgusting content in videos

Option 1: Short video

Option 2: Long video

Option 3: Live-stream

Moderation result