Estimate when a queued pull request will merge

curl --request GET \
  --url https://api.trunk.io/v2/pull-requests/{id}/queue-entry-estimate \
  --header 'Authorization: Bearer <token>'

import requests

url = "https://api.trunk.io/v2/pull-requests/{id}/queue-entry-estimate"

headers = {"Authorization": "Bearer <token>"}

response = requests.get(url, headers=headers)

print(response.text)

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

fetch('https://api.trunk.io/v2/pull-requests/{id}/queue-entry-estimate', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.trunk.io/v2/pull-requests/{id}/queue-entry-estimate",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "Authorization: Bearer <token>"
  ],
]);

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

curl_close($curl);

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

package main

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

func main() {

	url := "https://api.trunk.io/v2/pull-requests/{id}/queue-entry-estimate"

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

	req.Header.Add("Authorization", "Bearer <token>")

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

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

	fmt.Println(string(body))

}

require 'uri'
require 'net/http'

url = URI("https://api.trunk.io/v2/pull-requests/{id}/queue-entry-estimate")

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

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

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

{
  "status": "available",
  "computedAt": "2026-10-07T15:04:05.000Z",
  "kind": "merge",
  "estimatedAt": "2026-10-07T15:24:05.000Z",
  "estimatedAtState": "onTrack",
  "confidence": "medium",
  "pullRequestsAhead": 3,
  "waitingForPullRequestNumbers": [
    4901
  ],
  "sampleSize": 120,
  "startsTestingAt": "2026-10-07T15:09:05.000Z",
  "startsTestingAtState": "onTrack",
  "testsFinishAt": "2026-10-07T15:23:05.000Z",
  "testsFinishAtState": "onTrack",
  "typicalTestDurationSeconds": 900
}

Pull requests

Estimate when a queued pull request will merge

Returns a live estimate for this pull request’s queue entry: when it is expected to merge, when it starts and finishes testing, and how many pull requests it is waiting behind. An entry in pendingFailure instead reports when that failure is expected to resolve (kind: pendingFailureResolution) and which pull requests it is waiting on.

The estimate is computed on each request by simulating the queue forward, so it changes as the queue moves. Read it when the answer is needed rather than in a tight loop: each call runs a fresh simulation, and like the other pull-request reads it is rate-limited per caller. When no estimate can be given — a queue with too little test history, a pull request that is not ready yet, a paused queue — the response says why (status: unavailable, reason).

Not every queue serves estimates yet: one that does not answers 404 ESTIMATE_NOT_ENABLED.

GET

pull-requests

{id}

queue-entry-estimate

Estimate when a queued pull request will merge

curl --request GET \
  --url https://api.trunk.io/v2/pull-requests/{id}/queue-entry-estimate \
  --header 'Authorization: Bearer <token>'

import requests

url = "https://api.trunk.io/v2/pull-requests/{id}/queue-entry-estimate"

headers = {"Authorization": "Bearer <token>"}

response = requests.get(url, headers=headers)

print(response.text)

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

fetch('https://api.trunk.io/v2/pull-requests/{id}/queue-entry-estimate', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.trunk.io/v2/pull-requests/{id}/queue-entry-estimate",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "Authorization: Bearer <token>"
  ],
]);

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

curl_close($curl);

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

package main

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

func main() {

	url := "https://api.trunk.io/v2/pull-requests/{id}/queue-entry-estimate"

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

	req.Header.Add("Authorization", "Bearer <token>")

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

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

	fmt.Println(string(body))

}

require 'uri'
require 'net/http'

url = URI("https://api.trunk.io/v2/pull-requests/{id}/queue-entry-estimate")

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

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

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

{
  "status": "available",
  "computedAt": "2026-10-07T15:04:05.000Z",
  "kind": "merge",
  "estimatedAt": "2026-10-07T15:24:05.000Z",
  "estimatedAtState": "onTrack",
  "confidence": "medium",
  "pullRequestsAhead": 3,
  "waitingForPullRequestNumbers": [
    4901
  ],
  "sampleSize": 120,
  "startsTestingAt": "2026-10-07T15:09:05.000Z",
  "startsTestingAtState": "onTrack",
  "testsFinishAt": "2026-10-07T15:23:05.000Z",
  "testsFinishAtState": "onTrack",
  "typicalTestDurationSeconds": 900
}

