---
title: "Evaluate"
method: POST
path: "/v2/vrp/evaluate"
tags: ["Actions"]
---

# Evaluate

`POST /v2/vrp/evaluate`

Will trigger the evaluation run asynchronously.

## Request body

- OnRouteRequest — OnRoute Request for solving, evaluating
  - `resources` Resource[], required — List of available resources (vehicles, drivers, workers) that can be assigned to perform jobs. Each resource defines their working schedules, location constraints, capacity limits, and capabilities. At least one resource is required, with a maximum of 2000 resources per request.
    - `name` string, required — Unique identifier for this resource. Used to reference the resource in job assignments, relations, and results. Must be unique within the request.
    - `shifts` Shift[], nullable, required — List of work shifts defining when this resource is available for job assignments. Each shift specifies working hours, start/end locations, breaks, and other constraints. Multiple shifts allow for multi-day planning or split-shift schedules. At least one shift is required.
      - `from` string, ISO8601 datetime string, required — Start of the shift datetime
      - `to` string, ISO8601 datetime string, required — End of the shift datetime
      - `start` object, nullable — Geographical Location in WGS-84
        - `latitude` number, double — Latitude
        - `longitude` number, double — Longitude
        - `h3Index` integer, nullable — H3 hexagon index at resolution 9 (optional)
      - `end` object, nullable — Geographical Location in WGS-84
        - `latitude` number, double — Latitude
        - `longitude` number, double — Longitude
        - `h3Index` integer, nullable — H3 hexagon index at resolution 9 (optional)
      - `ignoreTravelTimeToFirstJob` boolean, nullable — Ignore the travel time from the start location to the first order
      - `ignoreTravelTimeFromLastJob` boolean, nullable — Ignore the travel time from the last order to the optional end location
      - `overtime` unknown
      - `overtimeEnd` string, ISO8601 datetime string, nullable — Maximum overtime time.
      - `breaks` BreakDto1[], nullable — Windowed breaks definitions.
        - `type` 'WINDOWED' | 'DRIVE' | 'UNAVAILABILITY', required — Type of break that can be defined for a resource
      - `tags` string[], nullable — Shift tags will ensure that this resource can only do Jobs of this tag during this shift. This allows for tag based availability.
      - `jobTypeLimitations` object, nullable — Map of job type to maximum count allowed per shift. Null means no limitations.
    - `start` object, nullable — Geographical Location in WGS-84
      - `latitude` number, double — Latitude
      - `longitude` number, double — Longitude
      - `h3Index` integer, nullable — H3 hexagon index at resolution 9 (optional)
    - `end` object, nullable — Geographical Location in WGS-84
      - `latitude` number, double — Latitude
      - `longitude` number, double — Longitude
      - `h3Index` integer, nullable — H3 hexagon index at resolution 9 (optional)
    - `maxDriveTimeInSeconds` unknown
    - `maxDriveDistance` integer, nullable — Maximum total distance allowed for this resource per shift or planning period. This constraint prevents excessive driving and ensures compliance with regulations or operational policies. Measured in meters and includes all travel between jobs but excludes service time.
    - `region` object, nullable — Geographical Location in WGS-84
      - `latitude` number, double — Latitude
      - `longitude` number, double — Longitude
      - `h3Index` integer, nullable — H3 hexagon index at resolution 9 (optional)
    - `tags` string[], nullable — List of capability tags that define what types of jobs this resource can perform. Tags create matching constraints between jobs and resources - only resources with matching tags can be assigned to jobs that require those capabilities. For example, 'plumbing' or 'electrical' tags.
    - `category` 'CAR' | 'BIKE' | 'TRUCK', nullable — Transportation type for the resource
    - `rules` Rule[], nullable — List of periodic constraints that apply to this resource over specified time periods. Rules can enforce minimum/maximum work time, service time, drive time, or job complexity limits. These constraints ensure compliance with labor regulations, operational policies, or capacity limitations.
      - `period` object, nullable — Subset of the planning period
        - `from` string, date-time, required
        - `end` string, required — End date-time
        - `to` string, date-time, required
      - `minWorkTime` integer, nullable — Minimum work time in seconds. Work time is service time + drive/travel time.
      - `maxWorkTime` integer, nullable — Maximum work time in seconds. Work time is service time + drive/travel time.
      - `minServiceTime` integer, nullable — Minimum service time in seconds
      - `maxServiceTime` integer, nullable — Maximum service time in seconds
      - `minDriveTime` integer, nullable — Minimum drive time in seconds
      - `maxDriveTime` integer, nullable — Maximum drive time in seconds
      - `minJobComplexity` integer, nullable — Sum of the complexity of the jobs completed by this resource should reach this value
      - `maxJobComplexity` integer, nullable — Sum of the complexity of the jobs completed by this resource should not go over this value
      - `jobTypeLimitations` object, nullable — Map of job type to maximum count allowed per period. Null means no limitations.
    - `capacity` integer[], nullable — Multi-dimensional capacity limits for this resource, such as weight, volume, or item count. Each dimension corresponds to job load requirements. For example, [500, 200] might represent 500 kg weight capacity and 200 cubic meters volume capacity. Maximum 5 dimensions supported.
    - `hourlyCost` integer, nullable — Hourly cost rate for this resource in your currency units. Used to calculate total labor costs for solutions. Only counts active time (driving, servicing, or waiting), not idle time. This enables cost-based optimization and financial analysis of routing solutions.
    - `compatibleResources` string[], nullable — List of resource names that this resource is compatible to work with on linked jobs requiring cooperation
    - `maxDriveTime` integer, nullable
    - `maxDriveTimeJob` integer, nullable
  - `jobs` Job[], required — List of jobs/tasks to be assigned to resources. Each job specifies service requirements, location, time constraints, duration, and resource preferences. Jobs represent the work that needs to be scheduled and optimized. At least one job is required, with a maximum of 10,000 jobs per request.
    - `name` string, required — Unique description
    - `duration` integer, nullable — Service duration of the job
    - `location` object, nullable — Geographical Location in WGS-84
      - `latitude` number, double — Latitude
      - `longitude` number, double — Longitude
      - `h3Index` integer, nullable — H3 hexagon index at resolution 9 (optional)
    - `priority` integer, nullable — Priority level that influences job selection during optimization. Higher priority jobs are more likely to be included in the final solution when not all jobs can be assigned due to resource or time constraints. The priority is multiplied by job duration to calculate the selection weight. Particularly important when partialPlanning is enabled. Default value is 1.
    - `urgency` integer, nullable — Urgency level that influences the scheduling order of jobs. Higher urgency jobs are preferentially scheduled earlier in the day and earlier in the planning period, helping ensure time-critical tasks are completed first. This affects the sequence of job execution rather than job selection.
    - `tags` Tag[], nullable — List of skill or capability tags that define resource requirements for this job. Tags create hard or soft constraints linking jobs to resources with matching capabilities. For example, a 'plumbing' tag ensures only resources with plumbing skills can be assigned to plumbing jobs.
      - `name` string, required — Tag name that defines a skill, capability, or requirement. This creates a matching constraint between jobs and resources - only resources with this tag can be assigned to jobs that require it. Common examples include 'plumbing', 'electrical', 'certified-technician', or 'heavy-lifting'.
      - `hard` boolean, nullable — Constraint type for this tag requirement. When true (default), creates a hard constraint - jobs can only be assigned to resources with matching tags. When false, creates a soft constraint - jobs prefer resources with matching tags but can be assigned to others if needed, with a score penalty.
      - `weight` integer, nullable — Penalty weight applied when this tag constraint is violated (soft constraints only). The weight is measured in the same units as travel time - a weight of 3600 means violating this tag constraint is equivalent to 1 hour of additional travel time. Higher weights make the constraint more important.
    - `rankings` Ranking[], nullable — List of resource preference rankings for this job. Each ranking specifies a resource name and a preference score (1-100), where lower values indicate stronger preference. This allows jobs to have preferred resources while still allowing assignment to other resources if needed, with the preference reflected in the optimization score.
      - `name` string, required — Name of the resource being ranked for this job. Must exactly match a resource name defined in the request's resources list. This creates a preference relationship between the job and the specified resource.
      - `ranking` integer, nullable — Preference ranking score for this resource (1-100). Lower values indicate stronger preference - rank 1 is most preferred, rank 100 is least preferred. The solver will try to assign jobs to higher-ranked (lower-numbered) resources when possible, with the preference strength controlled by the rankingWeight in the weights configuration.
    - `proficiency` Proficiency[], nullable — List of resource proficiency modifiers for this job. Each entry specifies how efficiently a specific resource can complete this job by adjusting the effective service duration. Resources with lower durationModifier values (e.g., 0.8) complete the job faster, while higher values (e.g., 1.5) indicate slower completion.
      - `resource` string, required — Name of the resource whose proficiency is being defined. Must exactly match a resource name defined in the request's resources list.
      - `durationModifier` number, float — Multiplier applied to the job's duration when assigned to this resource. Values less than 1.0 reduce the duration (faster completion), values greater than 1.0 increase it (slower completion). For example, 0.8 means the resource completes the job 20% faster, 1.5 means 50% slower. Default is 1.0 (no modification).
    - `windows` DateWindow[], nullable — List of time windows during which this job can be started or executed. Each window defines a start and end time, creating temporal constraints for job scheduling. Multiple windows allow for flexible scheduling across different time periods. Jobs can only be assigned within these time boundaries.
      - `from` string, ISO8601 datetime string, required — Date time start of window
      - `to` string, ISO8601 datetime string, required — Date time end of window
      - `weight` integer, nullable — Weight constraint modifier
      - `hard` boolean, nullable — Hard constraint violation of DateWindow
    - `durationSquash` integer, nullable — Reduced service duration when this job is performed at the same location immediately after another job. This optimization recognizes that setup time, travel within a building, or equipment preparation may be shared between consecutive jobs at the same location. For example, if duration=600 and durationSquash=30, the second job at the same location takes only 30 seconds instead of 600.
    - `plannedDate` string, Date string, nullable — Fixed date assignment for this job that must be respected during optimization. When specified, the job can only be scheduled on this specific date, creating a hard constraint that the solver must honor. Useful for jobs that are already committed to customers or have date-specific requirements.
    - `plannedResource` string, nullable — Fixed resource assignment for this job that must be respected during optimization. When specified, only the named resource can be assigned to this job, creating a hard constraint. Combined with plannedArrival, this allows for pre-committed assignments that the solver must work around when optimizing other jobs.
    - `plannedArrival` string, ISO8601 datetime string, nullable — Fixed arrival time for this job that creates a soft constraint during optimization. The solver will try to schedule the job as close as possible to this time, with deviations penalized in the score according to the plannedWeight. This allows for customer appointment times or preferred scheduling while maintaining optimization flexibility.
    - `hard` boolean, nullable — In the case of partialPlanning planning, this indicates whether this order should be integrated into the planning or not.
    - `hardWeight` integer, nullable — In the case of partialPlanning planning, this indicates the weight of this order.
    - `padding` integer, nullable — Padding time before and after the job. In seconds
    - `load` integer[], nullable — Load
    - `allowedResources` string[], nullable — List of vehicle names that are allowed to be assigned to this order.
    - `initialResource` string, nullable — Warm start for the assigned resource: name of the vehicle to which this job is planned. Use this to speed up the solver and to start from an initial solution.
    - `initialArrival` string, ISO8601 datetime string, nullable — Warm start for the arrival time. Use this to speed up the solver and to start from an initial solution.
    - `disallowedResources` string[], nullable — List of vehicle names that are allowed to be assigned to this order.
    - `complexity` integer, nullable — Complexity of the job
    - `resumable` boolean, nullable — Enables job interruption by resource unavailability breaks. When true, the job can start before a break, pause during the break, and resume afterward. Default: false.
    - `jobTypes` string[], nullable — List of job types that this job represents. Used to enforce job type limitations per resource per timeframe.
  - `options` object, nullable — Options to tweak the routing engine
    - `euclidian` boolean, nullable — Use euclidean distance calculations for travel time and distance instead of real road networks. When true, straight-line distances are used which is faster but less accurate. When false (default), routing engines like OSM, TomTom, or Google provide real road distances and travel times.
    - `routingEngine` 'OSM' | 'TOMTOM' | 'GOOGLE' | 'ANYMAP', nullable — The routing engine to use for distance and travel time calculations
    - `partialPlanning` boolean, nullable — Allow the solver to create solutions where not all jobs are assigned to resources. When true (default), the solver will assign as many jobs as possible while respecting constraints. When false, the solver will only accept solutions where all jobs are assigned, which may result in infeasible solutions.
    - `minimizeResources` boolean, nullable — Primary optimization objective. When true, the solver prioritizes using fewer resources (vehicles/drivers) even if it increases total travel time. When false, the solver prioritizes minimizing total travel time even if it requires more resources. This fundamentally changes the optimization strategy.
    - `traffic` number, double, nullable — Global traffic multiplier applied to all travel times. A value of 1.1 increases travel times by 10% to account for traffic congestion. For real-time traffic data, use TomTom or Google routing engines. This is a simple approximation for scenarios where precise traffic data is unavailable.
    - `polylines` boolean, nullable — Generate detailed route polylines (encoded route geometries) for each trip segment. When true, the response includes polyline data that can be used to draw routes on maps. This increases processing time and response size but provides visual route information for mapping applications.
    - `fairWorkloadPerTrip` boolean, nullable — Enable workload balancing across all resources and all days/trips. When true, the solver attempts to distribute service time evenly across all resources and time periods, preventing overloading of specific resources or days. The effectiveness is controlled by `Weights.workloadSpreadWeight` and `options.workloadSensitivity`.
    - `fairWorkloadPerResource` boolean, nullable — Enable workload balancing across different days for each individual resource. When true, the solver ensures that each resource's workload is distributed evenly across their available days, preventing some days from being overloaded while others are underutilized. Works in conjunction with `Weights.workloadSpreadWeight` and `options.workloadSensitivity`.
    - `snapUnit` integer, nullable — Time granularity in seconds for arrival time snapping. All calculated arrival times are rounded up to the nearest multiple of this value. For example, with snapUnit=300 (5 minutes), an arrival time of 08:32 becomes 08:35. This helps create more practical schedules by avoiding precise timings that are difficult to follow in real operations. The snapping affects score calculation during optimization.
    - `maxSuggestions` integer, nullable — Maximum number of alternative assignment suggestions to return when using the suggestion endpoint. The solver generates multiple assignment options for unassigned jobs, ranked by quality. A value of 0 (default) returns all possible suggestions, while values 1-5 limit the results to the best alternatives. Higher values increase response time but provide more options.
    - `onlyFeasibleSuggestions` boolean, nullable — Filter suggestions based on feasibility. When true (default), only suggestions that don't violate hard constraints are returned if the initial plan is feasible. If the initial plan is infeasible, only suggestions that don't worsen the infeasibility are returned. When false, all suggestions are returned regardless of feasibility, which may include constraint violations.
    - `enableClustering` boolean — Enable geographic clustering constraint to discourage route overlap. When enabled, routes are penalized if their bounding boxes overlap, encouraging visually distinct geographic territories for each route. This is a soft constraint that promotes clearer route separation without strictly enforcing non-overlapping regions. Default: false.
    - `clusteringThresholdMeters` integer — Clustering threshold in meters defining the buffer zone around each route's bounding box. Routes whose expanded bounding boxes (including buffer) overlap will be penalized based on their actual overlap area. This threshold acts as a proximity trigger - routes should ideally stay at least this distance apart. Default: 10000 meters (10km).
    - `jobProximityRadius` integer, nullable — Proximity radius in meters for grouping jobs as neighbors. Jobs within this distance of each other are considered neighbors for proximity-based constraints and optimizations. When set, the solver can leverage geographic proximity patterns to optimize routing decisions.
    - `jobProximityDistanceType` 'REAL' | 'HAVERSINE', nullable — The type of distance calculation to use for job proximity calculations
    - `workloadSensitivity` number, double, nullable
    - `explanation` ExplanationOptions — Options to manage the explanation of the solution
      - `enabled` boolean, nullable — When enabled the explanation will contain a map of all the alternative positions for each job
      - `filterHardConstraints` boolean, nullable — When true the map of alternative positions will contain only feasible alternatives
      - `onlyUnassigned` boolean, nullable
    - `fairComplexityPerTrip` boolean, nullable
    - `fairComplexityPerResource` boolean, nullable
  - `weights` object, nullable — OnRoute Weights
    - `priorityWeight` integer, nullable — Weight modifier for job priority constraints. Higher values make the solver more likely to include high-priority jobs in the solution when not all jobs can be assigned. This affects job selection probability but not scheduling order. The weight is multiplied by the job's priority value and duration.
    - `workloadSpreadWeight` integer, nullable — Weight modifier for workload balancing across resources and time periods. Higher values make the solver more aggressive about equalizing service time distribution. Works with fairWorkloadPerTrip and fairWorkloadPerResource options, and is sensitive to the workloadSensitivity parameter.
    - `travelTimeWeight` integer, nullable — Weight modifier for total travel time optimization. This is the baseline weight (typically 1) against which all other weights are compared. Higher values make the solver more aggressive about minimizing travel time, potentially at the expense of other objectives.
    - `plannedWeight` integer, nullable — Weight modifier for deviations from planned arrivals and resource assignments. Higher values make the solver more reluctant to deviate from plannedArrival times and plannedResource assignments. This is crucial for maintaining customer appointments and commitments.
    - `asapWeight` integer, nullable — Weight modifier for scheduling jobs as early as possible within their time windows and resource availability. Higher values push jobs toward the beginning of shifts and planning periods, useful for front-loading work or maximizing completion rates.
    - `minimizeResourcesWeight` integer, nullable — Weight modifier for minimizing the number of active resources per day/trip. The weight is measured in the same units as travel time - a weight of 3600 means using an additional resource is equivalent to 1 hour of travel time. Higher values encourage consolidation of jobs onto fewer resources.
    - `allowedResourcesWeight` integer, nullable — Weight modifier for soft violations of resource assignment constraints. When jobs have allowedResources restrictions and they cannot be satisfied as hard constraints, this weight determines the penalty for assigning jobs to non-allowed resources.
    - `waitTimeWeight` integer, nullable — Weight modifier for total waiting time across all resources. Waiting time occurs when resources arrive at jobs before their time windows open or when they have idle time between jobs. Higher values make the solver more aggressive about minimizing idle time.
    - `urgencyWeight` integer, nullable — Weight modifier for job urgency constraints. Higher values make the solver more aggressive about scheduling urgent jobs earlier in the day and planning period. This affects the sequence and timing of job execution based on their urgency values.
    - `driveTimeWeight` integer, nullable — Weight modifier for total driving time across all resources. Similar to travelTimeWeight but focuses specifically on driving time violations or constraints. Higher values make the solver more concerned with minimizing driving time, useful for fuel efficiency or driver fatigue management.
    - `rankingWeight` integer, nullable — Weight modifier for resource ranking preferences defined in job rankings. Higher values make the solver more aggressive about assigning jobs to their preferred (lower-ranked) resources, even if it increases travel time or other costs. This helps maintain service quality by using optimal resource assignments.
    - `clusteringWeight` integer, nullable — Weight modifier for geographic clustering constraint. Controls the penalty for route bounding box overlaps when clustering is enabled. Higher values more strongly discourage routes from overlapping in geographic space, promoting clearer territorial separation. The penalty is multiplied by this weight before being applied to the score.
    - `jobProximityWeight` integer, nullable — Weight modifier for separating jobs that are geographically close to each other. When jobProximityRadius is set in options, this weight penalizes consecutive scheduling of jobs within that radius to different resources or non-consecutive scheduling. Higher values encourage grouping nearby jobs together in the same route segment.
  - `hook` string, uri, nullable — Optional webhook URL that will receive a POST request with the job ID when the optimization is complete. This enables asynchronous processing where you can submit a request and be notified when results are ready, rather than waiting for the synchronous response.
  - `customDistanceMatrices` object, nullable — Custom distance matrix configuration for multi-profile and multi-slice scenarios
    - `profileMatrices` object, nullable — Map of vehicle profile names (CAR, BIKE, TRUCK) to time slice hour mappings. Each time slice hour maps to a matrix ID that should be fetched from the distance matrix service. Time slice hours correspond to: 6=MORNING_RUSH, 9=MORNING, 12=MIDDAY, 14=AFTERNOON, 16=EVENING_RUSH, 20=NIGHT.
    - `matrixServiceUrl` string, nullable — Optional URL for external distance matrix service endpoint. If not provided, uses the default system service.
  - `label` string, nullable
  - `relations` Relation[], nullable
    - `type` 'SAME_TRIP' | 'SEQUENCE' | 'DIRECT_SEQUENCE' | 'SAME_TIME' | 'NEIGHBOR' | 'PICKUP_AND_DELIVERY' | 'SAME_RESOURCE' | 'SAME_DAY' | 'GROUP_SEQUENCE', required — Type of relation between jobs
    - `jobs` string[], required — List of job names involved in this relation. For sequence-based relations, the order matters - jobs will be executed in the order specified. For other relations, order may be irrelevant. All job names must exist in the request's jobs list.
    - `resource` string, nullable — Optional resource constraint for this relation. When specified, all jobs in the relation must be assigned to this specific resource. This creates a hard constraint that can help enforce resource-specific workflows or capabilities.
    - `minTimeInterval` integer, nullable — Minimum time interval in seconds that must pass between consecutive jobs in sequence relations. This ensures adequate time for travel, setup, or processing between related jobs. Only applies to SEQUENCE, DIRECT_SEQUENCE, and SAME_TIME relations.
    - `maxTimeInterval` integer, nullable — Maximum time interval in seconds allowed between consecutive jobs in sequence relations. This prevents excessive delays between related jobs and ensures timely completion of job sequences. Only applies to SEQUENCE, DIRECT_SEQUENCE, and SAME_TIME relations.
    - `partialPlanning` boolean — Allows the solver to include only some jobs from this relation in the final solution when the full relation cannot be satisfied due to constraints. When false, either all jobs in the relation are assigned or none are, maintaining the relation's integrity.
    - `maxWaitingTime` integer, nullable — Maximum waiting time in seconds between jobs in a SAME_TIME relation. This defines how much time synchronization tolerance is allowed - jobs can start within this time window of each other. Defaults to 1200 seconds (20 minutes) if not specified.
    - `timeInterval` 'FROM_ARRIVAL' | 'FROM_DEPARTURE', required — Determines if the time interval between jobs should be measured from arrival or departure
    - `tags` string[], nullable — List of tag names used to define job groups in GROUP_SEQUENCE relations. Jobs with matching tags form groups that must be executed in sequence. This allows for complex sequencing rules based on job characteristics rather than explicit job names.
    - `enforceCompatibility` boolean — When true, enforces resource compatibility checking for SAME_TIME relations. Only compatible resources can work together on linked jobs.
    - `hardMinWait` boolean — When true (default), the minimum time interval constraint is enforced as a hard constraint. When false, it becomes a soft constraint that can be violated with penalty. Useful for SEQUENCE and SAME_TIME relations where timing flexibility is acceptable.
    - `weight` integer, nullable — Weight modifier for this relation. This can be used to modify the weight of a relation to make it more or less important than other relations.

