> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.runtype.com/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.runtype.com/_mcp/server.

# Submit eval

POST https://api.runtype.com/v1/eval/submit
Content-Type: application/json

Submit a flow or agent eval. Hosted targets support overrides and multi-model requests; delegated external agents support one baseline config without overrides and not /eval/stream.

Reference: https://docs.runtype.com/api-reference/runtype-api/evals/submit-eval

## Authentication

- `Authorization` header (bearer token, required) — API key or Clerk session token

## Servers

- `https://api.runtype.com` (Production, default)
- `https://api.runtype-staging.com` (Staging)

## Request

### Body (application/json)

This endpoint expects an object.

- `agent` (V1EvalSubmitPostRequestBodyContentApplicationJsonSchemaAgent, optional) — Version selector for an agentId target. Supply at most one of alias or versionId; the run resolves it once and every case executes that version.
- `evalConfig` (EvalConfigRequest, optional)
- `evalConfigs` (list of EvalConfigRequest, optional)
- `inputs` (map from string to any, optional, nullable) — Flow input variables applied to every record execution, as on POST /batch/flow: they override same-named record metadata at the top level and leave _record.metadata unchanged. Flow targets only.

## Response

### 200

Eval submitted

- `Evals_submitEval_Response_200`
  - EvalsSubmitEvalResponse2000
  - EvalsSubmitEvalResponse2001

## Errors

### 400 Bad Request Error

Invalid request

- `error` (string, required)
- `code` (string, optional) — Stable error code. `insufficient_scope` marks an API key that lacks a scope this request needs.
- `details` (list of ErrorDetailsItems, optional)
- `requiredScopes` (list of string, optional) — On `insufficient_scope`: every API key scope this request needs.

### 401 Unauthorized Error

Unauthorized

- `error` (string, required)
- `code` (string, optional) — Stable error code. `insufficient_scope` marks an API key that lacks a scope this request needs.
- `details` (list of ErrorDetailsItems, optional)
- `requiredScopes` (list of string, optional) — On `insufficient_scope`: every API key scope this request needs.

### 402 Payment Required Error

Limit exceeded

- `code` (string, required) — Stable error code. DAILY_EVAL_LIMIT: the daily eval count of the plan is used up; retry after `stats.resetsAt`. SPEND_LIMIT_EXCEEDED: the monthly spend cap is reached. CLAUDE_MANAGED_AGENTS_DENIED: the account cannot evaluate a Claude Managed agent.
- `error` (string, required)
- `message` (string, required) — Human-readable reason, including the limit and when it resets.
- `details` (list of EvalQuotaExceededErrorDetailsItems, optional)
- `requiredScopes` (list of string, optional) — On `insufficient_scope`: every API key scope this request needs.
- `stats` (EvalQuotaExceededErrorStats, optional) — Daily eval usage at the moment of a DAILY_EVAL_LIMIT or SPEND_LIMIT_EXCEEDED refusal.

### 403 Forbidden Error

Forbidden

- `error` (string, required)
- `code` (string, optional) — Stable error code. `insufficient_scope` marks an API key that lacks a scope this request needs.
- `details` (list of ErrorDetailsItems, optional)
- `requiredScopes` (list of string, optional) — On `insufficient_scope`: every API key scope this request needs.

### 422 Unprocessable Entity Error

The target cannot run: RUNTIME_LANE_INELIGIBLE (with `reasons`) for a flow, or flow plus eval overrides, the batch host cannot run, before any eval quota is reserved; or an unsupported agent target.

- `SubmitEvalRequestUnprocessableEntityError`
  - EvalLaneRefusalError: EvalLaneRefusalError
  - Error: Error

### 500 Internal Server Error

Internal server error

- `code` (string, required) — Stable error code: `INTERNAL_ERROR` unless the route documents its own.
- `error` (string, required)
- `details` (list of InternalErrorDetailsItems, optional)
- `requiredScopes` (list of string, optional) — On `insufficient_scope`: every API key scope this request needs.
- `message` (string, optional) — Plain-language guidance: retry, then contact support with the `requestId`.
- `requestId` (string, optional) — The `X-Runtype-Request-ID` of the failed request, for support.

### 503 Service Unavailable Error

Database temporarily unavailable; nothing was read or written. Retry after the `Retry-After` interval (seconds).

- `code` (enum, required) — Stable error code. `insufficient_scope` marks an API key that lacks a scope this request needs.
  - Allowed values: `DATABASE_UNAVAILABLE`
- `error` (string, required)
- `details` (list of DatabaseUnavailableErrorDetailsItems, optional)
- `requiredScopes` (list of string, optional) — On `insufficient_scope`: every API key scope this request needs.
- `requestId` (string, optional) — The `X-Runtype-Request-ID` of the failed request, for support.

## Types

### V1EvalSubmitPostRequestBodyContentApplicationJsonSchemaAgent

Version selector for an agentId target. Supply at most one of alias or versionId; the run resolves it once and every case executes that version.

- `alias` (string, optional) — Run whichever version this release alias currently points at. Resolved once for the whole run.
- `versionId` (string, optional) — Run this exact immutable version snapshot.

### EvalConfigRequest

- `evalConfigId` (string, optional)
- `evalName` (string, optional)
- `overrides` (EvalOverrides, optional) — Canonical eval override field. Replaces `stepOverrides` (and its `"*"` key), `claudeManagedOverride` and `advisorOverride`; setting both spellings of one channel is a 400.

### EvalsSubmitEvalResponse2000

- `evalGroupId` (string, required)
- `submissions` (list of V1EvalSubmitPostResponsesContentApplicationJsonSchemaOneOf0SubmissionsItems, required)
- `totalEvals` (integer, required)

### EvalsSubmitEvalResponse2001

- `batchExecutionId` (string, required)
- `status` (string, required)

### ErrorDetailsItems

- `message` (string, required)
- `code` (string, optional) — Stable Runtype validation code (e.g. MISSING_REQUIRED_FIELD, INVALID_ENUM).
- `path` (string, optional) — Dotted JSON path to the offending field.
- `suggestion` (string, optional) — Actionable hint (allowed values, accepted range, …).

### EvalQuotaExceededErrorDetailsItems

- `message` (string, required)
- `code` (string, optional) — Stable Runtype validation code (e.g. MISSING_REQUIRED_FIELD, INVALID_ENUM).
- `path` (string, optional) — Dotted JSON path to the offending field.
- `suggestion` (string, optional) — Actionable hint (allowed values, accepted range, …).

### EvalQuotaExceededErrorStats

Daily eval usage at the moment of a DAILY_EVAL_LIMIT or SPEND_LIMIT_EXCEEDED refusal.

- `evalLimit` (integer, required) — Daily eval limit; -1 means unlimited.
- `evalsUsed` (integer, required)
- `isAtLimit` (boolean, required)
- `remaining` (double, required, nullable)
- `resetsAt` (string, required) — ISO 8601 instant the daily count resets (midnight UTC).

### EvalLaneRefusalError

- `code` (enum, required) — The flow uses capabilities the batch host cannot run.
  - Allowed values: `RUNTIME_LANE_INELIGIBLE`
- `error` (string, required)
- `reasons` (list of string, required) — Stable reason codes: `ineligible:*` capabilities (e.g. `ineligible:wait-until`), or `eval-override:*` for an eval override the batch host cannot apply.
- `details` (list of EvalLaneRefusalErrorDetailsItems, optional)
- `requiredScopes` (list of string, optional) — On `insufficient_scope`: every API key scope this request needs.
- `evalConfigId` (string, optional) — `evalConfigId` of the refused configuration (product surface batch evals).
- `evalConfigIndex` (integer, optional) — Index into `evalConfigs` of the refused configuration (multi-config submissions).

### Error

- `error` (string, required)
- `code` (string, optional) — Stable error code. `insufficient_scope` marks an API key that lacks a scope this request needs.
- `details` (list of ErrorDetailsItems, optional)
- `requiredScopes` (list of string, optional) — On `insufficient_scope`: every API key scope this request needs.

### InternalErrorDetailsItems

- `message` (string, required)
- `code` (string, optional) — Stable Runtype validation code (e.g. MISSING_REQUIRED_FIELD, INVALID_ENUM).
- `path` (string, optional) — Dotted JSON path to the offending field.
- `suggestion` (string, optional) — Actionable hint (allowed values, accepted range, …).

### DatabaseUnavailableErrorDetailsItems

- `message` (string, required)
- `code` (string, optional) — Stable Runtype validation code (e.g. MISSING_REQUIRED_FIELD, INVALID_ENUM).
- `path` (string, optional) — Dotted JSON path to the offending field.
- `suggestion` (string, optional) — Actionable hint (allowed values, accepted range, …).

### EvalOverrides

Canonical eval override field. Replaces `stepOverrides` (and its `"*"` key), `claudeManagedOverride` and `advisorOverride`; setting both spellings of one channel is a 400.

- `advisor` (EvalOverridesAdvisor, optional, nullable) — Advisor override for agent capabilities. `null` disables the advisor; omitting it leaves the target’s own config alone.
- `agent` (EvalStepOverrideValues, optional) — Applies to every prompt step of the agent under test. Valid only on an agent target; sending it on a flow target is a 400.
- `claudeManaged` (EvalOverridesClaudeManaged, optional) — Claude Managed variant override. Valid only on a claude_managed agent target; rejected on a standard agent rather than silently ignored.
- `flow` (EvalOverridesFlow, optional) — Applies to every prompt step of the flow under test. Valid only on a flow target; sending it on an agent target is a 400.
- `steps` (map from string to EvalOverridesSteps, optional) — Per-step overrides keyed by step id. Beats agent/flow field by field. A key naming no step of the target is a 400 rather than a silently-scored no-op.
- `subagentDefaults` (EvalOverridesSubagentDefaults, optional) — Applies to every reachable sub-agent with no `subagents` entry of its own. Does not apply to a dynamically-spawned child, which keeps the model its spawn resolved.
- `subagents` (map from string to EvalOverridesSubagents, optional) — Per-sub-agent overrides keyed by agentId. The key is an identity, not a position: an entry applies wherever that agent runs, at any depth. A key naming an agent this target cannot reach is a 400.

### V1EvalSubmitPostResponsesContentApplicationJsonSchemaOneOf0SubmissionsItems

- `batchExecutionId` (string, required)
- `status` (string, required)
- `evalName` (string, optional)

### EvalLaneRefusalErrorDetailsItems

- `message` (string, required)
- `code` (string, optional) — Stable Runtype validation code (e.g. MISSING_REQUIRED_FIELD, INVALID_ENUM).
- `path` (string, optional) — Dotted JSON path to the offending field.
- `suggestion` (string, optional) — Actionable hint (allowed values, accepted range, …).

### EvalOverridesAdvisor

Advisor override for agent capabilities. `null` disables the advisor; omitting it leaves the target’s own config alone.

- `model` (string, required)
- `systemPrompt` (string, optional)

### EvalStepOverrideValues

Applies to every prompt step of the agent under test. Valid only on an agent target; sending it on a flow target is a 400.

