Three lines

Uber

Developers

Merchant Signals Guide

Access to These APIs May Require Written Approval From Uber

Uber’s APIs are always under development and as such are subject to changes according to our Versioning & Upgrade policy. As part of Uber’s ongoing privacy improvements, we’ve updated our Developer API program with new scope access policies for third party applications. For further information, please refer to our Getting Started guide in the navigation panel.

The Merchant Signals API lets your system send merchant-side signals about orders and their items to Uber Eats. Every signal is a MerchantSignal envelope sent to one endpoint, PostMerchantSignal, and each envelope carries exactly one payload.

This guide covers the shared authentication, reliability standards, endpoint, and signal envelope, followed by the Order Evidence payload.

Authentication

All requests must be authenticated with an OAuth 2.0 access token. See the Authentication Guide.

Include the token in the Authorization header of every request:

Authorization: Bearer <access_token>

Scope

Request the following scope when you generate the token:

Scope Description
eats.merchant.signals Send merchant signals, including order evidence.

Base URL

All endpoints in this guide are relative to https://api.uber.com.

Integration and Reliability Standards

To keep the system stable, prevent duplicate data, and recover dropped events, your integration must follow these standards.

Idempotency

  • Every signal must carry a unique event_id (for example evt_partner_987654321 or a UUID) in the envelope. This is the idempotency key: Uber uses it to de-duplicate and to trace the signal end to end.
  • Re-sending a signal with an event_id Uber has already seen is safe. Duplicate submissions are accepted and do not produce a second piece of evidence.
  • Generate a new event_id for every distinct capture. Do not reuse one event_id across two different images, two different weight readings, or an observation and a later conclusion.

Retry logic

  • Retry with exponential backoff until Uber returns a 2xx response.
  • Retry on 5xx responses and on network or timeout failures. Do not retry on 400 or 403: those indicate a payload or permission problem that will not resolve on its own.
  • Keep the original event_id across retries of the same signal. That is what makes the retry safe.
  • Every error response carries a retry field that tells you whether a retry is appropriate.

Batching and ordering

  • One request may contain multiple signals in the signals array.
  • A batch is not atomic. Uber processes signals in array order and stops at the first signal that fails validation or cannot be accepted. Signals before it may already be accepted, and signals after it are not processed. The error response does not say which signals were accepted.
  • After an error, resend the whole batch with the same event_id values, after fixing or removing the failing signal for a 400. Signals that were already accepted are de-duplicated by event_id, so resending them does not create duplicate evidence.
  • Evidence does not have to arrive in capture order, and it does not have to arrive before or after the matching order lifecycle events. Each observation carries its own captured_at, so late-arriving evidence is still attributed correctly.

Endpoint

POST /v1/delivery/store/events

Accepts a batch of merchant signals, including order evidence. Each request can contain one or more MerchantSignal objects.

Headers

Header Type Required Description
Authorization string Yes Bearer <access_token> with a valid Uber OAuth token.
Content-Type string Yes Must be application/json.

Uber identifies your application from the OAuth access token. You do not send an application ID header.

Request body

The request body is a JSON object containing a signals array:

{
  "signals": [
    {
      "event_id": "...",
      "timestamp": "...",
      "event_cadence": "...",
      "trigger_type": "...",
      "order_evidence": {
        "context": { ... },
        "observations": [ ... ],
        "conclusions": [ ... ]
      }
    }
  ]
}
Field Type Required Description
signals array<MerchantSignal> Yes One or more MerchantSignal entries.

Success response

200 OK

{
  "success": true
}

All signals in the request were parsed and accepted.

Signal Envelope

The JSON fields map directly to the underlying protocol buffer definitions.

message PostMerchantSignalRequest {
  repeated MerchantSignal signals = 1;
}

MerchantSignal

The envelope is shared by every merchant signal. Set exactly one payload variant; this guide documents order_evidence.

message MerchantSignal {
  string event_id = 1;
  google.protobuf.Timestamp timestamp = 2;
  EventCadence event_cadence = 3;
  TriggerType trigger_type = 4;
  oneof payload {
    OrderEvent    order_event    = 5;
    ItemEvent     item_event     = 6;
    OrderEvidence order_evidence = 7;
  }
}
Field Type Required Description
event_id string Yes Unique identifier for this signal. Used for idempotency and tracing on Uber’s side.
timestamp string Yes Time this signal was generated in your system (ISO 8601, for example 2026-05-02T11:00:00Z).
event_cadence enum Yes Whether this signal was generated in real time or by polling. See EventCadence.
trigger_type enum Yes Whether this signal was triggered manually or automatically. See TriggerType.
order_evidence object Yes Order evidence payload with observations and/or conclusions. See OrderEvidence.

