The Ag-Analytics® TillageAI tillage identification model exposed via API, uses mutlispectral harmonized Landsat/Sentinel data, as well as other data sources and artificial intelligence algorithms to determine whether a field has been tilled or not, and at what date of the year.

a) Tillage Identification

Service Overview

Similar to the crop identification models, there is also great value in being able to identify where tillage and no-till (a conservation practice) are being used, and to be able to construct histories.

The Ag-Analytics® TillageAI API provides the service in which a user may point to any field in any year, and be able to infer:

1) Was the field tilled or not
2) If tilled, what date it was tilled
3) If tilled, depth and type of tillage

This API uses NDVI imagery, location, weather, and other available data to "predict", or determine, if a field has been tilled.

The Tillage Model is a “backfilling model”, meaning that it can determine whether a field was tilled in the past, rather than provide prediction as to whether a field will be tilled. The model uses a seven-week window of satellite imagery, so as long as the date requested is more than three weeks prior to the current date (i.e., if today is Monday of the 20th week of the year, the latest request that can be made is for the 16th week.).

Example of Tillage Identification


Model Specifications

The Tillage Model predicts tillage using one of two models that have been trained on approximately 2,000 tillage records from real farming operations. The dataset of tillage operations is used for ground truthing to create a verification label. Without the ground-truth data, there would be no way to tell the model that it predicted tillage correctly, and no way to determine the accuracy of a trained model. The models are trained on three categories of data. The first is the location of the field geospatially. Tillage practices may vary in different areas of the country, so the addition of geospatial coordinates can illuminate some of these relationships. The second is the week of the year. In combination with the location of the field, the week of the year can help determine whether a field is able to be tilled at a given time of year. For example, tilling in Florida happens at a different time than in Minnesota. Third, remote sensing satellite imagery is used to find patterns in the ground reflectance that happen before, during, and after tillage. The temporal reflectance patterns are the primary driver for the tillage model in determining whether the field has been tilled. Currently, the model uses a seven-week window of satellite imagery.

Request Parameters

Parameter Data Type Required? Default Options Description
SHAPE Geometry, file/text Yes - Geojson Desired area-of-interest, see Fig. 1 for example.
ModelType Text String No Neural Network "NN" (Neural Network)
"TREE" (Decision Tree)
Type of model to use for prediction. Default is "NN". Not necessary to specify for most cases.
TillageStartDate Text Yes - Date String
The date that tillage began. Must be in years {2014, 2015, 2016, 2017, 2018}. For 2019,
must be more than 3 weeks prior to the current date.Ex. "04/23/2017"
ScalarVariables Dictionary Yes - - Wrapper dictionary for any variables that need to be included along with ModelType and SHAPE.
Does not have a value itself. Please see sample request for clarification.

Response Parameters

Parameter Data Type Description
feature_averages Dictionary Average value of each input used to predict tillage.
raster_filename String URL to use in GET request to retrieve predicted raster file.
rasterinfo List of Dictionaries Container for the features and metadata information for the raster.
attributes Dictionary Container for specific features regarding the tillage prediction raster.
CellSize List Size of a single cell in the raster in degrees. (0.0001, -0.0001) roughly corresponds to an 8 meter by 8
meter square on the Earth’s equator. (i.e., 0.0001 degrees ~= 8 meters)
CoordinateSystem String Information about the coordinate system being used for calculations.
Extent String Specifies the left bottom corner and right top corner in longitude and latitude respectively.
Legend List of Dictionaries List of the metadata features for the areas of the field that returned as till or no-till or both.
Area Float Specifies the number of acres that were till or no-till for a given field.
AreaPercent String Specifies a percentage of the field that returned either till or no-till. For example, if 50% of the field is “till”,
then Area is 50%.
Count Integer Number of pixels that returned as till or no-till. Used to calculate area.
CountAllPixels Integer Total number of pixels that make up the field in the predicted tillage raster.
Till String Specifies whether the given section (or entire area) of the field has been tilled. Returns “Yes” for tillage
and “No” for tillage not detected.
Value Integer Binary value for tillage detected or not. Tillage detected = 1, Tillage not detected = 0.
color String Color that can be used to display the feature when plotting in a GIS application. (Hexadecimal)
pngb64 String PNG image of the tillage raster encoded as base64. Actual raster file can be obtained with a
GET request to the service.

Parameter Examples






Call API


Request URL

Request headers

  • (optional)

Request body