- `frequencyPenalty` (double, optional)
- `maxTokens` (integer, optional)
- `model` (string, optional)
- `presencePenalty` (double, optional)
- `reasoning` (any, optional)
- `responseFormat` (enum, optional)
  - Allowed values: `default`, `json`, `markdown`, `html`, `xml`
- `seed` (double, optional)
- `temperature` (double, optional)
- `tools` (any, optional)
- `topK` (double, optional)
- `topP` (double, optional)

### EvalOverridesClaudeManaged

Claude Managed variant override. Valid only on a claude_managed agent target; rejected on a standard agent rather than silently ignored.

- `model` (string, optional)
- `systemPrompt` (string, optional)
- `toolPermissions` (map from string to boolean, optional)

### EvalOverridesFlow

Applies to every prompt step of the flow under test. Valid only on a flow target; sending it on an agent target is a 400.

- `frequencyPenalty` (double, optional)
- `maxTokens` (integer, optional)
- `model` (string, optional)
- `presencePenalty` (double, optional)
- `reasoning` (any, optional)
- `responseFormat` (enum, optional)
  - Allowed values: `default`, `json`, `markdown`, `html`, `xml`
- `seed` (double, optional)
- `temperature` (double, optional)
- `tools` (any, optional)
- `topK` (double, optional)
- `topP` (double, optional)

### EvalOverridesSteps

Sampling/model/tool values applied to one override target. Unset fields inherit; a field set here beats the same field on a broader target.

- `frequencyPenalty` (double, optional)
- `maxTokens` (integer, optional)
- `model` (string, optional)
- `presencePenalty` (double, optional)
- `reasoning` (any, optional)
- `responseFormat` (enum, optional)
  - Allowed values: `default`, `json`, `markdown`, `html`, `xml`
- `seed` (double, optional)
- `temperature` (double, optional)
- `tools` (any, optional)
- `topK` (double, optional)
- `topP` (double, optional)

### EvalOverridesSubagentDefaults

Applies to every reachable sub-agent with no `subagents` entry of its own. Does not apply to a dynamically-spawned child, which keeps the model its spawn resolved.

- `frequencyPenalty` (double, optional)
- `maxTokens` (integer, optional)
- `model` (string, optional)
- `presencePenalty` (double, optional)
- `reasoning` (any, optional)
- `responseFormat` (enum, optional)
  - Allowed values: `default`, `json`, `markdown`, `html`, `xml`
- `seed` (double, optional)
- `temperature` (double, optional)
- `tools` (any, optional)
- `topK` (double, optional)
- `topP` (double, optional)

### EvalOverridesSubagents

Sampling/model/tool values applied to one override target. Unset fields inherit; a field set here beats the same field on a broader target.

- `frequencyPenalty` (double, optional)
- `maxTokens` (integer, optional)
- `model` (string, optional)
- `presencePenalty` (double, optional)
- `reasoning` (any, optional)
- `responseFormat` (enum, optional)
  - Allowed values: `default`, `json`, `markdown`, `html`, `xml`
- `seed` (double, optional)
- `temperature` (double, optional)
- `tools` (any, optional)
- `topK` (double, optional)
- `topP` (double, optional)

## Examples

### Submit Eval with Ad-hoc (Virtual) Records

**Request**

```json
{
  "evalConfig": {
    "overrides": {
      "steps": {
        "step_01jv0000000000000000000001": {
          "maxTokens": 2000,
          "model": "gpt-4o",
          "temperature": 0.7
        }
      }
    }
  },
  "evalName": "Ad-hoc Data Test",
  "flowId": "flow_01jv0000000000000000000001",
  "options": {
    "chunkSize": 200,
    "recordConcurrency": 25
  },
  "records": [
    {
      "metadata": {
        "company": "Acme Corp",
        "email": "customer1@example.com",
        "plan": "enterprise"
      },
      "name": "Test Customer 1",
      "type": "customer"
    },
    {
      "metadata": {
        "company": "TechStart Inc",
        "email": "customer2@example.com",
        "plan": "growth"
      },
      "name": "Test Customer 2",
      "type": "customer"
    },
    {
      "metadata": {
        "company": "MegaSoft LLC",
        "email": "customer3@example.com",
        "plan": "starter"
      },
      "name": "Test Customer 3",
      "type": "customer"
    }
  ]
}
```

**Response**

```json
{
  "evalGroupId": "string",
  "submissions": [
    {
      "batchExecutionId": "string",
      "evalName": "string",
      "status": "string"
    }
  ],
  "totalEvals": 1
}
```

**SDK Code**

```python Submit Eval with Ad-hoc (Virtual) Records
import requests

url = "https://api.runtype.com/v1/eval/submit"

payload = {
    "evalConfig": { "overrides": { "steps": { "step_01jv0000000000000000000001": {
                    "maxTokens": 2000,
                    "model": "gpt-4o",
                    "temperature": 0.7
                } } } },
    "evalName": "Ad-hoc Data Test",
    "flowId": "flow_01jv0000000000000000000001",
    "options": {
        "chunkSize": 200,
        "recordConcurrency": 25
    },
    "records": [
        {
            "metadata": {
                "company": "Acme Corp",
                "email": "customer1@example.com",
                "plan": "enterprise"
            },
            "name": "Test Customer 1",
            "type": "customer"
        },
        {
            "metadata": {
                "company": "TechStart Inc",
                "email": "customer2@example.com",
                "plan": "growth"
            },
            "name": "Test Customer 2",
            "type": "customer"
        },
        {
            "metadata": {
                "company": "MegaSoft LLC",
                "email": "customer3@example.com",
                "plan": "starter"
            },
            "name": "Test Customer 3",
            "type": "customer"
        }
    ]
}
headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript Submit Eval with Ad-hoc (Virtual) Records
const url = 'https://api.runtype.com/v1/eval/submit';
const options = {
  method: 'POST',
  headers: {Authorization: 'Bearer <token>', 'Content-Type': 'application/json'},
  body: '{"evalConfig":{"overrides":{"steps":{"step_01jv0000000000000000000001":{"maxTokens":2000,"model":"gpt-4o","temperature":0.7}}}},"evalName":"Ad-hoc Data Test","flowId":"flow_01jv0000000000000000000001","options":{"chunkSize":200,"recordConcurrency":25},"records":[{"metadata":{"company":"Acme Corp","email":"customer1@example.com","plan":"enterprise"},"name":"Test Customer 1","type":"customer"},{"metadata":{"company":"TechStart Inc","email":"customer2@example.com","plan":"growth"},"name":"Test Customer 2","type":"customer"},{"metadata":{"company":"MegaSoft LLC","email":"customer3@example.com","plan":"starter"},"name":"Test Customer 3","type":"customer"}]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Submit Eval with Ad-hoc (Virtual) Records
package main

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

func main() {

	url := "https://api.runtype.com/v1/eval/submit"

	payload := strings.NewReader("{\n  \"evalConfig\": {\n    \"overrides\": {\n      \"steps\": {\n        \"step_01jv0000000000000000000001\": {\n          \"maxTokens\": 2000,\n          \"model\": \"gpt-4o\",\n          \"temperature\": 0.7\n        }\n      }\n    }\n  },\n  \"evalName\": \"Ad-hoc Data Test\",\n  \"flowId\": \"flow_01jv0000000000000000000001\",\n  \"options\": {\n    \"chunkSize\": 200,\n    \"recordConcurrency\": 25\n  },\n  \"records\": [\n    {\n      \"metadata\": {\n        \"company\": \"Acme Corp\",\n        \"email\": \"customer1@example.com\",\n        \"plan\": \"enterprise\"\n      },\n      \"name\": \"Test Customer 1\",\n      \"type\": \"customer\"\n    },\n    {\n      \"metadata\": {\n        \"company\": \"TechStart Inc\",\n        \"email\": \"customer2@example.com\",\n        \"plan\": \"growth\"\n      },\n      \"name\": \"Test Customer 2\",\n      \"type\": \"customer\"\n    },\n    {\n      \"metadata\": {\n        \"company\": \"MegaSoft LLC\",\n        \"email\": \"customer3@example.com\",\n        \"plan\": \"starter\"\n      },\n      \"name\": \"Test Customer 3\",\n      \"type\": \"customer\"\n    }\n  ]\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Authorization", "Bearer <token>")
	req.Header.Add("Content-Type", "application/json")

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Submit Eval with Ad-hoc (Virtual) Records
require 'uri'
require 'net/http'

url = URI("https://api.runtype.com/v1/eval/submit")

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

request = Net::HTTP::Post.new(url)
request["Authorization"] = 'Bearer <token>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"evalConfig\": {\n    \"overrides\": {\n      \"steps\": {\n        \"step_01jv0000000000000000000001\": {\n          \"maxTokens\": 2000,\n          \"model\": \"gpt-4o\",\n          \"temperature\": 0.7\n        }\n      }\n    }\n  },\n  \"evalName\": \"Ad-hoc Data Test\",\n  \"flowId\": \"flow_01jv0000000000000000000001\",\n  \"options\": {\n    \"chunkSize\": 200,\n    \"recordConcurrency\": 25\n  },\n  \"records\": [\n    {\n      \"metadata\": {\n        \"company\": \"Acme Corp\",\n        \"email\": \"customer1@example.com\",\n        \"plan\": \"enterprise\"\n      },\n      \"name\": \"Test Customer 1\",\n      \"type\": \"customer\"\n    },\n    {\n      \"metadata\": {\n        \"company\": \"TechStart Inc\",\n        \"email\": \"customer2@example.com\",\n        \"plan\": \"growth\"\n      },\n      \"name\": \"Test Customer 2\",\n      \"type\": \"customer\"\n    },\n    {\n      \"metadata\": {\n        \"company\": \"MegaSoft LLC\",\n        \"email\": \"customer3@example.com\",\n        \"plan\": \"starter\"\n      },\n      \"name\": \"Test Customer 3\",\n      \"type\": \"customer\"\n    }\n  ]\n}"

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

```java Submit Eval with Ad-hoc (Virtual) Records
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api.runtype.com/v1/eval/submit")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/json")
  .body("{\n  \"evalConfig\": {\n    \"overrides\": {\n      \"steps\": {\n        \"step_01jv0000000000000000000001\": {\n          \"maxTokens\": 2000,\n          \"model\": \"gpt-4o\",\n          \"temperature\": 0.7\n        }\n      }\n    }\n  },\n  \"evalName\": \"Ad-hoc Data Test\",\n  \"flowId\": \"flow_01jv0000000000000000000001\",\n  \"options\": {\n    \"chunkSize\": 200,\n    \"recordConcurrency\": 25\n  },\n  \"records\": [\n    {\n      \"metadata\": {\n        \"company\": \"Acme Corp\",\n        \"email\": \"customer1@example.com\",\n        \"plan\": \"enterprise\"\n      },\n      \"name\": \"Test Customer 1\",\n      \"type\": \"customer\"\n    },\n    {\n      \"metadata\": {\n        \"company\": \"TechStart Inc\",\n        \"email\": \"customer2@example.com\",\n        \"plan\": \"growth\"\n      },\n      \"name\": \"Test Customer 2\",\n      \"type\": \"customer\"\n    },\n    {\n      \"metadata\": {\n        \"company\": \"MegaSoft LLC\",\n        \"email\": \"customer3@example.com\",\n        \"plan\": \"starter\"\n      },\n      \"name\": \"Test Customer 3\",\n      \"type\": \"customer\"\n    }\n  ]\n}")
  .asString();
