Sighthound Cloud API Logo

Computer Vision API for Developers

Detection API & Recognition API

Sighthound Cloud offers a Detection API for person, face, gender, and facial landmark detections; and a Recognition API that developers can use for face and vehicle recognition applications. Try out the following demo to see the Detection API and Recognition API in action.

Sighthound Cloud API Service

Sighthound Cloud is an API service that allows developers to add computer vision to their applications. Simple REST APIs return the location of any people and faces found in an image. Faces can be analyzed for gender and can be identified against a gallery of developer-provided images. A landmark detector will find the various facial features in the detected faces, including eyes, nose and mouth, by fitting 68 landmark points to those features.

The detectors and recognizers are all based on state-of-the-art research from Sighthound’s Computer Vision Research Lab, and have higher rates of precision, recall and mean accuracy than other publicly available software.

Sighthound Cloud is free for developers and available for commercial purposes to those with a paid account. To get started, see below.

Plans & Pricing

Developer Free 5,000 API Calls
Development
  • Non-Commercial Use Only
  • No Credit Card Needed
Basic $49 / month 50,000 API Calls
Pro $199 / month 250,000 API Calls
Enterprise
$999 / month 2,000,000 API Calls
$2,499 / month 5,000,000 API Calls
$4,999 / month 10,000,000 API Calls
Commercial Use
  • Load Balanced Production Servers
  • 100% Uptime Guarantee
  • Obsessive Support
  • Additional API Calls $0.005
Get started for free

Sighthound Cloud is always free for developers. Full terms and conditions here.

Quickstart Guides

Recognition API

To get started with the Recognition API, view the face recognition tutorial to see code examples in popular languages, and then refer to the API documentation for full details.


Detection API

View the Detection API code examples below or refer to the API documentation for full details.

Code Examples

JavaScript
Python
Ruby
C#
Java
Curl

var image = {image: "https://www.example.com/path/to/image.jpg"};
var xmlhttp = new XMLHttpRequest();
var result;

xmlhttp.onreadystatechange = function () {
  if (xmlhttp.readyState === 4 && xmlhttp.status === 200) {
    result = xmlhttp.responseText;
  }
}

xmlhttp.open("POST", "https://dev.sighthoundapi.com/v1/detections?type=face,person&faceOption=landmark,gender");
xmlhttp.setRequestHeader("Content-type", "application/json");
xmlhttp.setRequestHeader("X-Access-Token", "YOUR-CLOUD-TOKEN");
xmlhttp.send(JSON.stringify(image));


import base64
import httplib
import json
import os
import ssl

headers = {"Content-type": "application/json",
           "X-Access-Token": "YOUR-CLOUD-TOKEN"}
conn = httplib.HTTPSConnection("dev.sighthoundapi.com", 
       context=ssl.SSLContext(ssl.PROTOCOL_TLSv1))

# To use a hosted image uncomment the following line and update the URL
#image_data = "http://example.com/path/to/hosted/image.jpg"

# To use a local file uncomment the following line and update the path
#image_data = base64.b64encode(open("/path/to/local/image.jpg").read())

params = json.dumps({"image": image_data})
conn.request("POST", "/v1/detections?type=face,person&faceOption=landmark,gender", params, headers)
response = conn.getresponse()
result = response.read()
print "Detection Results = " + str(result)


require "json"
require "net/http"
require "uri"

uri = URI.parse("https://dev.sighthoundapi.com/v1/detections?type=face,person&faceOption=landmark,gender")

connection = Net::HTTP.new(uri.host, uri.port)
connection.use_ssl = true

request = Net::HTTP::Post.new(uri.request_uri)
request.add_field("X-Access_Token", "YOUR-CLOUD-TOKEN")
request.add_field("Content-type", "application/json")
request.body = {"image" => "https://www.example.com/path/to/image.jpg"}.to_json

response = connection.request(request)
puts response.body


using System;
using System.Collections.Generic;
using System.Text;
using System.Net;
using System.IO;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;

class UrlSample
{
  static void Main(string[] args)
  {
    Dictionary dict = new Dictionary();
    dict.Add("image", "https://www.example.com/path/to/image.jpg");
    string json = JsonConvert.SerializeObject(dict, Formatting.Indented);
    byte[] body = Encoding.UTF8.GetBytes(json);

    WebRequest request = WebRequest.Create("https://dev.sighthoundapi.com/v1/detections?type=face,person&faceOption=landmark,gender");
    request.Method = "POST";
    request.ContentType = "application/json";
    request.ContentLength = json.Length;
    request.Headers["X-Access-Token"] = "Your-API-Key";
    Stream requestStream = request.GetRequestStream();
    requestStream.Write(body, 0, body.Length);
    requestStream.Close();

    try
    {
      HttpWebResponse response = (HttpWebResponse)request.GetResponse();
      StreamReader reader = new StreamReader(response.GetResponseStream(), 
                            ASCIIEncoding.UTF8);
      json = reader.ReadToEnd();
      reader.Close();
      JObject result = JObject.Parse(json);
      if (response.StatusCode == HttpStatusCode.OK)
      {
        JObject image = result["image"].Value();
        Console.WriteLine("analyzed image {0}x{1} with orientation {2}",
          image["width"].Value(),
          image["height"].Value(),
          image["orientation"].Value());
        JArray objects = (JArray)result["objects"];
        foreach (JObject obj in objects.Children())
        {
          string type = obj["type"].Value();
          JObject bbox = (JObject)obj["boundingBox"];
          Console.WriteLine("found '{0}' {1}x{2} at ({3},{4})", type,
            bbox["width"].Value(), bbox["height"].Value(),
            bbox["x"].Value(), bbox["y"].Value());
        }
      }
    }
    catch (WebException we)
    {
      StreamReader reader = new StreamReader(we.Response.GetResponseStream(),
                            ASCIIEncoding.UTF8);
      json = reader.ReadToEnd();
      reader.Close();
      JObject info = JObject.Parse(json);
      Console.WriteLine("REQUEST FAILED\nerror: {0}\nreason: '{1}'",
        info["error"].Value(),
        info["reason"].Value(),
        info["reasonCode"].Value());
    }
  }
}


