Retrieving Results

curl --request GET \
  --url https://api.sutro.sh/jobs/{job_id}/results \
  --header 'Authorization: <authorization>'

const options = {method: 'GET', headers: {Authorization: '<authorization>'}};

fetch('https://api.sutro.sh/jobs/{job_id}/results', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.sutro.sh/jobs/{job_id}/results",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "Authorization: <authorization>"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

package main

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

func main() {

	url := "https://api.sutro.sh/jobs/{job_id}/results"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("Authorization", "<authorization>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}

require 'uri'
require 'net/http'

url = URI("https://api.sutro.sh/jobs/{job_id}/results")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Authorization"] = '<authorization>'

response = http.request(request)
puts response.read_body

{
    "outputs": [
        "The capital of France is Paris.",
        "Quantum computing uses quantum mechanics principles to process information in ways that classical computers cannot..."
    ],
    "inputs": [
        "What is the capital of France?",
        "Explain quantum computing in simple terms"
    ],
    "cumulative_logprobs": [-0.5234, -1.2456]
}

inputs,job-abc123,cumulative_logprobs
"What is the capital of France?","The capital of France is Paris.",-0.5234
"Explain quantum computing in simple terms","Quantum computing uses quantum mechanics principles to process
information in ways that classical computers cannot...",-1.2456

Same structure as CSV, but with preserved data types:
- inputs (string)
- job-abc123 (string or JSON string)
- cumulative_logprobs (float64)

Binary format optimized for data analysis tools (pandas, polars, duckdb)
A user-provided ID column appears before the job output when configured.

GET

jobs

{job_id}

results

Retrieving Results

curl --request GET \
  --url https://api.sutro.sh/jobs/{job_id}/results \
  --header 'Authorization: <authorization>'

const options = {method: 'GET', headers: {Authorization: '<authorization>'}};

fetch('https://api.sutro.sh/jobs/{job_id}/results', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.sutro.sh/jobs/{job_id}/results",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "Authorization: <authorization>"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

package main

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

func main() {

	url := "https://api.sutro.sh/jobs/{job_id}/results"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("Authorization", "<authorization>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}

require 'uri'
require 'net/http'

url = URI("https://api.sutro.sh/jobs/{job_id}/results")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Authorization"] = '<authorization>'

response = http.request(request)
puts response.read_body

{
    "outputs": [
        "The capital of France is Paris.",
        "Quantum computing uses quantum mechanics principles to process information in ways that classical computers cannot..."
    ],
    "inputs": [
        "What is the capital of France?",
        "Explain quantum computing in simple terms"
    ],
    "cumulative_logprobs": [-0.5234, -1.2456]
}

inputs,job-abc123,cumulative_logprobs
"What is the capital of France?","The capital of France is Paris.",-0.5234
"Explain quantum computing in simple terms","Quantum computing uses quantum mechanics principles to process
information in ways that classical computers cannot...",-1.2456

Same structure as CSV, but with preserved data types:
- inputs (string)
- job-abc123 (string or JSON string)
- cumulative_logprobs (float64)

Binary format optimized for data analysis tools (pandas, polars, duckdb)
A user-provided ID column appears before the job output when configured.

Using the API directly is not recommended for most users. Instead, we recommend using the Python SDK.

Download the complete results of a batch inference job. Results can be downloaded in multiple formats optimized for different use cases. If the job was submitted with id_column_name, the user-provided ID column is always included in the result, even when include_inputs is false.

Path Parameters

string

required

The job_id returned when you submitted the batch inference job

Query Parameters

enum

required

The format to download results in:

csv - CSV file (zipped for compression)
parquet - Parquet file
json - JSON object

boolean

default:"false"

Whether to include the input prompts in the results

boolean

default:"false"

Whether to include the cumulative log probabilities in the results

Headers

string

required

Your Sutro API key using Key authentication scheme.Format: Key YOUR_API_KEYExample: Authorization: Key sk_abc123...

Response

Returns a downloadable file in the requested format.

Parquet

Returns a single Parquet file
Recommended for large datasets
Includes the user-provided ID column when configured for the job

CSV

Returns a ZIP file containing a CSV
File is compressed for efficient transfer
Column names may include the user-provided ID column, inputs (if requested), {job_id} outputs, and cumulative_logprobs (if requested)

JSON

Returns a JSON object
Best for smaller datasets

Structured Outputs

When using structured outputs (by providing a json_schema when creating the job), the outputs will be JSON strings that conform to your specified schema.

Standard Models

For non-reasoning models, the output will be a JSON string following your schema:

{
  "outputs": [
    "{\"name\": \"John Doe\", \"age\": 30, \"email\": \"[email protected]\"}",
    "{\"name\": \"Jane Smith\", \"age\": 25, \"email\": \"[email protected]\"}"
  ]
}

Reasoning Models

For reasoning models (like o1), the output includes both the structured content and the reasoning process:

{
  "outputs": [
    "{\"content\": {\"name\": \"John Doe\", \"age\": 30}, \"reasoning_content\": \"First, I identified the name from the text...\"}",
    "{\"content\": {\"name\": \"Jane Smith\", \"age\": 25}, \"reasoning_content\": \"I analyzed the passage and extracted...\"}"
  ]
}

The output structure for reasoning models:

content: The structured output following your JSON schema (can be a text string or JSON string containing an object matching your schema)
reasoning_content: The model’s step-by-step reasoning process (string)

Currently, when using structured outputs or reasoning models, one will need to run json.loads or similar on each output JSON, ie json.loads(outputs[0]) to transform from a string to a dict (or equivalent in other languages).

{
    "outputs": [
        "The capital of France is Paris.",
        "Quantum computing uses quantum mechanics principles to process information in ways that classical computers cannot..."
    ],
    "inputs": [
        "What is the capital of France?",
        "Explain quantum computing in simple terms"
    ],
    "cumulative_logprobs": [-0.5234, -1.2456]
}

inputs,job-abc123,cumulative_logprobs
"What is the capital of France?","The capital of France is Paris.",-0.5234
"Explain quantum computing in simple terms","Quantum computing uses quantum mechanics principles to process
information in ways that classical computers cannot...",-1.2456

Same structure as CSV, but with preserved data types:
- inputs (string)
- job-abc123 (string or JSON string)
- cumulative_logprobs (float64)

Binary format optimized for data analysis tools (pandas, polars, duckdb)
A user-provided ID column appears before the job output when configured.

Code Examples

import requests

response = requests.get(
    'https://api.sutro.sh/jobs/job_12345/results',
    headers={
        'Authorization': 'Key YOUR_SUTRO_API_KEY'
    },
    params={
        'format': 'csv',
        'include_inputs': True,
        'include_cumulative_logprobs': False
    }
)

# Save the zip file
with open('results.zip', 'wb') as f:
    f.write(response.content)

# Extract and read with pandas
import zipfile
import pandas as pd

with zipfile.ZipFile('results.zip') as z:
    csv_filename = z.namelist()[0]
    with z.open(csv_filename) as csv_file:
        df = pd.read_csv(csv_file)
        print(df.head())

import requests
import polars as pl

response = requests.get(
    'https://api.sutro.sh/jobs/job_12345/results',
    headers={
        'Authorization': 'Key YOUR_SUTRO_API_KEY'
    },
    params={
        'format': 'parquet',
        'include_inputs': True
    }
)

# Save and read with Polars
with open('results.parquet', 'wb') as f:
    f.write(response.content)

df = pl.read_parquet('results.parquet')
print(df.head())

import requests

response = requests.get(
    'https://api.sutro.sh/jobs/job_12345/results',
    headers={
        'Authorization': 'Key YOUR_SUTRO_API_KEY'
    },
    params={
        'format': 'json',
        'include_inputs': True,
        'include_cumulative_logprobs': False
    }
)

result = response.json()

# Access outputs and inputs
for i, (input_text, output_text) in enumerate(zip(result['inputs'], result['outputs'])):
    print(f"Input {i + 1}: {input_text}")
    print(f"Output {i + 1}: {output_text}")
    print("---")

curl -X GET "https://api.sutro.sh/jobs/job_12345/results?format=csv&include_inputs=true" \
-H "Authorization: Key YOUR_SUTRO_API_KEY" \
-o results.zip

curl -X GET "https://api.sutro.sh/jobs/job_12345/results?format=json&include_inputs=true" \
-H "Authorization: Key YOUR_SUTRO_API_KEY"

Notes

Results can only be retrieved for jobs that have completed successfully
The order of results matches the order of the original inputs
CSV format: outputs are in a column named after the job_id
Parquet format uses Snappy compression internally
For very large datasets, request a resumable Parquet results download URL
CSV files are automatically zipped to reduce download size

Functions API

Batch API

Retrieving Results

Path Parameters

Query Parameters

Headers

Response

Parquet

CSV

JSON

Structured Outputs

Standard Models

Reasoning Models

Code Examples

Notes

​Path Parameters

​Query Parameters

​Headers

​Response

​Parquet

​CSV

​JSON

​Structured Outputs

​Standard Models

​Reasoning Models

​Code Examples

​Notes

Path Parameters

Query Parameters

Headers

Response

Parquet

CSV

JSON

Structured Outputs

Standard Models

Reasoning Models

Code Examples

Notes