```

```php Submit Eval with Ad-hoc (Virtual) Records
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.runtype.com/v1/eval/submit', [
  'body' => '{
  "evalConfig": {
    "overrides": {
      "steps": {
        "step_01jv0000000000000000000001": {
          "maxTokens": 2000,
          "model": "gpt-4o",
          "temperature": 0.7
        }
      }
    }
  },
  "evalName": "Ad-hoc Data Test",
  "flowId": "flow_01jv0000000000000000000001",
  "options": {
    "chunkSize": 200,
    "recordConcurrency": 25
  },
  "records": [
    {
      "metadata": {
        "company": "Acme Corp",
        "email": "customer1@example.com",
        "plan": "enterprise"
      },
      "name": "Test Customer 1",
      "type": "customer"
    },
    {
      "metadata": {
        "company": "TechStart Inc",
        "email": "customer2@example.com",
        "plan": "growth"
      },
      "name": "Test Customer 2",
      "type": "customer"
    },
    {
      "metadata": {
        "company": "MegaSoft LLC",
        "email": "customer3@example.com",
        "plan": "starter"
      },
      "name": "Test Customer 3",
      "type": "customer"
    }
  ]
}',
  'headers' => [
    'Authorization' => 'Bearer <token>',
    'Content-Type' => 'application/json',
  ],
]);

echo $response->getBody();
```

```csharp Submit Eval with Ad-hoc (Virtual) Records
using RestSharp;

var client = new RestClient("https://api.runtype.com/v1/eval/submit");
var request = new RestRequest(Method.POST);
request.AddHeader("Authorization", "Bearer <token>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"evalConfig\": {\n    \"overrides\": {\n      \"steps\": {\n        \"step_01jv0000000000000000000001\": {\n          \"maxTokens\": 2000,\n          \"model\": \"gpt-4o\",\n          \"temperature\": 0.7\n        }\n      }\n    }\n  },\n  \"evalName\": \"Ad-hoc Data Test\",\n  \"flowId\": \"flow_01jv0000000000000000000001\",\n  \"options\": {\n    \"chunkSize\": 200,\n    \"recordConcurrency\": 25\n  },\n  \"records\": [\n    {\n      \"metadata\": {\n        \"company\": \"Acme Corp\",\n        \"email\": \"customer1@example.com\",\n        \"plan\": \"enterprise\"\n      },\n      \"name\": \"Test Customer 1\",\n      \"type\": \"customer\"\n    },\n    {\n      \"metadata\": {\n        \"company\": \"TechStart Inc\",\n        \"email\": \"customer2@example.com\",\n        \"plan\": \"growth\"\n      },\n      \"name\": \"Test Customer 2\",\n      \"type\": \"customer\"\n    },\n    {\n      \"metadata\": {\n        \"company\": \"MegaSoft LLC\",\n        \"email\": \"customer3@example.com\",\n        \"plan\": \"starter\"\n      },\n      \"name\": \"Test Customer 3\",\n      \"type\": \"customer\"\n    }\n  ]\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Submit Eval with Ad-hoc (Virtual) Records
import Foundation

let headers = [
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
]
let parameters = [
  "evalConfig": ["overrides": ["steps": ["step_01jv0000000000000000000001": [
          "maxTokens": 2000,
          "model": "gpt-4o",
          "temperature": 0.7
        ]]]],
  "evalName": "Ad-hoc Data Test",
  "flowId": "flow_01jv0000000000000000000001",
  "options": [
    "chunkSize": 200,
    "recordConcurrency": 25
  ],
  "records": [
    [
      "metadata": [
        "company": "Acme Corp",
        "email": "customer1@example.com",
        "plan": "enterprise"
      ],
      "name": "Test Customer 1",
      "type": "customer"
    ],
    [
      "metadata": [
        "company": "TechStart Inc",
        "email": "customer2@example.com",
        "plan": "growth"
      ],
      "name": "Test Customer 2",
      "type": "customer"
    ],
    [
      "metadata": [
        "company": "MegaSoft LLC",
        "email": "customer3@example.com",
        "plan": "starter"
      ],
      "name": "Test Customer 3",
      "type": "customer"
    ]
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://api.runtype.com/v1/eval/submit")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

### Submit Eval with Global + Per-Step Overrides

**Request**

```json
{
  "evalConfig": {
    "overrides": {
      "flow": {
        "model": "claude-haiku-4-5",
        "temperature": 0.2
      },
      "steps": {
        "step_01jv0000000000000000000001": {
          "maxTokens": 4000,
          "model": "claude-sonnet-4-6"
        }
      }
    }
  },
  "evalName": "Haiku everywhere, Sonnet on the summary step",
  "flowId": "flow_01jv0000000000000000000001",
  "options": {
    "chunkSize": 200,
    "recordConcurrency": 25
  },
  "recordIds": [
    "record_01jv0000000000000000000001"
  ]
}
```

**Response**

```json
{
  "evalGroupId": "string",
  "submissions": [
    {
      "batchExecutionId": "string",
      "evalName": "string",
      "status": "string"
    }
  ],
  "totalEvals": 1
}
```

**SDK Code**

```python Submit Eval with Global + Per-Step Overrides
import requests

url = "https://api.runtype.com/v1/eval/submit"

payload = {
    "evalConfig": { "overrides": {
            "flow": {
                "model": "claude-haiku-4-5",
                "temperature": 0.2
            },
            "steps": { "step_01jv0000000000000000000001": {
                    "maxTokens": 4000,
                    "model": "claude-sonnet-4-6"
                } }
        } },
    "evalName": "Haiku everywhere, Sonnet on the summary step",
    "flowId": "flow_01jv0000000000000000000001",
    "options": {
        "chunkSize": 200,
        "recordConcurrency": 25
    },
    "recordIds": ["record_01jv0000000000000000000001"]
}
headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript Submit Eval with Global + Per-Step Overrides
const url = 'https://api.runtype.com/v1/eval/submit';
const options = {
  method: 'POST',
  headers: {Authorization: 'Bearer <token>', 'Content-Type': 'application/json'},
  body: '{"evalConfig":{"overrides":{"flow":{"model":"claude-haiku-4-5","temperature":0.2},"steps":{"step_01jv0000000000000000000001":{"maxTokens":4000,"model":"claude-sonnet-4-6"}}}},"evalName":"Haiku everywhere, Sonnet on the summary step","flowId":"flow_01jv0000000000000000000001","options":{"chunkSize":200,"recordConcurrency":25},"recordIds":["record_01jv0000000000000000000001"]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Submit Eval with Global + Per-Step Overrides
package main

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

func main() {

	url := "https://api.runtype.com/v1/eval/submit"

	payload := strings.NewReader("{\n  \"evalConfig\": {\n    \"overrides\": {\n      \"flow\": {\n        \"model\": \"claude-haiku-4-5\",\n        \"temperature\": 0.2\n      },\n      \"steps\": {\n        \"step_01jv0000000000000000000001\": {\n          \"maxTokens\": 4000,\n          \"model\": \"claude-sonnet-4-6\"\n        }\n      }\n    }\n  },\n  \"evalName\": \"Haiku everywhere, Sonnet on the summary step\",\n  \"flowId\": \"flow_01jv0000000000000000000001\",\n  \"options\": {\n    \"chunkSize\": 200,\n    \"recordConcurrency\": 25\n  },\n  \"recordIds\": [\n    \"record_01jv0000000000000000000001\"\n  ]\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Authorization", "Bearer <token>")
	req.Header.Add("Content-Type", "application/json")

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Submit Eval with Global + Per-Step Overrides
require 'uri'
require 'net/http'

url = URI("https://api.runtype.com/v1/eval/submit")

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

request = Net::HTTP::Post.new(url)
request["Authorization"] = 'Bearer <token>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"evalConfig\": {\n    \"overrides\": {\n      \"flow\": {\n        \"model\": \"claude-haiku-4-5\",\n        \"temperature\": 0.2\n      },\n      \"steps\": {\n        \"step_01jv0000000000000000000001\": {\n          \"maxTokens\": 4000,\n          \"model\": \"claude-sonnet-4-6\"\n        }\n      }\n    }\n  },\n  \"evalName\": \"Haiku everywhere, Sonnet on the summary step\",\n  \"flowId\": \"flow_01jv0000000000000000000001\",\n  \"options\": {\n    \"chunkSize\": 200,\n    \"recordConcurrency\": 25\n  },\n  \"recordIds\": [\n    \"record_01jv0000000000000000000001\"\n  ]\n}"

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

```java Submit Eval with Global + Per-Step Overrides
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api.runtype.com/v1/eval/submit")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/json")
  .body("{\n  \"evalConfig\": {\n    \"overrides\": {\n      \"flow\": {\n        \"model\": \"claude-haiku-4-5\",\n        \"temperature\": 0.2\n      },\n      \"steps\": {\n        \"step_01jv0000000000000000000001\": {\n          \"maxTokens\": 4000,\n          \"model\": \"claude-sonnet-4-6\"\n        }\n      }\n    }\n  },\n  \"evalName\": \"Haiku everywhere, Sonnet on the summary step\",\n  \"flowId\": \"flow_01jv0000000000000000000001\",\n  \"options\": {\n    \"chunkSize\": 200,\n    \"recordConcurrency\": 25\n  },\n  \"recordIds\": [\n    \"record_01jv0000000000000000000001\"\n  ]\n}")
  .asString();
```

```php Submit Eval with Global + Per-Step Overrides
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.runtype.com/v1/eval/submit', [
  'body' => '{
  "evalConfig": {
    "overrides": {
      "flow": {
        "model": "claude-haiku-4-5",
        "temperature": 0.2
      },
      "steps": {
        "step_01jv0000000000000000000001": {
          "maxTokens": 4000,
          "model": "claude-sonnet-4-6"
        }
      }
    }
  },
  "evalName": "Haiku everywhere, Sonnet on the summary step",
  "flowId": "flow_01jv0000000000000000000001",
  "options": {
    "chunkSize": 200,
    "recordConcurrency": 25
  },
  "recordIds": [
    "record_01jv0000000000000000000001"
  ]
}',
  'headers' => [
    'Authorization' => 'Bearer <token>',
    'Content-Type' => 'application/json',
  ],
]);

echo $response->getBody();
```

```csharp Submit Eval with Global + Per-Step Overrides
using RestSharp;