Authorizations

Authorization

string

header

required

An API key, sent as Authorization: Bearer <key>. An organization admin creates one in the Trunk app under Settings → Developer → API Keys and chooses the merge-queue permissions it holds; a key with none can read merge queues but change nothing. Those permissions scope merge queue only: every key can use the Flaky Tests and Dynamic CI endpoints, including their writes, whatever permissions it holds.

Path Parameters

string<uuid>

required

The pull request's id.

Example:

"0f8fad5b-d9cb-469f-a165-70867728950e"

Response

The entry's estimate, or why there is none

Option 1
Option 2

A live estimate for a queued pull request, computed by simulating the queue forward from its current state over the queue's recent test history, or why there is none. A point-in-time prediction: a new submission, a priority change or a failure ahead changes it, so read it again when it is needed rather than counting down from one answer.

status

enum<string>

required

Available options:

available

Example:

"available"

computedAt

string<date-time>

required

When the public API received the estimate from the merge service; every other instant is relative to it, so each carries that call's latency.

Example:

"2026-10-07T15:04:05.000Z"

kind

enum<string>

required

merge: estimatedAt is when the pull request is expected to merge. pendingFailureResolution: the entry is in pendingFailure, and estimatedAt is when the failure is expected to resolve — by a restart, a bisection, a pass, or a failure — not a merge time.

Available options:

merge,

pendingFailureResolution

Example:

"merge"

estimatedAt

string<date-time>

required

For kind: merge, the median estimate of when the pull request merges: half of comparable entries finish sooner, half later. For kind: pendingFailureResolution, when the failure is expected to resolve — an upper bound, since it waits for every run the failure depends on, while a restart or a passing run behind it can resolve it sooner.

Example:

"2026-10-07T15:24:05.000Z"

estimatedAtState

enum<string>

required

How far to trust the instant it accompanies. onTrack: a forecast that moves closer as time passes. holding: not counting down, because the queue is waiting on a step it treats as instant (such as a verification run that can start now) or the instant is under a 30-second floor; it does not mean the instant is near. pastTypical: held by a run, this entry's or one ahead of it, that is past its typical time, so the instant is likely an underestimate; on testsFinishAtState the run is this entry's own, so compare against typicalTestDurationSeconds. pastP95: only on testsFinishAtState, this entry's verification run is taking longer than 95% of the queue's recent passing runs.

Available options:

onTrack,

holding,

pastTypical,

pastP95

Example:

"onTrack"

confidence

enum<string>

required

From how much history the queue has, lowered while the entry waits, sits deep in the queue, is held behind a failure, is bisecting, or has a pending failure ahead of it.

Available options:

low,

medium,

high

Example:

"medium"

pullRequestsAhead

integer

required

How many pull requests this one depends on and so must merge behind: a count of blockers, not a queue position. In a graph queue, pull requests in independent lanes are not counted. Past the graph's soft cap, before the pull request is admitted, it counts every pull request in the queue — an upper bound on its blockers.

Example:

3

waitingForPullRequestNumbers

integer[]

required

For pendingFailureResolution, the pull requests whose runs the failure is waiting on right now; empty otherwise.

Maximum array length: 10000

Example:

[4901]

sampleSize

integer

required

Passing tested pull requests in the queue's last 14 days the estimate draws on — one per pull request per verification run, so a passing batch of four counts four.

Example:

120

startsTestingAt

string<date-time>

Present while the entry waits for a test slot.

Example:

"2026-10-07T15:09:05.000Z"

startsTestingAtState

enum<string>

Present exactly when startsTestingAt is: how far to trust it.

Available options:

onTrack,

holding,

pastTypical,

pastP95

Example:

"onTrack"

testsFinishAt

string<date-time>

Present while the entry waits or tests: when its verification run is expected to finish passing, including expected restarts.

Example:

"2026-10-07T15:23:05.000Z"

testsFinishAtState

enum<string>

Present exactly when testsFinishAt is: how far to trust it.

Available options:

onTrack,

holding,

pastTypical,

pastP95

Example:

"onTrack"

typicalTestDurationSeconds

integer

The queue's median duration over its recent passing verification runs, in whole seconds rounded down. Absent when the queue has none to report.

Example:

900