TriggerType

Value Description
TRIGGER_TYPE_MANUAL Evidence capture was explicitly triggered by a person (for example a packer tapping “capture” on a station UI).
TRIGGER_TYPE_AUTOMATIC Evidence was produced automatically by the camera, scale, or vision system.

EventCadence

Value Description
EVENT_CADENCE_REAL_TIME Signal was sent as soon as the evidence was captured or the verdict was produced.
EVENT_CADENCE_POLLED Signal was observed and sent during a periodic polling cycle.

Order Evidence

Order evidence lets your system send merchant-side evidence about an order to Uber Eats in a consistent, structured format.

Evidence is anything your system captured or concluded about what was actually prepared and packed: camera images, video, scale readings, and the verdicts your models draw from them. Uber uses these signals to validate order accuracy and to make confident, transparent chargeback and dispute decisions.

With order evidence, your integration can:

  • Publish observations: the raw things your system captured.
    • Image evidence (referenced by URL)
    • Video evidence (referenced by URL)
    • Physical measurements (for example weight, with the expected value when known)
  • Publish conclusions: the verdicts your system drew, such as defect detected or no defect detected, with a confidence score and human-readable reasons.
  • Attach evidence at order granularity, optionally narrowed to a line item or customization.
  • Link evidence to Uber’s order graph using Uber identifiers (order_uuid, store_uuid) or your own identifiers (external_order_id, external_store_id) when Uber’s are not available at capture time.
  • Attach event metadata: when the signal was generated, how it was triggered, and whether it came from a real-time push or a polling cycle.

Order evidence is carried in the order_evidence payload of the MerchantSignal envelope.

Data Model

OrderEvidence

message OrderEvidence {
  Context              context      = 1;
  repeated Observation observations = 2;
  repeated Conclusion  conclusions  = 3;
}

event_id, timestamp, trigger_type, and event_cadence come from the enclosing MerchantSignal envelope and are not repeated here.

Field Type Required Description
context object Yes The order (and optionally item or customization) the evidence is about. See Context.
observations array<Observation> Yes* Raw evidence captured about the order: media or physical measurements.
conclusions array<Conclusion> Yes* Verdicts drawn about the order.

* At least one observation or one conclusion must be present. A signal may carry both (for example an image together with the verdict derived from it) or either one alone.

Context

message Context {
  string order_uuid                        = 1;
  string item_uuid                         = 2;
  string customization_uuid                = 3;
  string store_uuid                        = 4;
  ExternalIdentifiers external_identifiers = 5;
}
Field Type Required Description
order_uuid string Required if external_identifiers is absent Uber’s unique identifier for the order. Preferred, because it joins the evidence directly to Uber’s order systems.
item_uuid string Optional Uber’s item identifier. Set when the evidence is about one line item rather than the whole order.
customization_uuid string Optional Uber’s customization identifier. Set when the evidence is about a single customization on an item.
store_uuid string Optional Uber’s store identifier. Strongly recommended on every payload so evidence is attributed to the correct location.
external_identifiers object Required if order_uuid is absent Your own identifiers, used when Uber’s are not known at capture time. See ExternalIdentifiers.

Granularity: set order_uuid alone for order-level evidence, add item_uuid for item-level evidence, and add customization_uuid as well for customization-level evidence. Item and customization identifiers narrow the scope of the evidence. They never replace the order linkage.

ExternalIdentifiers

Use these when the Uber order_uuid is not available at the time the evidence is generated, for example a camera capture keyed off the order code printed on the receipt.

message ExternalIdentifiers {
  string external_order_id = 1;
  string entity_identifier = 2;
  string external_store_id = 3;
}
Field Type Required Description
external_order_id string Yes, if external_identifiers is present Your identifier for the order, typically the short order code on the receipt (for example ORD-91821 or 945CA).
entity_identifier string Optional Your identifier for the entity the evidence is about. In practice this is the item or customization name, and should match the name printed on the receipt when available.
external_store_id string Optional Your own store or location identifier. This is distinct from Uber’s store_uuid. Recommended whenever store_uuid is not available.