var client = new RestClient("https://api.runtype.com/v1/eval/submit");
var request = new RestRequest(Method.POST);
request.AddHeader("Authorization", "Bearer <token>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"evalConfig\": {\n    \"overrides\": {\n      \"flow\": {\n        \"model\": \"claude-haiku-4-5\",\n        \"temperature\": 0.2\n      },\n      \"steps\": {\n        \"step_01jv0000000000000000000001\": {\n          \"maxTokens\": 4000,\n          \"model\": \"claude-sonnet-4-6\"\n        }\n      }\n    }\n  },\n  \"evalName\": \"Haiku everywhere, Sonnet on the summary step\",\n  \"flowId\": \"flow_01jv0000000000000000000001\",\n  \"options\": {\n    \"chunkSize\": 200,\n    \"recordConcurrency\": 25\n  },\n  \"recordIds\": [\n    \"record_01jv0000000000000000000001\"\n  ]\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Submit Eval with Global + Per-Step Overrides
import Foundation

let headers = [
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
]
let parameters = [
  "evalConfig": ["overrides": [
      "flow": [
        "model": "claude-haiku-4-5",
        "temperature": 0.2
      ],
      "steps": ["step_01jv0000000000000000000001": [
          "maxTokens": 4000,
          "model": "claude-sonnet-4-6"
        ]]
    ]],
  "evalName": "Haiku everywhere, Sonnet on the summary step",
  "flowId": "flow_01jv0000000000000000000001",
  "options": [
    "chunkSize": 200,
    "recordConcurrency": 25
  ],
  "recordIds": ["record_01jv0000000000000000000001"]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://api.runtype.com/v1/eval/submit")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

### Submit Multi-Model Eval (eval group)

**Request**

```json
{
  "evalConfigs": [
    {
      "evalName": "GPT-4o Baseline",
      "overrides": {
        "steps": {
          "step_01jv0000000000000000000001": {
            "model": "gpt-4o",
            "temperature": 0.7
          }
        }
      }
    },
    {
      "evalName": "Claude Sonnet",
      "overrides": {
        "steps": {
          "step_01jv0000000000000000000001": {
            "model": "claude-sonnet-4-5",
            "temperature": 0.7
          }
        }
      }
    },
    {
      "evalName": "Gemini Flash",
      "overrides": {
        "steps": {
          "step_01jv0000000000000000000001": {
            "model": "gemini-3-flash",
            "temperature": 0.7
          }
        }
      }
    },
    {
      "evalName": "GPT-5 Mini",
      "overrides": {
        "steps": {
          "step_01jv0000000000000000000001": {
            "model": "gpt-5-mini",
            "temperature": 0.7
          }
        }
      }
    }
  ],
  "flowId": "flow_01jv0000000000000000000001",
  "options": {
    "chunkSize": 200,
    "recordConcurrency": 25
  },
  "recordIds": [
    "record_01jv0000000000000000000001",
    "record_01jv0000000000000000000002",
    "record_01jv0000000000000000000003"
  ]
}
```

**Response**

```json
{
  "evalGroupId": "string",
  "submissions": [
    {
      "batchExecutionId": "string",
      "evalName": "string",
      "status": "string"
    }
  ],
  "totalEvals": 1
}
```

**SDK Code**

```python Submit Multi-Model Eval (eval group)
import requests

url = "https://api.runtype.com/v1/eval/submit"

payload = {
    "evalConfigs": [
        {
            "evalName": "GPT-4o Baseline",
            "overrides": { "steps": { "step_01jv0000000000000000000001": {
                        "model": "gpt-4o",
                        "temperature": 0.7
                    } } }
        },
        {
            "evalName": "Claude Sonnet",
            "overrides": { "steps": { "step_01jv0000000000000000000001": {
                        "model": "claude-sonnet-4-5",
                        "temperature": 0.7
                    } } }
        },
        {
            "evalName": "Gemini Flash",
            "overrides": { "steps": { "step_01jv0000000000000000000001": {
                        "model": "gemini-3-flash",
                        "temperature": 0.7
                    } } }
        },
        {
            "evalName": "GPT-5 Mini",
            "overrides": { "steps": { "step_01jv0000000000000000000001": {
                        "model": "gpt-5-mini",
                        "temperature": 0.7
                    } } }
        }
    ],
    "flowId": "flow_01jv0000000000000000000001",
    "options": {
        "chunkSize": 200,
        "recordConcurrency": 25
    },
    "recordIds": ["record_01jv0000000000000000000001", "record_01jv0000000000000000000002", "record_01jv0000000000000000000003"]
}
headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript Submit Multi-Model Eval (eval group)
const url = 'https://api.runtype.com/v1/eval/submit';
const options = {
  method: 'POST',
  headers: {Authorization: 'Bearer <token>', 'Content-Type': 'application/json'},
  body: '{"evalConfigs":[{"evalName":"GPT-4o Baseline","overrides":{"steps":{"step_01jv0000000000000000000001":{"model":"gpt-4o","temperature":0.7}}}},{"evalName":"Claude Sonnet","overrides":{"steps":{"step_01jv0000000000000000000001":{"model":"claude-sonnet-4-5","temperature":0.7}}}},{"evalName":"Gemini Flash","overrides":{"steps":{"step_01jv0000000000000000000001":{"model":"gemini-3-flash","temperature":0.7}}}},{"evalName":"GPT-5 Mini","overrides":{"steps":{"step_01jv0000000000000000000001":{"model":"gpt-5-mini","temperature":0.7}}}}],"flowId":"flow_01jv0000000000000000000001","options":{"chunkSize":200,"recordConcurrency":25},"recordIds":["record_01jv0000000000000000000001","record_01jv0000000000000000000002","record_01jv0000000000000000000003"]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Submit Multi-Model Eval (eval group)
package main

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

func main() {

	url := "https://api.runtype.com/v1/eval/submit"

	payload := strings.NewReader("{\n  \"evalConfigs\": [\n    {\n      \"evalName\": \"GPT-4o Baseline\",\n      \"overrides\": {\n        \"steps\": {\n          \"step_01jv0000000000000000000001\": {\n            \"model\": \"gpt-4o\",\n            \"temperature\": 0.7\n          }\n        }\n      }\n    },\n    {\n      \"evalName\": \"Claude Sonnet\",\n      \"overrides\": {\n        \"steps\": {\n          \"step_01jv0000000000000000000001\": {\n            \"model\": \"claude-sonnet-4-5\",\n            \"temperature\": 0.7\n          }\n        }\n      }\n    },\n    {\n      \"evalName\": \"Gemini Flash\",\n      \"overrides\": {\n        \"steps\": {\n          \"step_01jv0000000000000000000001\": {\n            \"model\": \"gemini-3-flash\",\n            \"temperature\": 0.7\n          }\n        }\n      }\n    },\n    {\n      \"evalName\": \"GPT-5 Mini\",\n      \"overrides\": {\n        \"steps\": {\n          \"step_01jv0000000000000000000001\": {\n            \"model\": \"gpt-5-mini\",\n            \"temperature\": 0.7\n          }\n        }\n      }\n    }\n  ],\n  \"flowId\": \"flow_01jv0000000000000000000001\",\n  \"options\": {\n    \"chunkSize\": 200,\n    \"recordConcurrency\": 25\n  },\n  \"recordIds\": [\n    \"record_01jv0000000000000000000001\",\n    \"record_01jv0000000000000000000002\",\n    \"record_01jv0000000000000000000003\"\n  ]\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Authorization", "Bearer <token>")
	req.Header.Add("Content-Type", "application/json")

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Submit Multi-Model Eval (eval group)
require 'uri'
require 'net/http'

url = URI("https://api.runtype.com/v1/eval/submit")

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

request = Net::HTTP::Post.new(url)
request["Authorization"] = 'Bearer <token>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"evalConfigs\": [\n    {\n      \"evalName\": \"GPT-4o Baseline\",\n      \"overrides\": {\n        \"steps\": {\n          \"step_01jv0000000000000000000001\": {\n            \"model\": \"gpt-4o\",\n            \"temperature\": 0.7\n          }\n        }\n      }\n    },\n    {\n      \"evalName\": \"Claude Sonnet\",\n      \"overrides\": {\n        \"steps\": {\n          \"step_01jv0000000000000000000001\": {\n            \"model\": \"claude-sonnet-4-5\",\n            \"temperature\": 0.7\n          }\n        }\n      }\n    },\n    {\n      \"evalName\": \"Gemini Flash\",\n      \"overrides\": {\n        \"steps\": {\n          \"step_01jv0000000000000000000001\": {\n            \"model\": \"gemini-3-flash\",\n            \"temperature\": 0.7\n          }\n        }\n      }\n    },\n    {\n      \"evalName\": \"GPT-5 Mini\",\n      \"overrides\": {\n        \"steps\": {\n          \"step_01jv0000000000000000000001\": {\n            \"model\": \"gpt-5-mini\",\n            \"temperature\": 0.7\n          }\n        }\n      }\n    }\n  ],\n  \"flowId\": \"flow_01jv0000000000000000000001\",\n  \"options\": {\n    \"chunkSize\": 200,\n    \"recordConcurrency\": 25\n  },\n  \"recordIds\": [\n    \"record_01jv0000000000000000000001\",\n    \"record_01jv0000000000000000000002\",\n    \"record_01jv0000000000000000000003\"\n  ]\n}"

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

```java Submit Multi-Model Eval (eval group)
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api.runtype.com/v1/eval/submit")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/json")
  .body("{\n  \"evalConfigs\": [\n    {\n      \"evalName\": \"GPT-4o Baseline\",\n      \"overrides\": {\n        \"steps\": {\n          \"step_01jv0000000000000000000001\": {\n            \"model\": \"gpt-4o\",\n            \"temperature\": 0.7\n          }\n        }\n      }\n    },\n    {\n      \"evalName\": \"Claude Sonnet\",\n      \"overrides\": {\n        \"steps\": {\n          \"step_01jv0000000000000000000001\": {\n            \"model\": \"claude-sonnet-4-5\",\n            \"temperature\": 0.7\n          }\n        }\n      }\n    },\n    {\n      \"evalName\": \"Gemini Flash\",\n      \"overrides\": {\n        \"steps\": {\n          \"step_01jv0000000000000000000001\": {\n            \"model\": \"gemini-3-flash\",\n            \"temperature\": 0.7\n          }\n        }\n      }\n    },\n    {\n      \"evalName\": \"GPT-5 Mini\",\n      \"overrides\": {\n        \"steps\": {\n          \"step_01jv0000000000000000000001\": {\n            \"model\": \"gpt-5-mini\",\n            \"temperature\": 0.7\n          }\n        }\n      }\n    }\n  ],\n  \"flowId\": \"flow_01jv0000000000000000000001\",\n  \"options\": {\n    \"chunkSize\": 200,\n    \"recordConcurrency\": 25\n  },\n  \"recordIds\": [\n    \"record_01jv0000000000000000000001\",\n    \"record_01jv0000000000000000000002\",\n    \"record_01jv0000000000000000000003\"\n  ]\n}")
  .asString();
```

```php Submit Multi-Model Eval (eval group)
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.runtype.com/v1/eval/submit', [
  'body' => '{
  "evalConfigs": [
    {
      "evalName": "GPT-4o Baseline",
      "overrides": {
        "steps": {
          "step_01jv0000000000000000000001": {
            "model": "gpt-4o",
            "temperature": 0.7
          }
        }
      }
    },
    {
      "evalName": "Claude Sonnet",
      "overrides": {
        "steps": {
          "step_01jv0000000000000000000001": {
            "model": "claude-sonnet-4-5",
            "temperature": 0.7
          }
        }
      }
    },
    {
      "evalName": "Gemini Flash",
      "overrides": {
        "steps": {
          "step_01jv0000000000000000000001": {
            "model": "gemini-3-flash",
            "temperature": 0.7
          }
        }
      }
    },
    {
      "evalName": "GPT-5 Mini",
      "overrides": {
        "steps": {
          "step_01jv0000000000000000000001": {
            "model": "gpt-5-mini",
            "temperature": 0.7
          }
        }
      }
    }
  ],
  "flowId": "flow_01jv0000000000000000000001",
  "options": {
    "chunkSize": 200,
    "recordConcurrency": 25
  },
  "recordIds": [
    "record_01jv0000000000000000000001",
    "record_01jv0000000000000000000002",
    "record_01jv0000000000000000000003"
  ]
}',
  'headers' => [
    'Authorization' => 'Bearer <token>',
    'Content-Type' => 'application/json',
  ],
]);