"ModelType": "RF",
"SHAPE": "{\"type\":\"Feature\",\"geometry\":{\"type\":\"Polygon\",\"coordinates\":[ [ [-85.530165756639363, 41.003585131948597], [-85.520434643189319, 41.003807344585127], [-85.520353401853086, 40.999164864997709], [-85.523662529524572, 40.998736874798666], [-85.522491522109163, 40.997877961142841], [-85.52301570506603, 40.997135046630873], [-85.529932360326256, 40.996987366356251], [-85.530165756639363, 41.003585131948597] ] ]},\"properties\":{\"OBJECTID\":5102679,\"CALCACRES\":145.08999634,\"CALCACRES2\":null},\"id\":5102679}",
"ScalarVariables": {
"TillageStartDate": "04-23-2018"


200 OK


Code samples


curl -v -X POST "https://ag-analytics.azure-api.net/tillage-model/"
-H "Content-Type: application/json"

--data-ascii "{body}" 
using System;
using System.Net.Http.Headers;
using System.Text;
using System.Net.Http;
using System.Web;

namespace CSHttpClientSample
    static class Program
        static void Main()
            Console.WriteLine("Hit ENTER to exit...");
        static async void MakeRequest()
            var client = new HttpClient();
            var queryString = HttpUtility.ParseQueryString(string.Empty);

            // Request headers

            var uri = "https://ag-analytics.azure-api.net/tillage-model/?" + queryString;

            HttpResponseMessage response;

            // Request body
            byte[] byteData = Encoding.UTF8.GetBytes("{body}");

            using (var content = new ByteArrayContent(byteData))
               content.Headers.ContentType = new MediaTypeHeaderValue("< your content type, i.e. application/json >");
               response = await client.PostAsync(uri, content);

// // This sample uses the Apache HTTP client from HTTP Components (http://hc.apache.org/httpcomponents-client-ga/)
import java.net.URI;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.utils.URIBuilder;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;

public class JavaSample 
    public static void main(String[] args) 
        HttpClient httpclient = HttpClients.createDefault();

            URIBuilder builder = new URIBuilder("https://ag-analytics.azure-api.net/tillage-model/");

            URI uri = builder.build();
            HttpPost request = new HttpPost(uri);
            request.setHeader("Content-Type", "application/json");

            // Request body
            StringEntity reqEntity = new StringEntity("{body}");

            HttpResponse response = httpclient.execute(request);
            HttpEntity entity = response.getEntity();

            if (entity != null) 
        catch (Exception e)

<!DOCTYPE html>
    <script src="http://ajax.googleapis.com/ajax/libs/jquery/1.9.0/jquery.min.js"></script>

<script type="text/javascript">
    $(function() {
        var params = {
            // Request parameters
            url: "https://ag-analytics.azure-api.net/tillage-model/?" + $.param(params),
            beforeSend: function(xhrObj){
                // Request headers
            type: "POST",
            // Request body
            data: "{body}",
        .done(function(data) {
        .fail(function() {
#import <Foundation/Foundation.h>

int main(int argc, const char * argv[])
    NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
    NSString* path = @"https://ag-analytics.azure-api.net/tillage-model/";
    NSArray* array = @[
                         // Request parameters
    NSString* string = [array componentsJoinedByString:@"&"];
    path = [path stringByAppendingFormat:@"?%@", string];

    NSLog(@"%@", path);

    NSMutableURLRequest* _request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:path]];
    [_request setHTTPMethod:@"POST"];
    // Request headers
    [_request setValue:@"application/json" forHTTPHeaderField:@"Content-Type"];
    // Request body
    [_request setHTTPBody:[@"{body}" dataUsingEncoding:NSUTF8StringEncoding]];
    NSURLResponse *response = nil;
    NSError *error = nil;
    NSData* _connectionData = [NSURLConnection sendSynchronousRequest:_request returningResponse:&response error:&error];

    if (nil != error)
        NSLog(@"Error: %@", error);
        NSError* error = nil;
        NSMutableDictionary* json = nil;
        NSString* dataString = [[NSString alloc] initWithData:_connectionData encoding:NSUTF8StringEncoding];
        NSLog(@"%@", dataString);
        if (nil != _connectionData)
            json = [NSJSONSerialization JSONObjectWithData:_connectionData options:NSJSONReadingMutableContainers error:&error];
        if (error || !json)
            NSLog(@"Could not parse loaded json with error:%@", error);
        NSLog(@"%@", json);
        _connectionData = nil;
    [pool drain];

    return 0;
// This sample uses the Apache HTTP client from HTTP Components (http://hc.apache.org/httpcomponents-client-ga/)
require_once 'HTTP/Request2.php';

$request = new Http_Request2('https://ag-analytics.azure-api.net/tillage-model/');
$url = $request->getUrl();

$headers = array(
    // Request headers
    'Content-Type' => 'application/json',


$parameters = array(
    // Request parameters



// Request body

    $response = $request->send();
    echo $response->getBody();
catch (HttpException $ex)
    echo $ex;

########### Python 2.7 #############
import httplib, urllib, base64

headers = {
    # Request headers
    'Content-Type': 'application/json',

params = urllib.urlencode({

    conn = httplib.HTTPSConnection('ag-analytics.azure-api.net')
    conn.request("POST", "/tillage-model/?%s" % params, "{body}", headers)
    response = conn.getresponse()
    data = response.read()
except Exception as e:
    print("[Errno {0}] {1}".format(e.errno, e.strerror))


########### Python 3.2 #############
import http.client, urllib.request, urllib.parse, urllib.error, base64

headers = {
    # Request headers
    'Content-Type': 'application/json',

params = urllib.parse.urlencode({

    conn = http.client.HTTPSConnection('ag-analytics.azure-api.net')
    conn.request("POST", "/tillage-model/?%s" % params, "{body}", headers)
    response = conn.getresponse()
    data = response.read()
except Exception as e:
    print("[Errno {0}] {1}".format(e.errno, e.strerror))

require 'net/http'

uri = URI('https://ag-analytics.azure-api.net/tillage-model/')

request = Net::HTTP::Post.new(uri.request_uri)
# Request headers
request['Content-Type'] = 'application/json'
# Request body
request.body = "{body}"

response = Net::HTTP.start(uri.host, uri.port, :use_ssl => uri.scheme == 'https') do |http|

puts response.body