Semantic Segmentation

Run inference on semantic segmentation models hosted on Roboflow.

cURL

Linux or MacOS

Retrieving JSON predictions for a local file called YOUR_IMAGE.jpg:

base64 YOUR_IMAGE.jpg | curl -d @- \
"https://segment.roboflow.com/your-model/42?api_key=YOUR_KEY"

Inferring on an image hosted elsewhere on the web via its URL (don't forget to URL encode it):

curl -X POST "https://segment.roboflow.com/your-model/42?\
api_key=YOUR_KEY&\
image=https%3A%2F%2Fi.imgur.com%2FPEEvqPN.png"

Windows

You will need to install curl for Windows and GNU's base64 tool for Windows. The easiest way to do this is to use the git for Windows installer which also includes the curl and base64 command line tools when you select "Use Git and optional Unix tools from the Command Prompt" during installation.

Then you can use the same commands as above.

Python

Infer on Local and Hosted Images

To install dependencies, pip install roboflow

from roboflow import Roboflow

rf = Roboflow(api_key="API_KEY")
project = rf.workspace().project("MODEL_ENDPOINT")
model = project.version(VERSION).model

# infer on a local image
print(model.predict("your_image.jpg").json())

# infer on an image hosted elsewhere
print(model.predict("URL_OF_YOUR_IMAGE").json())

# save an image annotated with your predictions
model.predict("your_image.jpg").save("prediction.jpg")

Javascript

Node.js

We're using axios to perform the POST request in this example so first run npm install axios to install the dependency.

Inferring on a Local Image

const axios = require("axios");
const fs = require("fs");

const image = fs.readFileSync("YOUR_IMAGE.jpg", {
    encoding: "base64"
});

axios({
    method: "POST",
    url: "https://segment.roboflow.com/your-model/42",
    params: {
        api_key: "YOUR_KEY"
    },
    data: image,
    headers: {
        "Content-Type": "application/x-www-form-urlencoded"
    }
})
.then(function(response) {
    console.log(response.data);
})
.catch(function(error) {
    console.log(error.message);
});

Inferring on an Image Hosted Elsewhere via URL

const axios = require("axios");

axios({
    method: "POST",
    url: "https://segment.roboflow.com/your-model/42",
    params: {
        api_key: "YOUR_KEY",
        image: "https://i.imgur.com/PEEvqPN.png"
    }
})
.then(function(response) {
    console.log(response.data);
})
.catch(function(error) {
    console.log(error.message);
});

Web

We have realtime on-device inference available via roboflow.js; see the documentation here.

Swift/iOS

Swift

Inferring on a Local Image

import UIKit

// Load Image and Convert to Base64
let image = UIImage(named: "your-image-path") // path to image to upload ex: image.jpg
let imageData = image?.jpegData(compressionQuality: 1)
let fileContent = imageData?.base64EncodedString()
let postData = fileContent!.data(using: .utf8)

// Initialize Inference Server Request with API_KEY, Model, and Model Version
var request = URLRequest(url: URL(string: "https://segment.roboflow.com/your-model/your-model-version?api_key=YOUR_APIKEY&name=YOUR_IMAGE.jpg")!,timeoutInterval: Double.infinity)
request.addValue("application/x-www-form-urlencoded", forHTTPHeaderField: "Content-Type")
request.httpMethod = "POST"
request.httpBody = postData

// Execute Post Request
URLSession.shared.dataTask(with: request, completionHandler: { data, response, error in
    
    // Parse Response to String
    guard let data = data else {
        print(String(describing: error))
        return
    }
    
    // Convert Response String to Dictionary
    do {
        let dict = try JSONSerialization.jsonObject(with: data, options: []) as? [String: Any]
    } catch {
        print(error.localizedDescription)
    }
    
    // Print String Response
    print(String(data: data, encoding: .utf8)!)
}).resume()

Objective C

Click here to request an Objective-C snippet.

Android

Kotlin

Inferring on a Local Image

import java.io.*
import java.net.HttpURLConnection
import java.net.URL
import java.nio.charset.StandardCharsets
import java.util.*

fun main() {
    // Get Image Path
    val filePath = System.getProperty("user.dir") + System.getProperty("file.separator") + "YOUR_IMAGE.jpg"
    val file = File(filePath)

    // Base 64 Encode
    val encodedFile: String
    val fileInputStreamReader = FileInputStream(file)
    val bytes = ByteArray(file.length().toInt())
    fileInputStreamReader.read(bytes)
    encodedFile = String(Base64.getEncoder().encode(bytes), StandardCharsets.US_ASCII)
    val API_KEY = "" // Your API Key
    val MODEL_ENDPOINT = "dataset/v" // Set model endpoint (Found in Dataset URL)

    // Construct the URL
    val uploadURL ="https://segment.roboflow.com/" + MODEL_ENDPOINT + "?api_key=" + API_KEY + "&name=YOUR_IMAGE.jpg";

    // Http Request
    var connection: HttpURLConnection? = null
    try {
        // Configure connection to URL
        val url = URL(uploadURL)
        connection = url.openConnection() as HttpURLConnection
        connection.requestMethod = "POST"
        connection.setRequestProperty("Content-Type",
                "application/x-www-form-urlencoded")
        connection.setRequestProperty("Content-Length",
                Integer.toString(encodedFile.toByteArray().size))
        connection.setRequestProperty("Content-Language", "en-US")
        connection.useCaches = false
        connection.doOutput = true

        //Send request
        val wr = DataOutputStream(
                connection.outputStream)
        wr.writeBytes(encodedFile)
        wr.close()

        // Get Response
        val stream = connection.inputStream
        val reader = BufferedReader(InputStreamReader(stream))
        var line: String?
        while (reader.readLine().also { line = it } != null) {
            println(line)
        }
        reader.close()
    } catch (e: Exception) {
        e.printStackTrace()
    } finally {
        connection?.disconnect()
    }
}
main()

Inferring on an Image Hosted Elsewhere via URL

import java.io.BufferedReader
import java.io.DataOutputStream
import java.io.InputStreamReader
import java.net.HttpURLConnection
import java.net.URL
import java.net.URLEncoder

fun main() {
    val imageURL = "https://i.imgur.com/PEEvqPN.png" // Replace Image URL
    val API_KEY = "" // Your API Key
    val MODEL_ENDPOINT = "dataset/v" // Set model endpoint

    // Upload URL
    val uploadURL = "https://segment.roboflow.com/" + MODEL_ENDPOINT + "?api_key=" + API_KEY + "&image=" + URLEncoder.encode(imageURL, "utf-8");

    // Http Request
    var connection: HttpURLConnection? = null
    try {
        // Configure connection to URL
        val url = URL(uploadURL)
        connection = url.openConnection() as HttpURLConnection
        connection.requestMethod = "POST"
        connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded")
        connection.setRequestProperty("Content-Length", Integer.toString(uploadURL.toByteArray().size))
        connection.setRequestProperty("Content-Language", "en-US")
        connection.useCaches = false
        connection.doOutput = true

        // Send request
        val wr = DataOutputStream(connection.outputStream)
        wr.writeBytes(uploadURL)
        wr.close()

        // Get Response
        val stream = URL(uploadURL).openStream()
        val reader = BufferedReader(InputStreamReader(stream))
        var line: String?
        while (reader.readLine().also { line = it } != null) {
            println(line)
        }
        reader.close()
    } catch (e: Exception) {
        e.printStackTrace()
    } finally {
        connection?.disconnect()
    }
}

main()

Java

Inferring on a Local Image

import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
import java.nio.charset.StandardCharsets;
import java.util.Base64;

public class InferenceLocal {
    public static void main(String[] args) throws IOException {
        // Get Image Path
        String filePath = System.getProperty("user.dir") + System.getProperty("file.separator") + "YOUR_IMAGE.jpg";
        File file = new File(filePath);

        // Base 64 Encode
        String encodedFile;
        FileInputStream fileInputStreamReader = new FileInputStream(file);
        byte[] bytes = new byte[(int) file.length()];
        fileInputStreamReader.read(bytes);
        encodedFile = new String(Base64.getEncoder().encode(bytes), StandardCharsets.US_ASCII);

        String API_KEY = ""; // Your API Key
        String MODEL_ENDPOINT = "dataset/v"; // model endpoint

        // Construct the URL
        String uploadURL = "https://segment.roboflow.com/" + MODEL_ENDPOINT + "?api_key=" + API_KEY
                + "&name=YOUR_IMAGE.jpg";

        // Http Request
        HttpURLConnection connection = null;
        try {
            // Configure connection to URL
            URL url = new URL(uploadURL);
            connection = (HttpURLConnection) url.openConnection();
            connection.setRequestMethod("POST");
            connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");

            connection.setRequestProperty("Content-Length", Integer.toString(encodedFile.getBytes().length));
            connection.setRequestProperty("Content-Language", "en-US");
            connection.setUseCaches(false);
            connection.setDoOutput(true);

            // Send request
            DataOutputStream wr = new DataOutputStream(connection.getOutputStream());
            wr.writeBytes(encodedFile);
            wr.close();

            // Get Response
            InputStream stream = connection.getInputStream();
            BufferedReader reader = new BufferedReader(new InputStreamReader(stream));
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
            reader.close();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (connection != null) {
                connection.disconnect();
            }
        }

    }

}

Inferring on an Image Hosted Elsewhere via URL

import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;

public class InferenceHosted {
    public static void main(String[] args) {
        String imageURL = "https://i.imgur.com/PEEvqPN.png"; // Replace Image URL
        String API_KEY = ""; // Your API Key
        String MODEL_ENDPOINT = "dataset/v"; // model endpoint

        // Upload URL
        String uploadURL = "https://segment.roboflow.com/" + MODEL_ENDPOINT + "?api_key=" + API_KEY + "&image="
                + URLEncoder.encode(imageURL, StandardCharsets.UTF_8);

        // Http Request
        HttpURLConnection connection = null;
        try {
            // Configure connection to URL
            URL url = new URL(uploadURL);
            connection = (HttpURLConnection) url.openConnection();
            connection.setRequestMethod("POST");
            connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");

            connection.setRequestProperty("Content-Length", Integer.toString(uploadURL.getBytes().length));
            connection.setRequestProperty("Content-Language", "en-US");
            connection.setUseCaches(false);
            connection.setDoOutput(true);

            // Send request
            DataOutputStream wr = new DataOutputStream(connection.getOutputStream());
            wr.writeBytes(uploadURL);
            wr.close();

            // Get Response
            InputStream stream = new URL(uploadURL).openStream();
            BufferedReader reader = new BufferedReader(new InputStreamReader(stream));
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
            reader.close();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (connection != null) {
                connection.disconnect();
            }
        }
    }
}

Ruby

Gemfile

Gemfile

source "https://rubygems.org"

gem "httparty", "~> 0.18.1"
gem "base64", "~> 0.1.0"
gem "cgi", "~> 0.2.1"

Gemfile.lock

Gemfile.lock

GEM
  remote: https://rubygems.org/
  specs:
    base64 (0.1.0)
    cgi (0.2.1)
    httparty (0.18.1)
      mime-types (~> 3.0)
      multi_xml (>= 0.5.2)
    mime-types (3.3.1)
      mime-types-data (~> 3.2015)
    mime-types-data (3.2021.0225)
    multi_xml (0.6.0)

PLATFORMS
  x64-mingw32
  x86_64-linux

DEPENDENCIES
  base64 (~> 0.1.0)
  cgi (~> 0.2.1)
  httparty (~> 0.18.1)

BUNDLED WITH
   2.2.15

Inferring on a Local Image

require 'base64'
require 'httparty'

encoded = Base64.encode64(File.open("YOUR_IMAGE.jpg", "rb").read)
model_endpoint = "dataset/v" # Set model endpoint
api_key = "" # Your API KEY Here

params = "?api_key=" + api_key
+ "&name=YOUR_IMAGE.jpg"

response = HTTParty.post(
    "https://segment.roboflow.com/" + model_endpoint + params,
    body: encoded, 
    headers: {
    'Content-Type' => 'application/x-www-form-urlencoded',
    'charset' => 'utf-8'
  })

  puts response

 

Inferring on an Image Hosted Elsewhere via URL

require 'httparty'
require 'cgi'

model_endpoint = "dataset/v" # Set model endpoint
api_key = "" # Your API KEY Here
img_url = "https://i.imgur.com/PEEvqPN.png" # Construct the URL

img_url = CGI::escape(img_url)

params =  "?api_key=" + api_key + "&image=" + img_url

response = HTTParty.post(
    "https://segment.roboflow.com/" + model_endpoint + params,
    headers: {
    'Content-Type' => 'application/x-www-form-urlencoded',
    'charset' => 'utf-8'
  })

puts response

PHP

Inferring on a Local Image

<?php

// Base 64 Encode Image
$data = base64_encode(file_get_contents("YOUR_IMAGE.jpg"));

$api_key = ""; // Set API Key
$model_endpoint = "dataset/v"; // Set model endpoint (Found in Dataset URL)

// URL for Http Request
$url = "https://segment.roboflow.com/" . $model_endpoint
. "?api_key=" . $api_key
. "&name=YOUR_IMAGE.jpg";

// Setup + Send Http request
$options = array(
  'http' => array (
    'header' => "Content-type: application/x-www-form-urlencoded\r\n",
    'method'  => 'POST',
    'content' => $data
  ));

$context  = stream_context_create($options);
$result = file_get_contents($url, false, $context);
echo $result;
?>

Inferring on an Image Hosted Elsewhere via URL

<?php

$api_key = ""; // Set API Key
$model_endpoint = "dataset/v"; // Set model endpoint (Found in Dataset URL)
$img_url = "https://i.imgur.com/PEEvqPN.png";

// URL for Http Request
$url =  "https://segment.roboflow.com/" . $model_endpoint
. "?api_key=" . $api_key
. "&image=" . urlencode($img_url);

// Setup + Send Http request
$options = array(
  'http' => array (
    'header' => "Content-type: application/x-www-form-urlencoded\r\n",
    'method'  => 'POST'
  ));

$context  = stream_context_create($options);
$result = file_get_contents($url, false, $context);
echo $result;
?>

Go

Inferring on a Local Image

package main

import (
    "bufio"
    "encoding/base64"
    "fmt"
    "io/ioutil"
    "os"
	"net/http"
	"strings"
)

func main() {
	api_key := ""  // Your API Key
	model_endpoint := "dataset/v" // Set model endpoint

    // Open file on disk.
    f, _ := os.Open("YOUR_IMAGE.jpg")

    // Read entire JPG into byte slice.
    reader := bufio.NewReader(f)
    content, _ := ioutil.ReadAll(reader)

    // Encode as base64.
    data := base64.StdEncoding.EncodeToString(content)
	uploadURL := "https://segment.roboflow.com/" + model_endpoint + "?api_key=" + api_key + "&name=YOUR_IMAGE.jpg"

	req, _ := http.NewRequest("POST", uploadURL, strings.NewReader(data))
    req.Header.Set("Accept", "application/json")

    client := &http.Client{}
    resp, _ := client.Do(req)
    defer resp.Body.Close()

   	bytes, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(string(bytes))

}

Inferring on an Image Hosted Elsewhere via URL

package main

import (
    "fmt"
	"net/http"
	"net/url"
  "io/ioutil"
)

func main() {
	api_key := ""  // Your API Key
	model_endpoint := "dataset/v" // Set model endpoint
	img_url := "https://i.ibb.co/jzr27x0/YOUR-IMAGE.jpg"


	uploadURL := "https://segment.roboflow.com/" + model_endpoint + "?api_key=" + api_key + "&image=" + url.QueryEscape(img_url)

	req, _ := http.NewRequest("POST", uploadURL, nil)
    req.Header.Set("Accept", "application/json")

    client := &http.Client{}
    resp, _ := client.Do(req)
    defer resp.Body.Close()

   	bytes, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(string(bytes))


}

.NET

Inferring on a Local Image

using System;
using System.IO;
using System.Net;
using System.Text;

namespace InferenceLocal
{
    class InferenceLocal
    {

        static void Main(string[] args)
        {
            byte[] imageArray = System.IO.File.ReadAllBytes(@"YOUR_IMAGE.jpg");
            string encoded = Convert.ToBase64String(imageArray);
            byte[] data = Encoding.ASCII.GetBytes(encoded);
            string API_KEY = ""; // Your API Key
            string MODEL_ENDPOINT = "dataset/v"; // Set model endpoint

            // Construct the URL
            string uploadURL =
                    "https://segment.roboflow.com/" + MODEL_ENDPOINT + "?api_key=" + API_KEY
                + "&name=YOUR_IMAGE.jpg";

            // Service Request Config
            ServicePointManager.Expect100Continue = true;
            ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;

            // Configure Request
            WebRequest request = WebRequest.Create(uploadURL);
            request.Method = "POST";
            request.ContentType = "application/x-www-form-urlencoded";
            request.ContentLength = data.Length;

            // Write Data
            using (Stream stream = request.GetRequestStream())
            {
                stream.Write(data, 0, data.Length);
            }

            // Get Response
            string responseContent = null;
            using (WebResponse response = request.GetResponse())
            {
                using (Stream stream = response.GetResponseStream())
                {
                    using (StreamReader sr99 = new StreamReader(stream))
                    {
                        responseContent = sr99.ReadToEnd();
                    }
                }
            }

            Console.WriteLine(responseContent);

        }
    }
}

Inferring on an Image Hosted Elsewhere via URL

using System;
using System.IO;
using System.Net;
using System.Web;

namespace InferenceHosted
{
    class InferenceHosted
    {
        static void Main(string[] args)
        {
            string API_KEY = ""; // Your API Key
            string imageURL = "https://i.ibb.co/jzr27x0/YOUR-IMAGE.jpg";
            string MODEL_ENDPOINT = "dataset/v"; // Set model endpoint

            // Construct the URL
            string uploadURL =
                    "https://segment.roboflow.com/" + MODEL_ENDPOINT
                    + "?api_key=" + API_KEY
                    + "&image=" + HttpUtility.UrlEncode(imageURL);

            // Service Point Config
            ServicePointManager.Expect100Continue = true;
            ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;

            // Configure Http Request
            WebRequest request = WebRequest.Create(uploadURL);
            request.Method = "POST";
            request.ContentType = "application/x-www-form-urlencoded";
            request.ContentLength = 0;

            // Get Response
            string responseContent = null;
            using (WebResponse response = request.GetResponse())
            {
                using (Stream stream = response.GetResponseStream())
                {
                    using (StreamReader sr99 = new StreamReader(stream))
                    {
                        responseContent = sr99.ReadToEnd();
                    }
                }
            }

            Console.WriteLine(responseContent);

        }
    }
}

Elixer

We are adding code snippets as they are requested by users. If you'd like to integrate the inference API into your Elixir app, please click here to record your upvote.

Response Object Format

The hosted API inference route returns a JSON object containing an array of predictions. Each prediction has the following properties:

• segmentation_mask = base64 encoded single channel image with dimensions equal to the input image where each pixel value corresponds to a class ID

• class_map = object that maps class IDs to class names

• image = an object with the input image dimensions

  • height = height of the input image in number of pixels

  • width = width of the input image in number of pixels

// an example JSON object
{
    "segmentation_mask": "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",
    "class_map": {
        "0": " background",
        "1": " object"
    },
    "image": {
        "width": 1232,
        "height": 821
    }
}

API Reference

Using the Inference API

POST https://segment.roboflow.com/:datasetSlug/:versionNumber

You can POST a base64 encoded image directly to your model endpoint. Or you can pass a URL as the image parameter in the query string if your image is already hosted elsewhere.

Path Parameters

Name	Type	Description
datasetSlug	string	The url-safe version of the dataset name. You can find it in the web UI by looking at the URL on the main project view or by clicking the "Get curl command" button in the train results section of your dataset version after training your model.
version	number	The version number identifying the version of of your dataset

Query Parameters

Name	Type	Description
image	string	URL of the image to add. Use if your image is hosted elsewhere. (Required when you don't POST a base64 encoded image in the request body.) Note: don't forget to URL-encode it.
confidence	number	A threshold for the returned predictions on a scale of 0-100. A lower number will return more predictions. A higher number will return fewer high-certainty predictions. Default: 50
api_key	string	Your API key (obtained via your workspace API settings page)

Request Body

Name	Type	Description
	string	A base64 encoded image. (Required when you don't pass an image URL in the query parameters).

200 JSON format predictions. (x,y) are the box's center pixel coordinates.

{
    "segmentation_mask": "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",
    "class_map": {
        "0": " background",
        "1": " object"
    },
    "image": {
        "width": 1232,
        "height": 821
    }
}

403 If your api_key is not authorized to access the model.

{
    "Message": "User is not authorized to access this resource"
}