echo $response->getBody();
```

```csharp Submit Multi-Model Eval (eval group)
using RestSharp;

var client = new RestClient("https://api.runtype.com/v1/eval/submit");
var request = new RestRequest(Method.POST);
request.AddHeader("Authorization", "Bearer <token>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"evalConfigs\": [\n    {\n      \"evalName\": \"GPT-4o Baseline\",\n      \"overrides\": {\n        \"steps\": {\n          \"step_01jv0000000000000000000001\": {\n            \"model\": \"gpt-4o\",\n            \"temperature\": 0.7\n          }\n        }\n      }\n    },\n    {\n      \"evalName\": \"Claude Sonnet\",\n      \"overrides\": {\n        \"steps\": {\n          \"step_01jv0000000000000000000001\": {\n            \"model\": \"claude-sonnet-4-5\",\n            \"temperature\": 0.7\n          }\n        }\n      }\n    },\n    {\n      \"evalName\": \"Gemini Flash\",\n      \"overrides\": {\n        \"steps\": {\n          \"step_01jv0000000000000000000001\": {\n            \"model\": \"gemini-3-flash\",\n            \"temperature\": 0.7\n          }\n        }\n      }\n    },\n    {\n      \"evalName\": \"GPT-5 Mini\",\n      \"overrides\": {\n        \"steps\": {\n          \"step_01jv0000000000000000000001\": {\n            \"model\": \"gpt-5-mini\",\n            \"temperature\": 0.7\n          }\n        }\n      }\n    }\n  ],\n  \"flowId\": \"flow_01jv0000000000000000000001\",\n  \"options\": {\n    \"chunkSize\": 200,\n    \"recordConcurrency\": 25\n  },\n  \"recordIds\": [\n    \"record_01jv0000000000000000000001\",\n    \"record_01jv0000000000000000000002\",\n    \"record_01jv0000000000000000000003\"\n  ]\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Submit Multi-Model Eval (eval group)
import Foundation

let headers = [
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
]
let parameters = [
  "evalConfigs": [
    [
      "evalName": "GPT-4o Baseline",
      "overrides": ["steps": ["step_01jv0000000000000000000001": [
            "model": "gpt-4o",
            "temperature": 0.7
          ]]]
    ],
    [
      "evalName": "Claude Sonnet",
      "overrides": ["steps": ["step_01jv0000000000000000000001": [
            "model": "claude-sonnet-4-5",
            "temperature": 0.7
          ]]]
    ],
    [
      "evalName": "Gemini Flash",
      "overrides": ["steps": ["step_01jv0000000000000000000001": [
            "model": "gemini-3-flash",
            "temperature": 0.7
          ]]]
    ],
    [
      "evalName": "GPT-5 Mini",
      "overrides": ["steps": ["step_01jv0000000000000000000001": [
            "model": "gpt-5-mini",
            "temperature": 0.7
          ]]]
    ]
  ],
  "flowId": "flow_01jv0000000000000000000001",
  "options": [
    "chunkSize": 200,
    "recordConcurrency": 25
  ],
  "recordIds": ["record_01jv0000000000000000000001", "record_01jv0000000000000000000002", "record_01jv0000000000000000000003"]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://api.runtype.com/v1/eval/submit")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

### Submit Single Eval

**Request**

```json
{
  "evalConfig": {
    "overrides": {
      "steps": {
        "step_01jv0000000000000000000001": {
          "maxTokens": 2000,
          "model": "gpt-4o",
          "temperature": 0.7
        }
      }
    }
  },
  "evalName": "GPT-4o Baseline Test",
  "flowId": "flow_01jv0000000000000000000001",
  "options": {
    "chunkSize": 200,
    "recordConcurrency": 25
  },
  "recordIds": [
    "record_01jv0000000000000000000001",
    "record_01jv0000000000000000000002"
  ]
}
```

**Response**

```json
{
  "evalGroupId": "string",
  "submissions": [
    {
      "batchExecutionId": "string",
      "evalName": "string",
      "status": "string"
    }
  ],
  "totalEvals": 1
}
```

**SDK Code**

```python Submit Single Eval
import requests

url = "https://api.runtype.com/v1/eval/submit"

payload = {
    "evalConfig": { "overrides": { "steps": { "step_01jv0000000000000000000001": {
                    "maxTokens": 2000,
                    "model": "gpt-4o",
                    "temperature": 0.7
                } } } },
    "evalName": "GPT-4o Baseline Test",
    "flowId": "flow_01jv0000000000000000000001",
    "options": {
        "chunkSize": 200,
        "recordConcurrency": 25
    },
    "recordIds": ["record_01jv0000000000000000000001", "record_01jv0000000000000000000002"]
}
headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript Submit Single Eval
const url = 'https://api.runtype.com/v1/eval/submit';
const options = {
  method: 'POST',
  headers: {Authorization: 'Bearer <token>', 'Content-Type': 'application/json'},
  body: '{"evalConfig":{"overrides":{"steps":{"step_01jv0000000000000000000001":{"maxTokens":2000,"model":"gpt-4o","temperature":0.7}}}},"evalName":"GPT-4o Baseline Test","flowId":"flow_01jv0000000000000000000001","options":{"chunkSize":200,"recordConcurrency":25},"recordIds":["record_01jv0000000000000000000001","record_01jv0000000000000000000002"]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Submit Single Eval
package main

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

func main() {

	url := "https://api.runtype.com/v1/eval/submit"

	payload := strings.NewReader("{\n  \"evalConfig\": {\n    \"overrides\": {\n      \"steps\": {\n        \"step_01jv0000000000000000000001\": {\n          \"maxTokens\": 2000,\n          \"model\": \"gpt-4o\",\n          \"temperature\": 0.7\n        }\n      }\n    }\n  },\n  \"evalName\": \"GPT-4o Baseline Test\",\n  \"flowId\": \"flow_01jv0000000000000000000001\",\n  \"options\": {\n    \"chunkSize\": 200,\n    \"recordConcurrency\": 25\n  },\n  \"recordIds\": [\n    \"record_01jv0000000000000000000001\",\n    \"record_01jv0000000000000000000002\"\n  ]\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Authorization", "Bearer <token>")
	req.Header.Add("Content-Type", "application/json")

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Submit Single Eval
require 'uri'
require 'net/http'

url = URI("https://api.runtype.com/v1/eval/submit")

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

request = Net::HTTP::Post.new(url)
request["Authorization"] = 'Bearer <token>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"evalConfig\": {\n    \"overrides\": {\n      \"steps\": {\n        \"step_01jv0000000000000000000001\": {\n          \"maxTokens\": 2000,\n          \"model\": \"gpt-4o\",\n          \"temperature\": 0.7\n        }\n      }\n    }\n  },\n  \"evalName\": \"GPT-4o Baseline Test\",\n  \"flowId\": \"flow_01jv0000000000000000000001\",\n  \"options\": {\n    \"chunkSize\": 200,\n    \"recordConcurrency\": 25\n  },\n  \"recordIds\": [\n    \"record_01jv0000000000000000000001\",\n    \"record_01jv0000000000000000000002\"\n  ]\n}"

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

```java Submit Single Eval
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api.runtype.com/v1/eval/submit")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/json")
  .body("{\n  \"evalConfig\": {\n    \"overrides\": {\n      \"steps\": {\n        \"step_01jv0000000000000000000001\": {\n          \"maxTokens\": 2000,\n          \"model\": \"gpt-4o\",\n          \"temperature\": 0.7\n        }\n      }\n    }\n  },\n  \"evalName\": \"GPT-4o Baseline Test\",\n  \"flowId\": \"flow_01jv0000000000000000000001\",\n  \"options\": {\n    \"chunkSize\": 200,\n    \"recordConcurrency\": 25\n  },\n  \"recordIds\": [\n    \"record_01jv0000000000000000000001\",\n    \"record_01jv0000000000000000000002\"\n  ]\n}")
  .asString();
```

```php Submit Single Eval
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.runtype.com/v1/eval/submit', [
  'body' => '{
  "evalConfig": {
    "overrides": {
      "steps": {
        "step_01jv0000000000000000000001": {
          "maxTokens": 2000,
          "model": "gpt-4o",
          "temperature": 0.7
        }
      }
    }
  },
  "evalName": "GPT-4o Baseline Test",
  "flowId": "flow_01jv0000000000000000000001",
  "options": {
    "chunkSize": 200,
    "recordConcurrency": 25
  },
  "recordIds": [
    "record_01jv0000000000000000000001",
    "record_01jv0000000000000000000002"
  ]
}',
  'headers' => [
    'Authorization' => 'Bearer <token>',
    'Content-Type' => 'application/json',
  ],
]);

echo $response->getBody();
```

```csharp Submit Single Eval
using RestSharp;