If you send an external_identifiers object with any field set, external_order_id must be set. The other two fields alone cannot identify an order.

Observation

A single piece of evidence captured about the order.

message Observation {
  Source                    source      = 1;
  google.protobuf.Timestamp captured_at = 2;
  ObservationType           type        = 3;
  oneof payload {
    Media        media        = 4;
    Measurements measurements = 5;
  }
}
Field Type Required Description
source object Yes The device that captured the observation. See Source.
captured_at string Yes Time the observation was captured (ISO 8601). Distinct from the envelope timestamp, which is when the signal was generated.
type enum Yes The kind of observation: image, video, or measurement. See ObservationType.
media object Yes, when type is image or video Image or video evidence. Must be absent for measurement observations. See Media.
measurements object Yes, when type is measurement Physical measurements. Must be absent for image and video observations. See Measurements.

The payload must match the declared type. Sending measurements on an image observation, or media on a measurement observation, is rejected.

Source
Field Type Required Description
device_id string Yes Unique identifier for the camera, scale, or station that captured the evidence. Used for traceability and for isolating a misbehaving device.
Media
Field Type Required Description
url string Yes URL of the image or video asset. Signed URLs are supported, but they must stay retrievable long enough for Uber to access the asset.
Measurements

A wrapper around the list of readings. The wrapper exists because a protobuf oneof field cannot itself be repeated, which is why the JSON shows measurements nested inside measurements.

Field Type Required Description
measurements array<Measurement> Yes At least one measurement is required.
Measurement
message Measurement {
  MeasurementType type     = 1;
  string          value    = 2;
  string          expected = 3;
  UnitType        unit     = 4;
}
Field Type Required Description
type enum Yes The kind of measurement. Only MEASUREMENT_TYPE_WEIGHT is supported.
value string Yes The reading, sent as a string to preserve the exact precision your device reported (for example "412.5").
expected string Optional Your expected value for this reading, when known. Lets Uber interpret the deviation without re-deriving your baseline.
unit enum Yes The unit the reading was recorded in: grams, kilograms, or pounds. See UnitType.

Conclusion

A verdict drawn from the observations.

message Conclusion {
  ConclusionStatus status     = 1;
  float            confidence = 2;
  repeated string  reasons    = 3;
}
Field Type Required Description
status enum Yes Your verdict on the order: defect detected or no defect detected. See ConclusionStatus.
confidence float Optional Your confidence in the verdict, in the range [0, 1]. Strongly recommended.
reasons array<string> Optional Human-readable justifications for the verdict (for example "expected 3 items, detected 2"). Keep them legible: people read them, not only systems. Strongly recommended.

Evidence enums

ObservationType
Value Description
OBSERVATION_TYPE_VIDEO Video evidence, carried in media.
OBSERVATION_TYPE_IMAGE Image evidence, carried in media.
OBSERVATION_TYPE_MEASUREMENT Physical measurement evidence, carried in measurements.

OBSERVATION_TYPE_INVALID and OBSERVATION_TYPE_UNSET are not accepted. Omitting type is the same as sending OBSERVATION_TYPE_INVALID and is rejected.

ConclusionStatus
Value Description
CONCLUSION_STATUS_DEFECT_DETECTED Your system concluded the order is not correct (for example a wrong or missing item, or a weight mismatch).
CONCLUSION_STATUS_NO_DEFECT_DETECTED Your system concluded the order is correct.

CONCLUSION_STATUS_INVALID and CONCLUSION_STATUS_UNSET are not accepted. If your system did not analyze the order, send the observations without a conclusion rather than an unset verdict.

MeasurementType
Value Description
MEASUREMENT_TYPE_WEIGHT A weight reading. The only supported measurement type.
UnitType
Value Description
UNIT_TYPE_GRAMS Grams.
UNIT_TYPE_KILOGRAMS Kilograms.
UNIT_TYPE_POUNDS Pounds.

Send the unit your device actually reported. Do not convert: Uber normalizes on its side, and an unconverted reading is easier to reconcile against your own logs.

Validation Rules

A request is accepted only if every signal in it meets all of the following rules.

Envelope

  • The request is authenticated with an access token issued to your application.
  • event_id is present.
  • timestamp is present.
  • Exactly one of order_event, item_event, or order_evidence is set.

Evidence linkage

  • context.order_uuid is set, or context.external_identifiers is provided.
  • If context.external_identifiers is provided with any field set, external_identifiers.external_order_id is non-empty.