import java.io.IOException;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;

import javax.json.Json;
import javax.json.JsonObject;
import javax.json.JsonReader;

public class UrlSample {
  private static final String api = "https://dev.sighthoundapi.sighthound.com/v1/detections?type=face,person&faceOption=landmark,gender";
  private static final String accessToken = "Your-API-Key";
  private static String imageUrl = "https://www.example.com/path/to/image.jpg";
  public static void main(String[] args) throws IOException {
    JsonObject jsonImage = Json.createObjectBuilder().add("image", imageUrl).build();
    URL apiURL = new URL(api);
    HttpURLConnection connection = (HttpURLConnection) apiURL.openConnection();
    connection.setRequestProperty("Content-Type", "application/json");
    connection.setRequestProperty("X-Access-Token", accessToken);
    connection.setRequestMethod("POST");
    connection.setDoInput(true);
    connection.setDoOutput(true);
    byte[] body = jsonImage.toString().getBytes();
    connection.setFixedLengthStreamingMode(body.length);
    OutputStream os = connection.getOutputStream();
    os.write(body);
    os.flush();
    int httpCode = connection.getResponseCode();
    if ( httpCode == 200 ){
        JsonReader jReader = Json.createReader(connection.getInputStream());
        JsonObject jsonBody = jReader.readObject();
        System.out.println(jsonBody);
    } else {
        JsonReader jReader = Json.createReader(connection.getErrorStream());
        JsonObject jsonError = jReader.readObject();
        System.out.println(jsonError);
    }
  }
}


curl -X POST https://dev.sighthoundapi.com/v1/detections?type=face,person&faceOption=landmark,gender \
-H "Content-Type: application/json" \
-H "X-Access-Token: YOUR-CLOUD-TOKEN" \
-d '"image": "https://www.example.com/path/to/image.jpg"}'

URL and Headers

POST https://dev.sighthoundapi.com/v1/detections?type=face,person&faceOption=landmark,gender
Content-Type: application/json
X-Access-Token: Your-API-Key

Optional URL Parameters

type A comma-separated list of object categories to detect. Valid options are ‘all’, ‘face’, ‘person’. Default is ‘all’.
faceOption For type 'face', additional detections can be performed by passing comma-separated list of values. Valid options are ‘gender’ and ‘landmark’. Default is face bounding box only.

Body Parameters

image The image to analyze. This can be a URL to an image (authentication data in URL is accepted) or inline as base64 encoded data.

Result

The result is a JSON array of all detected objects and information about the processed image.

{ "image": {
    "width": 1280, "height": 960, "orientation": 1},
  "objects": [
    {"type": "person",
      "boundingBox": { "x": 363, "y": 182, "height": 778, "width": 723} },
    {"type": "face",
      "boundingBox": {"x": 508, "y": 305, "height": 406, "width": 406,},
      "attributes": {
        "gender": "male", "genderConfidence": 0.9883, "frontal": true},
      "landmarks": {
        "faceContour": [[515,447],[517,491]...[872,436]],
        "noseBridge": [[710,419],[711,441]...[712,487]],
        "noseBall": [[680,519],[696,522]...[742,518]],
        "eyebrowRight": [[736,387],[768,376]...854,394]],
        "eyebrowLeft": [[555,413],[578,391]...679,391]],
        "eyeRight": [[753,428],[774,414]...[777,432]],
        "eyeRightCenter": [[786,423]],
        "eyeLeft": [[597,435],[617,423]...[619,442]],
        "eyeLeftCenter": [[630,432]],
        "mouthOuter": [[650,590],[674,572]...[675,600]],
        "mouthInner": [[661,587],[697,580]...[697,584]]}
      }
   ]
}
objects An array of all detected objects. Each includes the type of detection results returned, face or person, and a boundingBox of the object's location in the image. The x, y, width, and height values are defined in a coordinate space with (0,0) as the top left corner of the image.
image The width, height, and orientation of the processed image. Orientation defaults to 1, else the value found in the image's Exif data and indicates that bounding boxes have been translated to match that coordinate space.

Get Support

Ask questions and share your projects in our forums or by emailing our support team.