var client = new RestClient("https://api.runtype.com/v1/eval/submit");
var request = new RestRequest(Method.POST);
request.AddHeader("Authorization", "Bearer <token>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"evalConfig\": {\n    \"overrides\": {\n      \"steps\": {\n        \"step_01jv0000000000000000000001\": {\n          \"maxTokens\": 2000,\n          \"model\": \"gpt-4o\",\n          \"temperature\": 0.7\n        }\n      }\n    }\n  },\n  \"evalName\": \"GPT-4o Baseline Test\",\n  \"flowId\": \"flow_01jv0000000000000000000001\",\n  \"options\": {\n    \"chunkSize\": 200,\n    \"recordConcurrency\": 25\n  },\n  \"recordIds\": [\n    \"record_01jv0000000000000000000001\",\n    \"record_01jv0000000000000000000002\"\n  ]\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Submit Single Eval
import Foundation

let headers = [
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
]
let parameters = [
  "evalConfig": ["overrides": ["steps": ["step_01jv0000000000000000000001": [
          "maxTokens": 2000,
          "model": "gpt-4o",
          "temperature": 0.7
        ]]]],
  "evalName": "GPT-4o Baseline Test",
  "flowId": "flow_01jv0000000000000000000001",
  "options": [
    "chunkSize": 200,
    "recordConcurrency": 25
  ],
  "recordIds": ["record_01jv0000000000000000000001", "record_01jv0000000000000000000002"]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://api.runtype.com/v1/eval/submit")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

### Submit Eval with Per-Sub-Agent Overrides

**Request**

```json
{
  "evalConfigs": [
    {
      "evalName": "Baseline"
    },
    {
      "evalName": "Cheap children",
      "overrides": {
        "subagentDefaults": {
          "model": "claude-haiku-4-5"
        }
      }
    },
    {
      "evalName": "Cheap children, strong researcher",
      "overrides": {
        "subagentDefaults": {
          "model": "claude-haiku-4-5"
        },
        "subagents": {
          "agent_01jv0000000000000000000002": {
            "model": "claude-sonnet-4-6",
            "temperature": 0
          }
        }
      }
    },
    {
      "evalName": "Strong parent, cheap children",
      "overrides": {
        "agent": {
          "model": "claude-opus-4-6"
        },
        "subagentDefaults": {
          "model": "claude-haiku-4-5"
        }
      }
    }
  ],
  "agentId": "agent_01jv0000000000000000000001",
  "options": {
    "chunkSize": 200,
    "recordConcurrency": 25
  },
  "records": [
    {
      "metadata": {
        "messages": [
          {
            "content": "Summarize this quarter's support themes.",
            "role": "user"
          }
        ]
      },
      "name": "Research request"
    }
  ]
}
```

**Response**

```json
{
  "evalGroupId": "string",
  "submissions": [
    {
      "batchExecutionId": "string",
      "evalName": "string",
      "status": "string"
    }
  ],
  "totalEvals": 1
}
```

**SDK Code**

```python Submit Eval with Per-Sub-Agent Overrides
import requests

url = "https://api.runtype.com/v1/eval/submit"

payload = {
    "evalConfigs": [
        { "evalName": "Baseline" },
        {
            "evalName": "Cheap children",
            "overrides": { "subagentDefaults": { "model": "claude-haiku-4-5" } }
        },
        {
            "evalName": "Cheap children, strong researcher",
            "overrides": {
                "subagentDefaults": { "model": "claude-haiku-4-5" },
                "subagents": { "agent_01jv0000000000000000000002": {
                        "model": "claude-sonnet-4-6",
                        "temperature": 0
                    } }
            }
        },
        {
            "evalName": "Strong parent, cheap children",
            "overrides": {
                "agent": { "model": "claude-opus-4-6" },
                "subagentDefaults": { "model": "claude-haiku-4-5" }
            }
        }
    ],
    "agentId": "agent_01jv0000000000000000000001",
    "options": {
        "chunkSize": 200,
        "recordConcurrency": 25
    },
    "records": [
        {
            "metadata": { "messages": [
                    {
                        "content": "Summarize this quarter's support themes.",
                        "role": "user"
                    }
                ] },
            "name": "Research request"
        }
    ]
}
headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript Submit Eval with Per-Sub-Agent Overrides
const url = 'https://api.runtype.com/v1/eval/submit';
const options = {
  method: 'POST',
  headers: {Authorization: 'Bearer <token>', 'Content-Type': 'application/json'},
  body: '{"evalConfigs":[{"evalName":"Baseline"},{"evalName":"Cheap children","overrides":{"subagentDefaults":{"model":"claude-haiku-4-5"}}},{"evalName":"Cheap children, strong researcher","overrides":{"subagentDefaults":{"model":"claude-haiku-4-5"},"subagents":{"agent_01jv0000000000000000000002":{"model":"claude-sonnet-4-6","temperature":0}}}},{"evalName":"Strong parent, cheap children","overrides":{"agent":{"model":"claude-opus-4-6"},"subagentDefaults":{"model":"claude-haiku-4-5"}}}],"agentId":"agent_01jv0000000000000000000001","options":{"chunkSize":200,"recordConcurrency":25},"records":[{"metadata":{"messages":[{"content":"Summarize this quarter\'s support themes.","role":"user"}]},"name":"Research request"}]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Submit Eval with Per-Sub-Agent Overrides
package main

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

func main() {

	url := "https://api.runtype.com/v1/eval/submit"

	payload := strings.NewReader("{\n  \"evalConfigs\": [\n    {\n      \"evalName\": \"Baseline\"\n    },\n    {\n      \"evalName\": \"Cheap children\",\n      \"overrides\": {\n        \"subagentDefaults\": {\n          \"model\": \"claude-haiku-4-5\"\n        }\n      }\n    },\n    {\n      \"evalName\": \"Cheap children, strong researcher\",\n      \"overrides\": {\n        \"subagentDefaults\": {\n          \"model\": \"claude-haiku-4-5\"\n        },\n        \"subagents\": {\n          \"agent_01jv0000000000000000000002\": {\n            \"model\": \"claude-sonnet-4-6\",\n            \"temperature\": 0\n          }\n        }\n      }\n    },\n    {\n      \"evalName\": \"Strong parent, cheap children\",\n      \"overrides\": {\n        \"agent\": {\n          \"model\": \"claude-opus-4-6\"\n        },\n        \"subagentDefaults\": {\n          \"model\": \"claude-haiku-4-5\"\n        }\n      }\n    }\n  ],\n  \"agentId\": \"agent_01jv0000000000000000000001\",\n  \"options\": {\n    \"chunkSize\": 200,\n    \"recordConcurrency\": 25\n  },\n  \"records\": [\n    {\n      \"metadata\": {\n        \"messages\": [\n          {\n            \"content\": \"Summarize this quarter's support themes.\",\n            \"role\": \"user\"\n          }\n        ]\n      },\n      \"name\": \"Research request\"\n    }\n  ]\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Authorization", "Bearer <token>")
	req.Header.Add("Content-Type", "application/json")

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Submit Eval with Per-Sub-Agent Overrides
require 'uri'
require 'net/http'

url = URI("https://api.runtype.com/v1/eval/submit")

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

request = Net::HTTP::Post.new(url)
request["Authorization"] = 'Bearer <token>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"evalConfigs\": [\n    {\n      \"evalName\": \"Baseline\"\n    },\n    {\n      \"evalName\": \"Cheap children\",\n      \"overrides\": {\n        \"subagentDefaults\": {\n          \"model\": \"claude-haiku-4-5\"\n        }\n      }\n    },\n    {\n      \"evalName\": \"Cheap children, strong researcher\",\n      \"overrides\": {\n        \"subagentDefaults\": {\n          \"model\": \"claude-haiku-4-5\"\n        },\n        \"subagents\": {\n          \"agent_01jv0000000000000000000002\": {\n            \"model\": \"claude-sonnet-4-6\",\n            \"temperature\": 0\n          }\n        }\n      }\n    },\n    {\n      \"evalName\": \"Strong parent, cheap children\",\n      \"overrides\": {\n        \"agent\": {\n          \"model\": \"claude-opus-4-6\"\n        },\n        \"subagentDefaults\": {\n          \"model\": \"claude-haiku-4-5\"\n        }\n      }\n    }\n  ],\n  \"agentId\": \"agent_01jv0000000000000000000001\",\n  \"options\": {\n    \"chunkSize\": 200,\n    \"recordConcurrency\": 25\n  },\n  \"records\": [\n    {\n      \"metadata\": {\n        \"messages\": [\n          {\n            \"content\": \"Summarize this quarter's support themes.\",\n            \"role\": \"user\"\n          }\n        ]\n      },\n      \"name\": \"Research request\"\n    }\n  ]\n}"

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

```java Submit Eval with Per-Sub-Agent Overrides
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api.runtype.com/v1/eval/submit")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/json")
  .body("{\n  \"evalConfigs\": [\n    {\n      \"evalName\": \"Baseline\"\n    },\n    {\n      \"evalName\": \"Cheap children\",\n      \"overrides\": {\n        \"subagentDefaults\": {\n          \"model\": \"claude-haiku-4-5\"\n        }\n      }\n    },\n    {\n      \"evalName\": \"Cheap children, strong researcher\",\n      \"overrides\": {\n        \"subagentDefaults\": {\n          \"model\": \"claude-haiku-4-5\"\n        },\n        \"subagents\": {\n          \"agent_01jv0000000000000000000002\": {\n            \"model\": \"claude-sonnet-4-6\",\n            \"temperature\": 0\n          }\n        }\n      }\n    },\n    {\n      \"evalName\": \"Strong parent, cheap children\",\n      \"overrides\": {\n        \"agent\": {\n          \"model\": \"claude-opus-4-6\"\n        },\n        \"subagentDefaults\": {\n          \"model\": \"claude-haiku-4-5\"\n        }\n      }\n    }\n  ],\n  \"agentId\": \"agent_01jv0000000000000000000001\",\n  \"options\": {\n    \"chunkSize\": 200,\n    \"recordConcurrency\": 25\n  },\n  \"records\": [\n    {\n      \"metadata\": {\n        \"messages\": [\n          {\n            \"content\": \"Summarize this quarter's support themes.\",\n            \"role\": \"user\"\n          }\n        ]\n      },\n      \"name\": \"Research request\"\n    }\n  ]\n}")
  .asString();
```

```php Submit Eval with Per-Sub-Agent Overrides
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.runtype.com/v1/eval/submit', [
  'body' => '{
  "evalConfigs": [
    {
      "evalName": "Baseline"
    },
    {
      "evalName": "Cheap children",
      "overrides": {
        "subagentDefaults": {
          "model": "claude-haiku-4-5"
        }
      }
    },
    {
      "evalName": "Cheap children, strong researcher",
      "overrides": {
        "subagentDefaults": {
          "model": "claude-haiku-4-5"
        },
        "subagents": {
          "agent_01jv0000000000000000000002": {
            "model": "claude-sonnet-4-6",
            "temperature": 0
          }
        }
      }
    },
    {
      "evalName": "Strong parent, cheap children",
      "overrides": {
        "agent": {
          "model": "claude-opus-4-6"
        },
        "subagentDefaults": {
          "model": "claude-haiku-4-5"
        }
      }
    }
  ],
  "agentId": "agent_01jv0000000000000000000001",
  "options": {
    "chunkSize": 200,
    "recordConcurrency": 25
  },
  "records": [
    {
      "metadata": {
        "messages": [
          {
            "content": "Summarize this quarter\'s support themes.",
            "role": "user"
          }
        ]
      },
      "name": "Research request"
    }
  ]
}',
  'headers' => [
    'Authorization' => 'Bearer <token>',
    'Content-Type' => 'application/json',
  ],
]);

echo $response->getBody();
```

```csharp Submit Eval with Per-Sub-Agent Overrides
using RestSharp;