Evidence content

  • At least one observation or one conclusion is present.

Each observation

  • type is one of OBSERVATION_TYPE_IMAGE, OBSERVATION_TYPE_VIDEO, or OBSERVATION_TYPE_MEASUREMENT.
  • For image and video: media is present with a non-empty url, and measurements is absent.
  • For measurement: measurements is present with at least one entry, and media is absent.
  • Each measurement has type set to MEASUREMENT_TYPE_WEIGHT, a non-empty value, and a unit of grams, kilograms, or pounds.

Each conclusion

  • status is CONCLUSION_STATUS_DEFECT_DETECTED or CONCLUSION_STATUS_NO_DEFECT_DETECTED.

Errors

On error, the API returns an error object. The retry field tells you whether backoff and retry is appropriate for that failure.

{
  "code": "BAD_REQUEST",
  "message": "missing identifiers in order_evidence: either order_uuid or external_identifiers required",
  "retry": false
}
{
  "code": "INTERNAL_ERROR",
  "message": "failed to publish the events",
  "retry": true
}
HTTP status Code Reason
400 Bad Request BAD_REQUEST Invalid JSON, missing required fields, invalid enum values, or inconsistent payloads (for example media sent on a measurement observation).
401 Unauthorized Missing or invalid OAuth token.
403 Forbidden The application is not allowed to send signals for this resource.
500 Internal Server Error INTERNAL_ERROR Unexpected server error while processing the request. Retry with backoff.

Common validation messages

Message What to fix
missing application_id Uber could not identify your application from the access token. Use an access token issued to your application.
missing event_id Set event_id on the signal envelope.
missing timestamp Set timestamp on the signal envelope.
missing event: one of order_event, item_event or order_evidence required Set order_evidence on the signal envelope.
missing identifiers in order_evidence: either order_uuid or external_identifiers required Set context.order_uuid or context.external_identifiers.
missing external_order_id in external_identifiers You sent external_identifiers without external_order_id.
missing evidence in order_evidence: at least one observation or conclusion required The payload has neither observations nor conclusions.
missing type in observation: one of video, image or measurement required type was omitted, invalid, or unset.
missing media in media observation / missing url in media An image or video observation has no media.url.
unexpected measurements in media observation Remove measurements from an image or video observation.
unexpected media in measurement observation Remove media from a measurement observation.
missing measurements in measurement observation A measurement observation has no measurements object.
missing measurements: at least one measurement required measurements.measurements is empty.
missing type in measurement: weight required Set type to MEASUREMENT_TYPE_WEIGHT.
missing value in measurement / missing unit in measurement Set value and a supported unit.
missing status in conclusion: one of defect_detected or no_defect_detected required status was omitted, invalid, or unset.

Example Payloads

These examples show a request body for every supported evidence shape. Most use a single-signal batch for clarity. In practice you can send multiple signals in one request, as in example 6. All timestamps are in ISO 8601 format.

1. Image evidence linked by order_uuid

The preferred shape: the evidence maps directly to Uber’s order systems.

{
  "signals": [
    {
      "event_id": "evt_partner_987654321",
      "timestamp": "2026-05-02T11:00:02Z",
      "event_cadence": "EVENT_CADENCE_REAL_TIME",
      "trigger_type": "TRIGGER_TYPE_AUTOMATIC",
      "order_evidence": {
        "context": {
          "order_uuid": "a9d50317-5cb3-5bc8-910c-00dffe321a04",
          "store_uuid": "01f0c928-601a-4d46-b64b-03ed8e4888dc"
        },
        "observations": [
          {
            "source": {
              "device_id": "partner_camera_01"
            },
            "captured_at": "2026-05-02T11:00:00Z",
            "type": "OBSERVATION_TYPE_IMAGE",
            "media": {
              "url": "https://partner.example.cloud/media/signed-url-123.jpg"
            }
          }
        ],
        "conclusions": [
          {
            "status": "CONCLUSION_STATUS_NO_DEFECT_DETECTED",
            "confidence": 0.97,
            "reasons": ["all 3 expected items detected in bag"]
          }
        ]
      }
    }
  ]
}

2. Image evidence linked by external_identifiers

If Uber’s order_uuid is not available when the evidence is generated, send your own order code (the one printed on the receipt) so the signal is still attributed to the correct order.