## Response `200`

Status

- SolviceStatusJob — Status of a solve job
  - `id` string, required — Job ID
  - `status` 'QUEUED' | 'SOLVING' | 'SOLVED' | 'ERROR', nullable — Status of the solve.
  - `solveDuration` integer, nullable — Duration of the solve in seconds
  - `errors` Message[], nullable — List of errors
    - `code` integer — Error code
    - `message` string, required — Error message
  - `warnings` Message[], nullable — List of warnings
    - `code` integer — Error code
    - `message` string, required — Error message

## Other responses

- `400` — Bad request
- `427` — Too many requests.
- `500` — Internal error

## Changes

- **2026-01-18** `d77ac8b3d302` — 5 warning
  - the `jobs/items/urgency` request property's min was set to `0.00`
  - changed the pattern of the request property `jobs/items/name` from `^[^<>"';`\\]*$` to `^(?!.*\$\{)[^<>"';`\\]*$`
  - changed the pattern of the request property `jobs/items/rankings/items/name` from `^[^<>"';`\\]*$` to `^(?!.*\$\{)[^<>"';`\\]*$`
  - changed the pattern of the request property `jobs/items/tags/items/name` from `^[^<>"';`\\]*$` to `^(?!.*\$\{)[^<>"';`\\]*$`
  - …1 more
- **2026-01-17** `97e1f293a7ee` — 5 breaking, 9 warning
  - added the pattern `^(?!.*\$\{).*$` to the request property `label`
  - added the pattern `^[^<>"';`\\]*$` to the request property `jobs/items/name`
  - added the pattern `^[^<>"';`\\]*$` to the request property `jobs/items/rankings/items/name`
  - added the pattern `^[^<>"';`\\]*$` to the request property `jobs/items/tags/items/name`
  - …10 more
- **2025-12-23** `143dcd1fff82` — 1 info
  - added the new optional request property `jobs/items/proficiency`
- …earlier changes not shown

[Full history](https://skmtc.dev/solvice/apis/vrp-api/changes/v2/vrp/evaluate/post.md)

---

[API](https://skmtc.dev/solvice/apis/vrp-api.md) · [All operations](https://skmtc.dev/solvice/apis/vrp-api/llms.txt) · [OpenAPI document](https://skmtc-service-production.skmtc.workers.dev/v1/apis/solvice/vrp-api/revisions/d77ac8b3d302/schema)