var client = new RestClient("https://api.runtype.com/v1/eval/submit");
var request = new RestRequest(Method.POST);
request.AddHeader("Authorization", "Bearer <token>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"evalConfigs\": [\n    {\n      \"evalName\": \"Baseline\"\n    },\n    {\n      \"evalName\": \"Cheap children\",\n      \"overrides\": {\n        \"subagentDefaults\": {\n          \"model\": \"claude-haiku-4-5\"\n        }\n      }\n    },\n    {\n      \"evalName\": \"Cheap children, strong researcher\",\n      \"overrides\": {\n        \"subagentDefaults\": {\n          \"model\": \"claude-haiku-4-5\"\n        },\n        \"subagents\": {\n          \"agent_01jv0000000000000000000002\": {\n            \"model\": \"claude-sonnet-4-6\",\n            \"temperature\": 0\n          }\n        }\n      }\n    },\n    {\n      \"evalName\": \"Strong parent, cheap children\",\n      \"overrides\": {\n        \"agent\": {\n          \"model\": \"claude-opus-4-6\"\n        },\n        \"subagentDefaults\": {\n          \"model\": \"claude-haiku-4-5\"\n        }\n      }\n    }\n  ],\n  \"agentId\": \"agent_01jv0000000000000000000001\",\n  \"options\": {\n    \"chunkSize\": 200,\n    \"recordConcurrency\": 25\n  },\n  \"records\": [\n    {\n      \"metadata\": {\n        \"messages\": [\n          {\n            \"content\": \"Summarize this quarter's support themes.\",\n            \"role\": \"user\"\n          }\n        ]\n      },\n      \"name\": \"Research request\"\n    }\n  ]\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Submit Eval with Per-Sub-Agent Overrides
import Foundation

let headers = [
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
]
let parameters = [
  "evalConfigs": [
    ["evalName": "Baseline"],
    [
      "evalName": "Cheap children",
      "overrides": ["subagentDefaults": ["model": "claude-haiku-4-5"]]
    ],
    [
      "evalName": "Cheap children, strong researcher",
      "overrides": [
        "subagentDefaults": ["model": "claude-haiku-4-5"],
        "subagents": ["agent_01jv0000000000000000000002": [
            "model": "claude-sonnet-4-6",
            "temperature": 0
          ]]
      ]
    ],
    [
      "evalName": "Strong parent, cheap children",
      "overrides": [
        "agent": ["model": "claude-opus-4-6"],
        "subagentDefaults": ["model": "claude-haiku-4-5"]
      ]
    ]
  ],
  "agentId": "agent_01jv0000000000000000000001",
  "options": [
    "chunkSize": 200,
    "recordConcurrency": 25
  ],
  "records": [
    [
      "metadata": ["messages": [
          [
            "content": "Summarize this quarter's support themes.",
            "role": "user"
          ]
        ]],
      "name": "Research request"
    ]
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://api.runtype.com/v1/eval/submit")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

### Submit Eval with Tool Variations

**Request**

```json
{
  "evalConfigs": [
    {
      "evalName": "No Tools",
      "overrides": {
        "steps": {
          "step_01jv0000000000000000000001": {
            "model": "gpt-4o",
            "temperature": 0.7,
            "tools": {
              "toolIds": []
            }
          }
        }
      }
    },
    {
      "evalName": "With Tool A",
      "overrides": {
        "steps": {
          "step_01jv0000000000000000000001": {
            "model": "gpt-4o",
            "temperature": 0.7,
            "tools": {
              "maxToolCalls": 5,
              "toolCallStrategy": "auto",
              "toolIds": [
                "tool_01jv0000000000000000000001"
              ]
            }
          }
        }
      }
    },
    {
      "evalName": "With Tools A + B",
      "overrides": {
        "steps": {
          "step_01jv0000000000000000000001": {
            "model": "gpt-4o",
            "temperature": 0.7,
            "tools": {
              "maxToolCalls": 10,
              "toolCallStrategy": "auto",
              "toolIds": [
                "tool_01jv0000000000000000000001",
                "tool_01jv0000000000000000000002"
              ]
            }
          }
        }
      }
    },
    {
      "evalName": "Required Tool Usage",
      "overrides": {
        "steps": {
          "step_01jv0000000000000000000001": {
            "model": "gpt-4o",
            "temperature": 0.7,
            "tools": {
              "maxToolCalls": 1,
              "toolCallStrategy": "required",
              "toolIds": [
                "tool_01jv0000000000000000000001"
              ]
            }
          }
        }
      }
    }
  ],
  "flowId": "flow_01jv0000000000000000000001",
  "options": {
    "chunkSize": 200,
    "recordConcurrency": 25
  },
  "recordIds": [
    "record_01jv0000000000000000000001",
    "record_01jv0000000000000000000002",
    "record_01jv0000000000000000000003"
  ]
}
```

**Response**

```json
{
  "evalGroupId": "string",
  "submissions": [
    {
      "batchExecutionId": "string",
      "evalName": "string",
      "status": "string"
    }
  ],
  "totalEvals": 1
}
```

**SDK Code**

```python Submit Eval with Tool Variations
import requests

url = "https://api.runtype.com/v1/eval/submit"

payload = {
    "evalConfigs": [
        {
            "evalName": "No Tools",
            "overrides": { "steps": { "step_01jv0000000000000000000001": {
                        "model": "gpt-4o",
                        "temperature": 0.7,
                        "tools": { "toolIds": [] }
                    } } }
        },
        {
            "evalName": "With Tool A",
            "overrides": { "steps": { "step_01jv0000000000000000000001": {
                        "model": "gpt-4o",
                        "temperature": 0.7,
                        "tools": {
                            "maxToolCalls": 5,
                            "toolCallStrategy": "auto",
                            "toolIds": ["tool_01jv0000000000000000000001"]
                        }
                    } } }
        },
        {
            "evalName": "With Tools A + B",
            "overrides": { "steps": { "step_01jv0000000000000000000001": {
                        "model": "gpt-4o",
                        "temperature": 0.7,
                        "tools": {
                            "maxToolCalls": 10,
                            "toolCallStrategy": "auto",
                            "toolIds": ["tool_01jv0000000000000000000001", "tool_01jv0000000000000000000002"]
                        }
                    } } }
        },
        {
            "evalName": "Required Tool Usage",
            "overrides": { "steps": { "step_01jv0000000000000000000001": {
                        "model": "gpt-4o",
                        "temperature": 0.7,
                        "tools": {
                            "maxToolCalls": 1,
                            "toolCallStrategy": "required",
                            "toolIds": ["tool_01jv0000000000000000000001"]
                        }
                    } } }
        }
    ],
    "flowId": "flow_01jv0000000000000000000001",
    "options": {
        "chunkSize": 200,
        "recordConcurrency": 25
    },
    "recordIds": ["record_01jv0000000000000000000001", "record_01jv0000000000000000000002", "record_01jv0000000000000000000003"]
}
headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript Submit Eval with Tool Variations
const url = 'https://api.runtype.com/v1/eval/submit';
const options = {
  method: 'POST',
  headers: {Authorization: 'Bearer <token>', 'Content-Type': 'application/json'},
  body: '{"evalConfigs":[{"evalName":"No Tools","overrides":{"steps":{"step_01jv0000000000000000000001":{"model":"gpt-4o","temperature":0.7,"tools":{"toolIds":[]}}}}},{"evalName":"With Tool A","overrides":{"steps":{"step_01jv0000000000000000000001":{"model":"gpt-4o","temperature":0.7,"tools":{"maxToolCalls":5,"toolCallStrategy":"auto","toolIds":["tool_01jv0000000000000000000001"]}}}}},{"evalName":"With Tools A + B","overrides":{"steps":{"step_01jv0000000000000000000001":{"model":"gpt-4o","temperature":0.7,"tools":{"maxToolCalls":10,"toolCallStrategy":"auto","toolIds":["tool_01jv0000000000000000000001","tool_01jv0000000000000000000002"]}}}}},{"evalName":"Required Tool Usage","overrides":{"steps":{"step_01jv0000000000000000000001":{"model":"gpt-4o","temperature":0.7,"tools":{"maxToolCalls":1,"toolCallStrategy":"required","toolIds":["tool_01jv0000000000000000000001"]}}}}}],"flowId":"flow_01jv0000000000000000000001","options":{"chunkSize":200,"recordConcurrency":25},"recordIds":["record_01jv0000000000000000000001","record_01jv0000000000000000000002","record_01jv0000000000000000000003"]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Submit Eval with Tool Variations
package main

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

func main() {

	url := "https://api.runtype.com/v1/eval/submit"

	payload := strings.NewReader("{\n  \"evalConfigs\": [\n    {\n      \"evalName\": \"No Tools\",\n      \"overrides\": {\n        \"steps\": {\n          \"step_01jv0000000000000000000001\": {\n            \"model\": \"gpt-4o\",\n            \"temperature\": 0.7,\n            \"tools\": {\n              \"toolIds\": []\n            }\n          }\n        }\n      }\n    },\n    {\n      \"evalName\": \"With Tool A\",\n      \"overrides\": {\n        \"steps\": {\n          \"step_01jv0000000000000000000001\": {\n            \"model\": \"gpt-4o\",\n            \"temperature\": 0.7,\n            \"tools\": {\n              \"maxToolCalls\": 5,\n              \"toolCallStrategy\": \"auto\",\n              \"toolIds\": [\n                \"tool_01jv0000000000000000000001\"\n              ]\n            }\n          }\n        }\n      }\n    },\n    {\n      \"evalName\": \"With Tools A + B\",\n      \"overrides\": {\n        \"steps\": {\n          \"step_01jv0000000000000000000001\": {\n            \"model\": \"gpt-4o\",\n            \"temperature\": 0.7,\n            \"tools\": {\n              \"maxToolCalls\": 10,\n              \"toolCallStrategy\": \"auto\",\n              \"toolIds\": [\n                \"tool_01jv0000000000000000000001\",\n                \"tool_01jv0000000000000000000002\"\n              ]\n            }\n          }\n        }\n      }\n    },\n    {\n      \"evalName\": \"Required Tool Usage\",\n      \"overrides\": {\n        \"steps\": {\n          \"step_01jv0000000000000000000001\": {\n            \"model\": \"gpt-4o\",\n            \"temperature\": 0.7,\n            \"tools\": {\n              \"maxToolCalls\": 1,\n              \"toolCallStrategy\": \"required\",\n              \"toolIds\": [\n                \"tool_01jv0000000000000000000001\"\n              ]\n            }\n          }\n        }\n      }\n    }\n  ],\n  \"flowId\": \"flow_01jv0000000000000000000001\",\n  \"options\": {\n    \"chunkSize\": 200,\n    \"recordConcurrency\": 25\n  },\n  \"recordIds\": [\n    \"record_01jv0000000000000000000001\",\n    \"record_01jv0000000000000000000002\",\n    \"record_01jv0000000000000000000003\"\n  ]\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Authorization", "Bearer <token>")
	req.Header.Add("Content-Type", "application/json")

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Submit Eval with Tool Variations
require 'uri'
require 'net/http'

url = URI("https://api.runtype.com/v1/eval/submit")

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

request = Net::HTTP::Post.new(url)
request["Authorization"] = 'Bearer <token>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"evalConfigs\": [\n    {\n      \"evalName\": \"No Tools\",\n      \"overrides\": {\n        \"steps\": {\n          \"step_01jv0000000000000000000001\": {\n            \"model\": \"gpt-4o\",\n            \"temperature\": 0.7,\n            \"tools\": {\n              \"toolIds\": []\n            }\n          }\n        }\n      }\n    },\n    {\n      \"evalName\": \"With Tool A\",\n      \"overrides\": {\n        \"steps\": {\n          \"step_01jv0000000000000000000001\": {\n            \"model\": \"gpt-4o\",\n            \"temperature\": 0.7,\n            \"tools\": {\n              \"maxToolCalls\": 5,\n              \"toolCallStrategy\": \"auto\",\n              \"toolIds\": [\n                \"tool_01jv0000000000000000000001\"\n              ]\n            }\n          }\n        }\n      }\n    },\n    {\n      \"evalName\": \"With Tools A + B\",\n      \"overrides\": {\n        \"steps\": {\n          \"step_01jv0000000000000000000001\": {\n            \"model\": \"gpt-4o\",\n            \"temperature\": 0.7,\n            \"tools\": {\n              \"maxToolCalls\": 10,\n              \"toolCallStrategy\": \"auto\",\n              \"toolIds\": [\n                \"tool_01jv0000000000000000000001\",\n                \"tool_01jv0000000000000000000002\"\n              ]\n            }\n          }\n        }\n      }\n    },\n    {\n      \"evalName\": \"Required Tool Usage\",\n      \"overrides\": {\n        \"steps\": {\n          \"step_01jv0000000000000000000001\": {\n            \"model\": \"gpt-4o\",\n            \"temperature\": 0.7,\n            \"tools\": {\n              \"maxToolCalls\": 1,\n              \"toolCallStrategy\": \"required\",\n              \"toolIds\": [\n                \"tool_01jv0000000000000000000001\"\n              ]\n            }\n          }\n        }\n      }\n    }\n  ],\n  \"flowId\": \"flow_01jv0000000000000000000001\",\n  \"options\": {\n    \"chunkSize\": 200,\n    \"recordConcurrency\": 25\n  },\n  \"recordIds\": [\n    \"record_01jv0000000000000000000001\",\n    \"record_01jv0000000000000000000002\",\n    \"record_01jv0000000000000000000003\"\n  ]\n}"

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

```java Submit Eval with Tool Variations
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api.runtype.com/v1/eval/submit")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/json")
  .body("{\n  \"evalConfigs\": [\n    {\n      \"evalName\": \"No Tools\",\n      \"overrides\": {\n        \"steps\": {\n          \"step_01jv0000000000000000000001\": {\n            \"model\": \"gpt-4o\",\n            \"temperature\": 0.7,\n            \"tools\": {\n              \"toolIds\": []\n            }\n          }\n        }\n      }\n    },\n    {\n      \"evalName\": \"With Tool A\",\n      \"overrides\": {\n        \"steps\": {\n          \"step_01jv0000000000000000000001\": {\n            \"model\": \"gpt-4o\",\n            \"temperature\": 0.7,\n            \"tools\": {\n              \"maxToolCalls\": 5,\n              \"toolCallStrategy\": \"auto\",\n              \"toolIds\": [\n                \"tool_01jv0000000000000000000001\"\n              ]\n            }\n          }\n        }\n      }\n    },\n    {\n      \"evalName\": \"With Tools A + B\",\n      \"overrides\": {\n        \"steps\": {\n          \"step_01jv0000000000000000000001\": {\n            \"model\": \"gpt-4o\",\n            \"temperature\": 0.7,\n            \"tools\": {\n              \"maxToolCalls\": 10,\n              \"toolCallStrategy\": \"auto\",\n              \"toolIds\": [\n                \"tool_01jv0000000000000000000001\",\n                \"tool_01jv0000000000000000000002\"\n              ]\n            }\n          }\n        }\n      }\n    },\n    {\n      \"evalName\": \"Required Tool Usage\",\n      \"overrides\": {\n        \"steps\": {\n          \"step_01jv0000000000000000000001\": {\n            \"model\": \"gpt-4o\",\n            \"temperature\": 0.7,\n            \"tools\": {\n              \"maxToolCalls\": 1,\n              \"toolCallStrategy\": \"required\",\n              \"toolIds\": [\n                \"tool_01jv0000000000000000000001\"\n              ]\n            }\n          }\n        }\n      }\n    }\n  ],\n  \"flowId\": \"flow_01jv0000000000000000000001\",\n  \"options\": {\n    \"chunkSize\": 200,\n    \"recordConcurrency\": 25\n  },\n  \"recordIds\": [\n    \"record_01jv0000000000000000000001\",\n    \"record_01jv0000000000000000000002\",\n    \"record_01jv0000000000000000000003\"\n  ]\n}")
  .asString();
```

```php Submit Eval with Tool Variations
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.runtype.com/v1/eval/submit', [
  'body' => '{
  "evalConfigs": [
    {
      "evalName": "No Tools",
      "overrides": {
        "steps": {
          "step_01jv0000000000000000000001": {
            "model": "gpt-4o",
            "temperature": 0.7,
            "tools": {
              "toolIds": []
            }
          }
        }
      }
    },
    {
      "evalName": "With Tool A",
      "overrides": {
        "steps": {
          "step_01jv0000000000000000000001": {
            "model": "gpt-4o",
            "temperature": 0.7,
            "tools": {
              "maxToolCalls": 5,
              "toolCallStrategy": "auto",
              "toolIds": [
                "tool_01jv0000000000000000000001"
              ]
            }
          }
        }
      }
    },
    {
      "evalName": "With Tools A + B",
      "overrides": {
        "steps": {
          "step_01jv0000000000000000000001": {
            "model": "gpt-4o",
            "temperature": 0.7,
            "tools": {
              "maxToolCalls": 10,
              "toolCallStrategy": "auto",
              "toolIds": [
                "tool_01jv0000000000000000000001",
                "tool_01jv0000000000000000000002"
              ]
            }
          }
        }
      }
    },
    {
      "evalName": "Required Tool Usage",
      "overrides": {
        "steps": {
          "step_01jv0000000000000000000001": {
            "model": "gpt-4o",
            "temperature": 0.7,
            "tools": {
              "maxToolCalls": 1,
              "toolCallStrategy": "required",
              "toolIds": [
                "tool_01jv0000000000000000000001"
              ]
            }
          }
        }
      }
    }
  ],
  "flowId": "flow_01jv0000000000000000000001",
  "options": {
    "chunkSize": 200,
    "recordConcurrency": 25
  },
  "recordIds": [
    "record_01jv0000000000000000000001",
    "record_01jv0000000000000000000002",
    "record_01jv0000000000000000000003"
  ]
}',
  'headers' => [
    'Authorization' => 'Bearer <token>',
    'Content-Type' => 'application/json',
  ],
]);