{
  "signals": [
    {
      "event_id": "evt_partner_987654322",
      "timestamp": "2026-05-02T11:05:03Z",
      "event_cadence": "EVENT_CADENCE_REAL_TIME",
      "trigger_type": "TRIGGER_TYPE_AUTOMATIC",
      "order_evidence": {
        "context": {
          "external_identifiers": {
            "external_order_id": "ORD-91821",
            "entity_identifier": "Chicken Burrito Bowl",
            "external_store_id": "STORE-4471"
          }
        },
        "observations": [
          {
            "source": {
              "device_id": "partner_camera_02"
            },
            "captured_at": "2026-05-02T11:05:00Z",
            "type": "OBSERVATION_TYPE_IMAGE",
            "media": {
              "url": "https://partner.example.cloud/media/signed-url-456.jpg"
            }
          }
        ],
        "conclusions": [
          {
            "status": "CONCLUSION_STATUS_DEFECT_DETECTED",
            "confidence": 0.88,
            "reasons": ["expected 3 items, detected 2", "side of guacamole not visible"]
          }
        ]
      }
    }
  ]
}

3. Video evidence

{
  "signals": [
    {
      "event_id": "evt_partner_987654323",
      "timestamp": "2026-05-02T11:08:10Z",
      "event_cadence": "EVENT_CADENCE_REAL_TIME",
      "trigger_type": "TRIGGER_TYPE_AUTOMATIC",
      "order_evidence": {
        "context": {
          "order_uuid": "a9d50317-5cb3-5bc8-910c-00dffe321a04",
          "store_uuid": "01f0c928-601a-4d46-b64b-03ed8e4888dc"
        },
        "observations": [
          {
            "source": {
              "device_id": "partner_camera_01"
            },
            "captured_at": "2026-05-02T11:07:40Z",
            "type": "OBSERVATION_TYPE_VIDEO",
            "media": {
              "url": "https://partner.example.cloud/media/packing-clip-789.mp4"
            }
          }
        ]
      }
    }
  ]
}

4. Weight measurement evidence

Note the nested measurements object: the outer key is the payload, and the inner array is the list of readings.

{
  "signals": [
    {
      "event_id": "evt_partner_987654324",
      "timestamp": "2026-05-02T11:09:01Z",
      "event_cadence": "EVENT_CADENCE_REAL_TIME",
      "trigger_type": "TRIGGER_TYPE_AUTOMATIC",
      "order_evidence": {
        "context": {
          "order_uuid": "a9d50317-5cb3-5bc8-910c-00dffe321a04",
          "store_uuid": "01f0c928-601a-4d46-b64b-03ed8e4888dc"
        },
        "observations": [
          {
            "source": {
              "device_id": "partner_scale_07"
            },
            "captured_at": "2026-05-02T11:09:00Z",
            "type": "OBSERVATION_TYPE_MEASUREMENT",
            "measurements": {
              "measurements": [
                {
                  "type": "MEASUREMENT_TYPE_WEIGHT",
                  "value": "1180.5",
                  "expected": "1350",
                  "unit": "UNIT_TYPE_GRAMS"
                }
              ]
            }
          }
        ],
        "conclusions": [
          {
            "status": "CONCLUSION_STATUS_DEFECT_DETECTED",
            "confidence": 0.81,
            "reasons": ["measured weight 12.6% below expected"]
          }
        ]
      }
    }
  ]
}

5. Conclusion-only evidence

A verdict produced after the fact, for example when your model runs on a batch of captures, sent without re-sending the underlying media.

{
  "signals": [
    {
      "event_id": "evt_partner_987654327",
      "timestamp": "2026-05-02T11:20:00Z",
      "event_cadence": "EVENT_CADENCE_POLLED",
      "trigger_type": "TRIGGER_TYPE_AUTOMATIC",
      "order_evidence": {
        "context": {
          "order_uuid": "a9d50317-5cb3-5bc8-910c-00dffe321a04",
          "store_uuid": "01f0c928-601a-4d46-b64b-03ed8e4888dc"
        },
        "conclusions": [
          {
            "status": "CONCLUSION_STATUS_NO_DEFECT_DETECTED",
            "confidence": 0.95,
            "reasons": ["post-hoc review of packing clip found no discrepancy"]
          }
        ]
      }
    }
  ]
}

6. Batch of multiple evidence signals

Multiple captures for the same order, submitted in one request. Each signal carries its own event_id.