echo $response->getBody();
```

```csharp Submit Eval with Tool Variations
using RestSharp;

var client = new RestClient("https://api.runtype.com/v1/eval/submit");
var request = new RestRequest(Method.POST);
request.AddHeader("Authorization", "Bearer <token>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"evalConfigs\": [\n    {\n      \"evalName\": \"No Tools\",\n      \"overrides\": {\n        \"steps\": {\n          \"step_01jv0000000000000000000001\": {\n            \"model\": \"gpt-4o\",\n            \"temperature\": 0.7,\n            \"tools\": {\n              \"toolIds\": []\n            }\n          }\n        }\n      }\n    },\n    {\n      \"evalName\": \"With Tool A\",\n      \"overrides\": {\n        \"steps\": {\n          \"step_01jv0000000000000000000001\": {\n            \"model\": \"gpt-4o\",\n            \"temperature\": 0.7,\n            \"tools\": {\n              \"maxToolCalls\": 5,\n              \"toolCallStrategy\": \"auto\",\n              \"toolIds\": [\n                \"tool_01jv0000000000000000000001\"\n              ]\n            }\n          }\n        }\n      }\n    },\n    {\n      \"evalName\": \"With Tools A + B\",\n      \"overrides\": {\n        \"steps\": {\n          \"step_01jv0000000000000000000001\": {\n            \"model\": \"gpt-4o\",\n            \"temperature\": 0.7,\n            \"tools\": {\n              \"maxToolCalls\": 10,\n              \"toolCallStrategy\": \"auto\",\n              \"toolIds\": [\n                \"tool_01jv0000000000000000000001\",\n                \"tool_01jv0000000000000000000002\"\n              ]\n            }\n          }\n        }\n      }\n    },\n    {\n      \"evalName\": \"Required Tool Usage\",\n      \"overrides\": {\n        \"steps\": {\n          \"step_01jv0000000000000000000001\": {\n            \"model\": \"gpt-4o\",\n            \"temperature\": 0.7,\n            \"tools\": {\n              \"maxToolCalls\": 1,\n              \"toolCallStrategy\": \"required\",\n              \"toolIds\": [\n                \"tool_01jv0000000000000000000001\"\n              ]\n            }\n          }\n        }\n      }\n    }\n  ],\n  \"flowId\": \"flow_01jv0000000000000000000001\",\n  \"options\": {\n    \"chunkSize\": 200,\n    \"recordConcurrency\": 25\n  },\n  \"recordIds\": [\n    \"record_01jv0000000000000000000001\",\n    \"record_01jv0000000000000000000002\",\n    \"record_01jv0000000000000000000003\"\n  ]\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Submit Eval with Tool Variations
import Foundation

let headers = [
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
]
let parameters = [
  "evalConfigs": [
    [
      "evalName": "No Tools",
      "overrides": ["steps": ["step_01jv0000000000000000000001": [
            "model": "gpt-4o",
            "temperature": 0.7,
            "tools": ["toolIds": []]
          ]]]
    ],
    [
      "evalName": "With Tool A",
      "overrides": ["steps": ["step_01jv0000000000000000000001": [
            "model": "gpt-4o",
            "temperature": 0.7,
            "tools": [
              "maxToolCalls": 5,
              "toolCallStrategy": "auto",
              "toolIds": ["tool_01jv0000000000000000000001"]
            ]
          ]]]
    ],
    [
      "evalName": "With Tools A + B",
      "overrides": ["steps": ["step_01jv0000000000000000000001": [
            "model": "gpt-4o",
            "temperature": 0.7,
            "tools": [
              "maxToolCalls": 10,
              "toolCallStrategy": "auto",
              "toolIds": ["tool_01jv0000000000000000000001", "tool_01jv0000000000000000000002"]
            ]
          ]]]
    ],
    [
      "evalName": "Required Tool Usage",
      "overrides": ["steps": ["step_01jv0000000000000000000001": [
            "model": "gpt-4o",
            "temperature": 0.7,
            "tools": [
              "maxToolCalls": 1,
              "toolCallStrategy": "required",
              "toolIds": ["tool_01jv0000000000000000000001"]
            ]
          ]]]
    ]
  ],
  "flowId": "flow_01jv0000000000000000000001",
  "options": [
    "chunkSize": 200,
    "recordConcurrency": 25
  ],
  "recordIds": ["record_01jv0000000000000000000001", "record_01jv0000000000000000000002", "record_01jv0000000000000000000003"]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://api.runtype.com/v1/eval/submit")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```