{
  "signals": [
    {
      "event_id": "evt_partner_987654328",
      "timestamp": "2026-05-02T11:30:05Z",
      "event_cadence": "EVENT_CADENCE_REAL_TIME",
      "trigger_type": "TRIGGER_TYPE_AUTOMATIC",
      "order_evidence": {
        "context": {
          "order_uuid": "7c1b0a53-1f2e-4c9a-9a44-6d3e02b7c518",
          "store_uuid": "01f0c928-601a-4d46-b64b-03ed8e4888dc"
        },
        "observations": [
          {
            "source": { "device_id": "partner_camera_03" },
            "captured_at": "2026-05-02T11:30:00Z",
            "type": "OBSERVATION_TYPE_IMAGE",
            "media": { "url": "https://partner.example.cloud/media/bag-open-001.jpg" }
          },
          {
            "source": { "device_id": "partner_camera_03" },
            "captured_at": "2026-05-02T11:30:03Z",
            "type": "OBSERVATION_TYPE_IMAGE",
            "media": { "url": "https://partner.example.cloud/media/bag-sealed-002.jpg" }
          }
        ]
      }
    },
    {
      "event_id": "evt_partner_987654329",
      "timestamp": "2026-05-02T11:30:09Z",
      "event_cadence": "EVENT_CADENCE_REAL_TIME",
      "trigger_type": "TRIGGER_TYPE_AUTOMATIC",
      "order_evidence": {
        "context": {
          "order_uuid": "7c1b0a53-1f2e-4c9a-9a44-6d3e02b7c518",
          "store_uuid": "01f0c928-601a-4d46-b64b-03ed8e4888dc"
        },
        "observations": [
          {
            "source": { "device_id": "partner_scale_09" },
            "captured_at": "2026-05-02T11:30:07Z",
            "type": "OBSERVATION_TYPE_MEASUREMENT",
            "measurements": {
              "measurements": [
                {
                  "type": "MEASUREMENT_TYPE_WEIGHT",
                  "value": "2.31",
                  "expected": "2.30",
                  "unit": "UNIT_TYPE_KILOGRAMS"
                }
              ]
            }
          }
        ],
        "conclusions": [
          {
            "status": "CONCLUSION_STATUS_NO_DEFECT_DETECTED",
            "confidence": 0.99,
            "reasons": ["measured weight within 1% of expected"]
          }
        ]
      }
    }
  ]
}

Key Data Dictionary

Field Description Requirement
event_id Unique identifier for the signal, for idempotent processing and to prevent duplicate entries. Mandatory
timestamp Time the signal was generated in your system. Mandatory
event_cadence Whether the signal was pushed in real time or produced by a polling cycle. Mandatory
trigger_type Whether the capture was triggered by a person or automatically by the device. Mandatory
order_evidence.context.order_uuid Uber’s unique identifier for the order. Required if external_identifiers is absent
order_evidence.context.external_identifiers.external_order_id Your order code, for example the short code on the receipt (945CA). Required if order_uuid is absent
order_evidence.context.external_identifiers.entity_identifier Your identifier for the entity, in practice the item or customization name as printed on the receipt. Optional
order_evidence.context.external_identifiers.external_store_id Your own store or location identifier. Recommended when store_uuid is unavailable
order_evidence.context.store_uuid Uber’s store identifier, so data is attributed to the correct location. Strongly recommended on every payload
order_evidence.context.item_uuid Uber’s item identifier, for item-level evidence. Optional
order_evidence.context.customization_uuid Uber’s customization identifier, for customization-level evidence. Optional
order_evidence.observations[].source.device_id Unique identifier for the camera or scale that captured the evidence, for traceability. Mandatory
order_evidence.observations[].captured_at Time the observation was captured, as distinct from when the signal was sent. Mandatory
order_evidence.observations[].type Kind of observation: image, video, or measurement. Mandatory
order_evidence.observations[].media.url URL of the captured image or video. Mandatory for image and video observations
order_evidence.observations[].measurements.measurements[] The list of physical readings (type, value, expected, unit). Mandatory for measurement observations
order_evidence.conclusions[].status Your verdict on the order: defect detected or no defect detected. Mandatory on every conclusion
order_evidence.conclusions[].confidence Confidence in the verdict, in the range [0, 1]. Optional, strongly recommended
order_evidence.conclusions[].reasons Human-readable justification supporting the verdict. Optional, strongly recommended

Uber

Developers
© 2026 Uber Technologies Inc.