freightutils-mcp

endpoint

https://www.freightutils.com/api/mcp also at https://www.freightutils.com/api/mcp/mcp

door code

22f5e2f2204946d3

protocol

http-sse ·2025-06-18

authentication

none observed

public key

none — nobody has proven they own this listing · is it yours? claim it

karma

0 · newcomer

Is freightutils-mcp live?

Yes — it answered the hub's last check (checked 2h ago). It answered 100% of checks over the last 30 days.

Is freightutils-mcp free to use?

Yes — the hub reached it with no key and no payment.

What tools does freightutils-mcp have?

26 tools: cbm_calculator, ldm_calculator, chargeable_weight_calculator, resolve_reference, unit_converter, adr_lq_eq_check, emissions_calculator, ics2_check, ….

Is freightutils-mcp safe to connect?

The hub found no text in its card or tool descriptions aimed at the agent reading them. It measures what the server answers, not its code — grant it only the access its tools need.

Price is per tool, not per server. An agent whose handshake is open can hold tools that demand a key or a payment, and one figure for the whole agent sends callers into a wall.

• validate reads open 20h ago

  Validate and parse freight identifiers by their public check-digit algorithms: shipping container numbers (ISO 6346), air waybill (AWB) numbers (IATA modulus-7) and IMO ship identification numbers. Two modes: pass text=<arbitrary string> to find and validate every identifier in it (e.g. a booking-email line), OR pass value=<identifier> + type=<container|awb|imo> to validate one. Behavior: deterministic check-digit arithmetic; per identifier found it reports type, the normalised form, valid (pass/fail), expected vs actual check digit, and details (container: owner prefix + equipment category; AWB: airline prefix + the airline from the AWB-prefix dataset when ONE record holds the prefix — when several do (e.g. 020: Lufthansa and Lufthansa Cargo), airline is null and airline_candidates[] lists every holder with airline_note saying why, never a guessed carrier; IMO: the 7-digit number); text mode with no identifiers found returns an empty found[] with a note. Rate-limited: a limit error carries reset_at, the UTC time the allowance resets. Returns: found[] (each entry with its own _source naming the standard applied) and disclaimer under result, plus confidence, _source and citation (the FreightUtils v1 response envelope). Limitations: STRUCTURAL ONLY — a valid check digit means well-formed, NOT that the container, shipment or vessel exists or is active; not a registry or tracking lookup. Related: container_lookup (container TYPE specs, not numbers), airline_lookup (the AWB-prefix dataset the airline resolution uses).

  mcp-tool

  123456789101112131415161718192021222324252627282930313233

  {
    "type": "object",
    "$schema": "http://json-schema.org/draft-07/schema#",
    "properties": {
      "text": {
        "type": "string",
        "description": "Arbitrary string to scan for container / AWB / IMO identifiers (parse mode). Provide this OR value+type."
      },
      "type": {
        "enum": [
          "container",
          "awb",
          "imo",
          "consignment"
        ],
        "type": "string",
        "description": "Identifier type for value: container = ISO 6346, awb = IATA Air Waybill, imo = IMO ship number; or \"consignment\" with the consignment argument."
      },
      "value": {
        "type": "string",
        "description": "A single identifier to validate (typed mode). Requires type."
      },
      "consignment": {
        "type": "object",
        "description": "With type \"consignment\": the consignment object to validate (https://www.freightutils.com/schema/consignment-object.v1.json). The answer says whether it is valid and which checks it carries the inputs for.",
        "propertyNames": {
          "type": "string"
        },
        "additionalProperties": {}
      }
    },
    "additionalProperties": false
  }

  arguments 33 lines copy
• adr_lookup reads open 25h ago

  Look up the full European road dangerous-goods (ADR 2025) Table A entry for a substance — all 20 columns, from class, packing group and labels through special provisions, limited/excepted quantities, packing instructions, tank codes, carriage provisions, transport category, tunnel restriction code and hazard identification number — and what each of those codes means (resolved_codes). Covers 2,939 entries across all 9 hazard classes, from UNECE ADR 2025 (ECE/TRANS/352). Provide exactly ONE of: un_number (exact lookup — returns every packing-group variant of that UN number), search (case-insensitive partial match on the proper shipping name), or hazard_class (all entries in a class or division). un_number is normalised — "1203", "UN1203" and "un 1203" are equivalent, and normalized_input reports the correction; explosives keep their leading zero ("0004"). Behavior: read-only reference lookup; a name search or class filter is a paged list — total, truncated and next_offset, with offset and limit (at most 50 per search page, 100 per class page) — never a silently cut list. A search with no hits errors with suggestions: the closest proper shipping names in Table A ("acetne" → ACETONE, UN 1090). 28 Table A rows carry a scope remark instead of a packing group: those return packing_group null plus not_subject_to_adr (with conditions_ref, e.g. "5.5.3" for UN 1845 dry ice) or carriage_prohibited, and table_a_remark preserves the verbatim Table A text. Rate-limited: a limit error carries reset_at, the UTC time the allowance resets. Returns: count and results[] — per entry, all 20 Table A columns: un_number, proper_shipping_name, class, classification_code, packing_group, labels, special_provisions, limited_quantity, excepted_quantity, packing_instructions, special_/mixed_packing_provisions, portable_tank_instructions/_special_provisions, tank_code, tank_special_provisions, vehicle_for_tank_carriage, carriage_packages/_bulk/_loading_unloading_handling/_operation, transport_category, tunnel_restriction_code, hazard_identification_number, variant_index/variant_count and, on scope-flagged rows, not_subject_to_adr/carriage_prohibited/conditions_ref/table_a_remark — plus resolved_codes[] beside results[]: one entry per distinct code in columns (5)–(20) across the answer, with its code, family, columns, rows (the results[] indexes that carry it), summary, ADR section and verification_status (include_codes "full" adds url, title, meaning, parameters, applies_to, references; "none" omits the list; default compact for un_number, none for search, hazard_class and un_numbers; a code's page is https://www.freightutils.com/adr/codes/{family}/{code}). The meanings are FreightUtils' paraphrases of ADR 2025, cited to section and page; verification_status says how each one has been reviewed, in the registry's own words: paraphrase_unreviewed (not yet reviewed), machine_reviewed (two independent readings of the UNECE text, compared with the record; the owner adjudicates every disagreement), contested (the readings disagree and no person has reviewed it yet), owner_reviewed (the owner's ok), dg_reviewed (the owner's and the DG reviewer's ok), needs_fix (the latest review asks for a fix), or verified on the transport category and tunnel code entries, which are read from the 1.1.3.6.3 and 8.6.4 tables — under result, plus confidence, _source and citation (the FreightUtils v1 response envelope). Editions: edition ("2025" | "2027") and as_of (YYYY-MM-DD) choose the ADR edition — edition wins, else the date picks it (ADR 2025 before 2027-01-01, ADR 2027 from then; ADR 2025 may still be applied until 2027-06-30). An answer on a named edition carries adr_edition; neither sent, the answer is ADR 2025 until 2027-01-01. Limitations: a factual compilation of the ADR table, not legal or compliance advice; classification remains the consignor's responsibility — verify against the current UNECE ADR text. Related: adr_lq_eq_check (checks quantities against the LQ/EQ values returned here), adr_exemption_calculator (1.1.3.6 small-load points), consignment_calculator (flags dangerous-goods lines by UN number). Identifiers: Each record carries fu_id, a stable FreightUtils identifier (and fu_version_id where the dataset has editions); resolve_reference resolves one to exactly its record.

  mcp-tool

  12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970

  {
    "type": "object",
    "$schema": "http://json-schema.org/draft-07/schema#",
    "properties": {
      "as_of": {
        "type": "string",
        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
        "description": "YYYY-MM-DD the answer is for (default today, UTC); picks the ADR edition when edition is omitted, and is echoed in the answer and its check receipt."
      },
      "limit": {
        "type": "integer",
        "maximum": 100,
        "minimum": 1,
        "description": "search / hazard_class only: rows per page (default 10; at most 50 for search, 100 for hazard_class)."
      },
      "offset": {
        "type": "integer",
        "maximum": 9007199254740991,
        "minimum": 0,
        "description": "search / hazard_class only: rows to skip (default 0). The response gives total and next_offset."
      },
      "search": {
        "type": "string",
        "maxLength": 200,
        "minLength": 2,
        "description": "Case-insensitive partial match on the proper shipping name (2 to 200 characters). Example: \"acetone\"."
      },
      "edition": {
        "enum": [
          "2025",
          "2027"
        ],
        "type": "string",
        "description": "ADR edition: \"2025\" or \"2027\". Wins over as_of. Omit it and as_of picks the edition by the legal timeline: before 2027-01-01 ADR 2025; from 2027-01-01 ADR 2027 (ADR 2025 may still be applied until 2027-06-30 under 1.6.1.1 — edition \"2025\" answers on it until then); from 2027-07-01 ADR 2027 only. An ADR 2027 answer for a date before 2027-01-01 carries an EDITION_NOT_YET_APPLICABLE warning."
      },
      "un_number": {
        "type": "string",
        "pattern": "^\\s*(?:UN\\s*)?\\d{4}\\s*$",
        "description": "Exact UN number — 4 digits, optionally \"UN\"-prefixed; explosives keep their leading zero. Examples: \"1203\", \"UN1203\", \"UN 1203\", \"0004\"."
      },
      "un_numbers": {
        "type": "array",
        "items": {
          "type": "string",
          "maxLength": 12
        },
        "maxItems": 50,
        "minItems": 1,
        "description": "Batch: up to 50 UN numbers, answered in one call as results[] in input order, each as its own un_number lookup with its own status. Send alone (include_codes may go beside it)."
      },
      "hazard_class": {
        "type": "string",
        "description": "Filter by ADR hazard class (Table A column (3a)). Examples: \"3\" (flammable liquids), \"6.1\" (toxic), \"8\" (corrosive), \"1\" (explosives — the division and compatibility group are in classification_code, e.g. \"1.4S\")."
      },
      "include_codes": {
        "enum": [
          "none",
          "compact",
          "full"
        ],
        "type": "string",
        "description": "include_codes: \"none\" | \"compact\" | \"full\" — resolved_codes beside results[]: one entry per distinct code in Table A columns (5)–(20) across the answer, with its meaning in FreightUtils' own words (code, family, columns, rows = the results[] indexes that carry it, summary, section, verification_status; \"full\" adds url, title, meaning, parameters, applies_to, references; a code's page is https://www.freightutils.com/adr/codes/{family}/{code}). Default \"compact\" for a un_number lookup, \"none\" for search, hazard_class and un_numbers batches."
      },
      "include_statements": {
        "type": "boolean",
        "description": "true adds statements[] to every row: short plain-word statements (tunnel, transport category, labels, packing, tanks, carriage) assembled from the code meanings and the 8.6.4 / 1.1.3.6.3 tables, each with its basis, codes and verification_status (the lowest of the codes it draws on). Default false."
      }
    },
    "additionalProperties": false
  }

  arguments 70 lines copy
• vehicle_lookup reads open 20h ago

  Look up road-freight vehicle and trailer specifications — 17 types: EU articulated trailers (standard/mega curtainsider, box, reefer, double-deck, flatbed, low-loader), US 53ft/48ft dry vans, rigid trucks (7.5-26 t) and vans (Luton, Transit, Sprinter). Each record carries internal dimensions, payload and gross weights, euro/UK pallet capacity, axle configuration and features. Provide slug (e.g. "standard-curtainsider") for one record; omit it to list all 17; category (articulated | rigid | van) and region (EU | US) filter the list. Behavior: read-only; an unknown slug errors with the valid list and the closest slugs; a single record carries its provenance (sources, audited_at, decision_rationale). A list (no single record asked for) returns summary rows with total, truncated, next_offset and detail_hint; full: true returns full records five per page, with offset / limit to page. Rate-limited: a limit error carries reset_at, the UTC time the allowance resets. Returns: the vehicle record (or the list) under result, plus confidence, _source and citation (the FreightUtils v1 response envelope). Field names as this package serves them (snake_case); the hosted /api/mcp endpoint serves the same fields in camelCase (e.g. total_cbm → totalCbm). Limitations: typical specs, provenance pending independent verification (the envelope's provenance_status says so) — real equipment varies by operator and build; legal payload is set by the vehicle's plated weights. Related: ldm_calculator (whether a pallet load fits), pallet_fitting_calculator, consignment_calculator. Identifiers: Each record carries fu_id, a stable FreightUtils identifier (and fu_version_id where the dataset has editions); resolve_reference resolves one to exactly its record.

  mcp-tool

  123456789101112131415161718192021222324252627282930313233343536373839404142434445

  {
    "type": "object",
    "$schema": "http://json-schema.org/draft-07/schema#",
    "properties": {
      "full": {
        "type": "boolean",
        "description": "Lists only: true returns full records (provenance, sources, rationale) instead of summary rows. A single-record call always returns the full record."
      },
      "slug": {
        "type": "string",
        "minLength": 2,
        "description": "Vehicle slug (e.g., \"standard-curtainsider\"). Omit to list all."
      },
      "limit": {
        "type": "integer",
        "maximum": 100,
        "minimum": 1,
        "description": "Lists only: rows per page (default: every row for summaries; 5 with full: true)."
      },
      "offset": {
        "type": "integer",
        "maximum": 9007199254740991,
        "minimum": 0,
        "description": "Lists only: rows to skip (default 0). The response gives total and next_offset."
      },
      "region": {
        "enum": [
          "EU",
          "US"
        ],
        "type": "string",
        "description": "Filter by region"
      },
      "category": {
        "enum": [
          "articulated",
          "rigid",
          "van"
        ],
        "type": "string",
        "description": "Filter by category"
      }
    },
    "additionalProperties": false
  }

  arguments 45 lines copy
• container_lookup reads open 15h ago

  Get ISO shipping-container specifications, with optional load-fit maths. Covers 10 types: 20ft/40ft standard, 40ft and 45ft high-cube, 20ft/40ft reefer, 20ft/40ft open-top and 20ft/40ft flat-rack. Provide type as a slug (e.g. "20ft-standard", "40ft-high-cube") for one container's record; omit it to list all 10 as summary rows (full: true for full records). Add item dimensions (item_length_cm/width_cm/height_cm, optional item_weight_kg and item_quantity) to also compute how many such items fit. Behavior: read-only reference data with per-record provenance (sources, audited_at, decision_rationale); type is read in any letter case, as the ISO size-type code ("45G1") or the short form of its name ("40HC"); an unknown type errors with the valid slugs and the closest one ("20ft-standrd" → 20ft-standard). Fit calculations are geometric best-effort — they do not model load distribution, securing or mixed cargo. Rate-limited: a limit error carries reset_at, the UTC time the allowance resets. Returns: the container record — internal/external/door dimensions (cm), capacity_cbm, tare_weight_kg, max_gross_kg, max_payload_kg and euro/GMA pallet counts — under result, plus confidence, _source and citation (the FreightUtils v1 response envelope). Field names as this package serves them (snake_case); the hosted /api/mcp endpoint serves the same fields in camelCase (e.g. total_cbm → totalCbm). A list (no single record asked for) returns summary rows with total, truncated, next_offset and detail_hint; full: true returns full records five per page, with offset / limit to page. Limitations: manufacturer-typical specs, provenance pending independent verification (the envelope's provenance_status says so) — actual equipment varies by lessor and line; confirm against the carrier's equipment guide. Related: validate (checks a container NUMBER's ISO 6346 check digit — not specs), cbm_calculator / consignment_calculator (the cargo volume to fill it), uld_lookup (the air-freight equivalent). Identifiers: Each record carries fu_id, a stable FreightUtils identifier (and fu_version_id where the dataset has editions); resolve_reference resolves one to exactly its record.

  mcp-tool

  123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354

  {
    "type": "object",
    "$schema": "http://json-schema.org/draft-07/schema#",
    "properties": {
      "full": {
        "type": "boolean",
        "description": "Lists only: true returns full records (provenance, sources, rationale) instead of summary rows. A single-record call always returns the full record."
      },
      "type": {
        "type": "string",
        "minLength": 2,
        "description": "Container slug (e.g., \"20ft-standard\", \"40ft-high-cube\"). Omit to list all."
      },
      "limit": {
        "type": "integer",
        "maximum": 100,
        "minimum": 1,
        "description": "Lists only: rows per page (default: every row for summaries; 5 with full: true)."
      },
      "offset": {
        "type": "integer",
        "maximum": 9007199254740991,
        "minimum": 0,
        "description": "Lists only: rows to skip (default 0). The response gives total and next_offset."
      },
      "item_quantity": {
        "type": "integer",
        "maximum": 9007199254740991,
        "description": "Load fit: number of items (default 1).",
        "exclusiveMinimum": 0
      },
      "item_width_cm": {
        "type": "number",
        "description": "Load fit: item width in cm.",
        "exclusiveMinimum": 0
      },
      "item_height_cm": {
        "type": "number",
        "description": "Load fit: item height in cm.",
        "exclusiveMinimum": 0
      },
      "item_length_cm": {
        "type": "number",
        "description": "Load fit: item length in cm (with item_width_cm and item_height_cm, and type).",
        "exclusiveMinimum": 0
      },
      "item_weight_kg": {
        "type": "number",
        "minimum": 0,
        "description": "Load fit: weight of ONE item in kg (default 0 — no weight check)."
      }
    },
    "additionalProperties": false
  }

  arguments 54 lines copy
• incoterms_lookup reads open 13h ago

  Look up the 11 Incoterms 2020 trade rules — who pays for transport, insurance and customs clearance, and where risk transfers from seller to buyer. 7 rules work for any transport mode (EXW, FCA, CPT, CIP, DAP, DPU, DDP); 4 are sea/inland-waterway only (FAS, FOB, CFR, CIF). Provide code for one rule, category (any_mode | sea_only) for a filtered list, or neither to list all 11 (a list is summary rows — code, name, category, summary — with full: true for the full rules). Behavior: read-only reference; an unknown code errors with the valid code list, and DAT — replaced in Incoterms 2020 — names its successor, DPU (ICC). Rate-limited: a limit error carries reset_at, the UTC time the allowance resets. Returns: the rule record — name, category, summary, seller_responsibility, buyer_responsibility, risk_transfer, cost_transfer, insurance, export/import clearance, best_for and watch_out — under result, plus confidence, _source and citation (the FreightUtils v1 response envelope). Limitations: summarised guidance on ICC Incoterms 2020; the ICC publication is the binding text and specific contract wording prevails. Related: uk_duty_calculator (accepts an incoterm when composing the CIF value), shipment_summary (composite analysis). Identifiers: Each record carries fu_id, a stable FreightUtils identifier (and fu_version_id where the dataset has editions); resolve_reference resolves one to exactly its record.

  mcp-tool

  123456789101112131415161718192021222324252627282930313233343536

  {
    "type": "object",
    "$schema": "http://json-schema.org/draft-07/schema#",
    "properties": {
      "code": {
        "type": "string",
        "pattern": "^[A-Za-z]{3}$",
        "description": "Incoterm code (3 letters, e.g., \"FOB\", \"CIF\")"
      },
      "full": {
        "type": "boolean",
        "description": "Lists only: true returns full records (provenance, sources, rationale) instead of summary rows. A single-record call always returns the full record."
      },
      "limit": {
        "type": "integer",
        "maximum": 100,
        "minimum": 1,
        "description": "Lists only: rows per page (default: every row for summaries; 5 with full: true)."
      },
      "offset": {
        "type": "integer",
        "maximum": 9007199254740991,
        "minimum": 0,
        "description": "Lists only: rows to skip (default 0). The response gives total and next_offset."
      },
      "category": {
        "enum": [
          "any_mode",
          "sea_only"
        ],
        "type": "string",
        "description": "Filter by mode"
      }
    },
    "additionalProperties": false
  }

  arguments 36 lines copy
• cbm_calculator reads unknown 11h ago

  Calculate cubic metres (CBM) for a shipment from per-piece dimensions. CBM is the standard volume unit in international shipping: 1 CBM = 1m x 1m x 1m = 1,000 litres, and ocean freight prices per "freight tonne" (1 CBM or 1,000 kg, whichever is greater). Behavior: deterministic — identical inputs always return identical figures; total volume = pieces x per-piece CBM (totals are computed from unrounded figures and rounded only for display), with conversions to cubic feet, cubic inches and litres (exact factors: 1 ft = 0.3048 m). Missing or non-positive dimensions error with a validation message naming the parameter. Rate-limited: a limit error carries reset_at, the UTC time the allowance resets. Returns: cbm_per_piece, total_cbm, cubic_feet, litres, cubic_inches and pieces under result, plus confidence, _source and citation (the FreightUtils v1 response envelope). Field names as this package serves them (snake_case); the hosted /api/mcp endpoint serves the same fields in camelCase (e.g. total_cbm → totalCbm). Related: chargeable_weight_calculator (air billing weight from the same dims), consignment_calculator (multi-line totals), unit_converter (single conversions), shipment_summary (full composite analysis).

  mcp-tool

  123456789101112131415161718192021222324252627282930313233

  {
    "type": "object",
    "$schema": "http://json-schema.org/draft-07/schema#",
    "required": [
      "length_cm",
      "width_cm",
      "height_cm"
    ],
    "properties": {
      "pieces": {
        "type": "integer",
        "maximum": 9007199254740991,
        "description": "Number of identical pieces (default: 1)",
        "exclusiveMinimum": 0
      },
      "width_cm": {
        "type": "number",
        "description": "Width in centimetres",
        "exclusiveMinimum": 0
      },
      "height_cm": {
        "type": "number",
        "description": "Height in centimetres",
        "exclusiveMinimum": 0
      },
      "length_cm": {
        "type": "number",
        "description": "Length in centimetres",
        "exclusiveMinimum": 0
      }
    },
    "additionalProperties": false
  }

  arguments 33 lines copy
• ldm_calculator reads unknown 13h ago

  Calculate loading metres (LDM) for European road freight — how much trailer length a pallet load occupies. 1 LDM = 1 linear metre of a 2.4m-wide trailer; a standard artic is 13.6 LDM. Provide a pallet preset OR custom length_mm + width_mm — omitting both errors with a usage hint. Behavior: deterministic; stackable=true with stack_height 2 or 3 divides the floor footprint accordingly; fits is true only when the load fits the vehicle's LENGTH, its pallet FLOOR POSITIONS and — when weight_kg is given — its max PAYLOAD; each failed limit is named in warnings[] with its numbers. Euro and UK pallets count as their own floor positions (pallet_spaces.basis says which), other footprints as Euro equivalents. The vehicle's floor positions are its record's own count only when that count is a floor count; a weight-limited or unverified count (the 7.5t rigid stores 8, its 6.1 x 2.4 m deck holds 15) is not, and the positions come from the deck instead — pallet_spaces.floor_positions_basis says which, record_count is the stored figure. Without weight_kg the payload is not checked: payload_checked is false and an info warning gives the payload. utilisation_percent is of the vehicle's length. Rate-limited: a limit error carries reset_at, the UTC time the allowance resets. Returns: ldm, vehicle (name, length_m, max_payload_kg), utilisation_percent, pallet_spaces (used, available, basis, floor_positions_basis, floor_positions_note, record_count, record_count_basis), total_weight_kg, payload_checked, fits and warnings under result, plus confidence, _source and citation (the FreightUtils v1 response envelope). Field names as this package serves them (snake_case); the hosted /api/mcp endpoint serves the same fields in camelCase (e.g. total_cbm → totalCbm). Related: vehicle_lookup (the trailer specs behind the vehicle presets), pallet_fitting_calculator (boxes onto one pallet), consignment_calculator (mixed lines including LDM).

  mcp-tool

  123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566

  {
    "type": "object",
    "$schema": "http://json-schema.org/draft-07/schema#",
    "properties": {
      "pallet": {
        "enum": [
          "euro",
          "uk",
          "half",
          "quarter"
        ],
        "type": "string",
        "description": "Pallet preset"
      },
      "vehicle": {
        "enum": [
          "artic",
          "rigid10",
          "rigid75",
          "luton",
          "us53",
          "us48",
          "custom"
        ],
        "type": "string",
        "description": "Vehicle type. DEPRECATED: rigid10 (removal in 3.0.0) — its 10 m length is published by no manufacturer; use custom with vehicle_length_m, or artic."
      },
      "quantity": {
        "type": "integer",
        "maximum": 9007199254740991,
        "description": "Number of pallets (default: 1)",
        "exclusiveMinimum": 0
      },
      "width_mm": {
        "type": "number",
        "description": "Custom pallet width in mm",
        "exclusiveMinimum": 0
      },
      "length_mm": {
        "type": "number",
        "description": "Custom pallet length in mm",
        "exclusiveMinimum": 0
      },
      "stackable": {
        "type": "boolean",
        "description": "Can pallets be stacked?"
      },
      "weight_kg": {
        "type": "number",
        "description": "Weight per pallet in kg",
        "exclusiveMinimum": 0
      },
      "stack_height": {
        "type": "integer",
        "maximum": 3,
        "minimum": 2,
        "description": "Stack height 2 or 3"
      },
      "vehicle_length_m": {
        "type": "number",
        "description": "Custom vehicle length in m",
        "exclusiveMinimum": 0
      }
    },
    "additionalProperties": false
  }

  arguments 66 lines copy
• chargeable_weight_calculator reads unknown 5h ago

  Calculate air freight chargeable weight — the greater of actual gross weight and volumetric weight, which is what airlines bill. Volumetric weight (kg) = (L x W x H in cm) / divisor; the IATA-standard divisor is 6,000 (1 CBM = 166.67 kg), while express integrators (DHL, FedEx, UPS) typically use 5,000. Behavior: deterministic; the dimensions are per piece and gross_weight_kg is the TOTAL for all pieces; totals are computed from unrounded figures and rounded only for display (10,000 pieces of 5 x 5 x 6 cm = 250 kg); basis reports which weight governs ("volumetric" = cargo is light for its size, "actual" = dense). Air mode only — sea W/M (1 CBM = 1,000 kg) is covered by consignment_calculator with mode=sea. Missing or non-positive inputs error with the failing parameter named. Rate-limited: a limit error carries reset_at, the UTC time the allowance resets. Returns: chargeable_weight_kg, basis, volumetric_weight_kg (the total; the hosted endpoint names it volumetricWeightTotalKg) and volumetric_weight_per_piece_kg, gross_weight_kg, cbm, ratio, factor and pieces under result; normalized_input echoes the interpreted inputs (gross_weight_basis, dimensions_basis) and any defaults applied; plus confidence, _source and citation (the FreightUtils v1 response envelope). Field names as this package serves them (snake_case); the hosted /api/mcp endpoint serves the same fields in camelCase (e.g. total_cbm → totalCbm). Related: cbm_calculator (volume only), consignment_calculator (multi-line, all modes), uld_lookup (the equipment the freight flies in).

  mcp-tool

  123456789101112131415161718192021222324252627282930313233343536373839404142434445

  {
    "type": "object",
    "$schema": "http://json-schema.org/draft-07/schema#",
    "required": [
      "length_cm",
      "width_cm",
      "height_cm",
      "gross_weight_kg"
    ],
    "properties": {
      "factor": {
        "type": "integer",
        "maximum": 9007199254740991,
        "description": "Volumetric divisor (default: 6000)",
        "exclusiveMinimum": 0
      },
      "pieces": {
        "type": "integer",
        "maximum": 9007199254740991,
        "description": "Number of identical pieces (default: 1)",
        "exclusiveMinimum": 0
      },
      "width_cm": {
        "type": "number",
        "description": "Width in centimetres",
        "exclusiveMinimum": 0
      },
      "height_cm": {
        "type": "number",
        "description": "Height in centimetres",
        "exclusiveMinimum": 0
      },
      "length_cm": {
        "type": "number",
        "description": "Length in centimetres",
        "exclusiveMinimum": 0
      },
      "gross_weight_kg": {
        "type": "number",
        "description": "Actual gross weight in kilograms of ALL pieces together (the total, not one piece) — the dimensions are per piece.",
        "exclusiveMinimum": 0
      }
    },
    "additionalProperties": false
  }

  arguments 45 lines copy
• resolve_reference reads unknown 5h ago

  Resolve an arbitrary freight identifier — one opaque string in, typed and cited candidates out. Use when you hold one identifier-ish token ("176", "UN1845", "NLRTM", "FOB", "22G1", "MSKU1100810", "D/E") and do not know what kind of identifier it is: each candidate names its entity type and carries the api_url and canonical_url of its full record. Provide q: ONE identifier (single token, max 32 chars) — or an fu: identifier, the fu_id or fu_version_id of any record in an answer (up to 200 chars), which resolves to exactly its one record or to none. Fourteen grammars all run — UN numbers, AWB prefixes, airline IATA/ICAO, airport IATA/ICAO, UN/LOCODE, ISO 6346 container numbers (check digit computed), HS codes (6-10 digits; national lines resolve at their 6-digit international parent), Incoterms, ADR tunnel codes, ADR Table A codes (special provisions, packing instructions and their PP/B/L provisions, MP, T/BK/TP, tank codes, TU/TC/TE/TA/TT/TM, V/VC/AP/CV/S, vehicle designations, labels, hazard identification numbers — e.g. "TU9" → its meaning, section and review status; a well-formed code no Table A row carries, e.g. "P999", is pattern_only), ULD serials, ISO container size/type codes. Ambiguity is the product: colliding grammars return MULTIPLE ranked candidates ("LHR" is Heathrow AND an Egyptian carrier's ICAO; "336" is an ADR special provision AND a hazard identification number), never a silent guess. Behavior: deterministic — normalize (trim, uppercase, collapse spaces/dashes, strip a UN prefix), match ALL grammars, rank by record-hit > verification status > static dataset prior (airlines/adr/unlocode first) > stable tiebreak; every candidate carries rank_basis so the ordering is inspectable. Zero candidates is a VALID result (count 0 + note), never an error. A failed container check digit returns a candidate with valid:false rather than dropping it. Rate-limited: a limit error carries reset_at, the UTC time the allowance resets. Returns: query, normalized, count and candidates[] — each with entity_type, identifier_type, value_normalized, summary, record (the core fields the matching dataset holds), verification_status + verification_basis, rank_basis, canonical_url, api_url and a per-candidate dataset citation — under result, plus confidence, _source and citation (the FreightUtils v1 response envelope). Limitations: v1 is SINGLE-TOKEN resolution, not free-text extraction — pass one identifier, not a manifest line; SCAC/BIC codes are not yet covered; a match asserts the identifier is known/well-formed, not that a shipment exists. Related: every lookup tool this resolves into — adr_lookup, airline_lookup, airport_lookup, unlocode_lookup, hs_code_lookup, incoterms_lookup, container_lookup, uld_lookup, validate. Identifiers: Each record carries fu_id, a stable FreightUtils identifier (and fu_version_id where the dataset has editions); resolve_reference resolves one to exactly its record.

  mcp-tool

  12345678910111213141516

  {
    "type": "object",
    "$schema": "http://json-schema.org/draft-07/schema#",
    "required": [
      "q"
    ],
    "properties": {
      "q": {
        "type": "string",
        "maxLength": 200,
        "minLength": 1,
        "description": "One freight identifier — e.g. \"176\", \"UN1845\", \"NLRTM\", \"FOB\", \"LHR\", \"22G1\", \"MSKU1100810\", \"090111\", \"AKE12345AB\", \"D/E\" — or an fu: identifier from any answer's fu_id / fu_version_id (e.g. \"fu:adr:un:1203:II:F1@2025\"), which resolves to exactly its one record or to none."
      }
    },
    "additionalProperties": false
  }

  arguments 16 lines copy
• unit_converter reads unknown 5h ago

  Convert freight and logistics units: weight (kg, lbs, oz, tonnes, short_tons, long_tons), volume (cbm, cuft, cuin, litres, gal_us, gal_uk), length (cm, inches, m, feet, mm), plus two freight-specific targets valid only FROM cbm — chargeable_kg (air volumetric weight at the IATA 6,000 divisor: m³ x 1,000,000 / 6000) and freight_tonnes (sea W/M, 1 CBM = 1 freight tonne). Behavior: deterministic, on the exact legal factors (1 lb = 0.45359237 kg, 1 in = 2.54 cm); the response names both units and states the formula used. Cross-dimension conversions (e.g. kg to litres), a negative value and freight targets from a non-cbm source are refused with the accepted units listed by category. Note: short ton (US) = 2,000 lb, long ton (UK) = 2,240 lb, metric tonne = 2,204.6 lb. Rate-limited: a limit error carries reset_at, the UTC time the allowance resets. Returns: input {value, unit, name}, result {value, unit, name}, formula and note under result, plus confidence, _source and citation (the FreightUtils v1 response envelope). Related: cbm_calculator (dimensions to volume first), chargeable_weight_calculator (proper air billing weight with pieces and a custom divisor).

  mcp-tool

  12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364

  {
    "type": "object",
    "$schema": "http://json-schema.org/draft-07/schema#",
    "required": [
      "value",
      "from",
      "to"
    ],
    "properties": {
      "to": {
        "enum": [
          "kg",
          "lbs",
          "oz",
          "tonnes",
          "short_tons",
          "long_tons",
          "cbm",
          "cuft",
          "cuin",
          "litres",
          "gal_us",
          "gal_uk",
          "cm",
          "inches",
          "m",
          "feet",
          "mm",
          "chargeable_kg",
          "freight_tonnes"
        ],
        "type": "string",
        "description": "Target unit — any source unit, plus the freight targets chargeable_kg and freight_tonnes (only valid from cbm)"
      },
      "from": {
        "enum": [
          "kg",
          "lbs",
          "oz",
          "tonnes",
          "short_tons",
          "long_tons",
          "cbm",
          "cuft",
          "cuin",
          "litres",
          "gal_us",
          "gal_uk",
          "cm",
          "inches",
          "m",
          "feet",
          "mm"
        ],
        "type": "string",
        "description": "Source unit — weight (kg, lbs, oz, tonnes, short_tons, long_tons), volume (cbm, cuft, cuin, litres, gal_us, gal_uk) or length (cm, inches, m, feet, mm)"
      },
      "value": {
        "type": "number",
        "description": "Value to convert"
      }
    },
    "additionalProperties": false
  }

  arguments 64 lines copy
• adr_lq_eq_check reads unknown 2h ago

  Check whether dangerous goods qualify for ADR Limited Quantity (LQ, ADR 3.4) or Excepted Quantity (EQ, ADR 3.5) relief. LQ compares each item's per-inner-packaging quantity against that substance's LQ maximum; EQ resolves the substance's E-code (E0-E5) and checks the per-inner limit, plus the per-outer limit when inner_packaging_qty is given. Provide mode ("lq" or "eq") and 1-20 items, each with un_number, quantity and unit — ml or L for liquids, g or kg for solids; quantity is per INNER packaging, not the whole load. Unit families: column (7a) states the limit in ONE dimension — a mass for some entries, a volume for others — and ADR supplies no density, so a mass quantity against a volume limit (or the reverse) CANNOT be compared. Those items return status 'inconclusive' with the dimension named, never a pass or a fail, and a batch holding any inconclusive item never reads overall_status 'qualifies'. Send the quantity in the unit given by lq_limit_unit to get a verdict. Multi-variant UNs: a UN number with more than one ADR Table A row (packing group / concentration variant — e.g. UN 1789 PG II LQ 1 L vs PG III LQ 5 L) needs packing_group (I|II|III) or variant_index (from adr_lookup) on that item to pin one row. A packing_group that still leaves several rows is enough when those rows agree on class, column (7a), column (7b) and scope (UN 1790 PG I: two concentration bands, both LQ 0 / E0) — the item is answered with equivalent_variants + variant_note naming the rows it holds for; only when the rows DISAGREE does it still ask for variant_index, and candidates[] then lists only that packing group's rows. With no disambiguator at all: a single-item call, or a batch where EVERY item is ambiguous, returns blocking_errors[AMBIGUOUS_UN_VARIANT] + human_review_required + candidates[] (each candidate's item_index, un_number, variant_index, packing_group, proper_shipping_name, limited_quantity, excepted_quantity) and NO verdict; a MIXED batch withholds only the ambiguous item (status 'withheld', withheld true, row fields null) while the other items are answered, overall_status never reads 'qualifies' while an item is withheld, summary carries withheld, and the envelope carries human_review_required + candidates[] plus one AMBIGUOUS_UN_VARIANT warning per withheld item. Never a silently checked packing group. Single-row UNs are unchanged. Behavior: deterministic reference check; each item gets a status and reason (an LQ value of "0" or code E0 means the relief is not permitted for that substance), with overall_status and summary counts across the batch. Table A rows listed "NOT SUBJECT TO ADR" (e.g. UN 1845 dry ice) get item status not_subject — outside ADR scope, neither a pass nor a fail — and an all-not-subject batch returns overall_status not_applicable; "CARRIAGE PROHIBITED" rows are not_permitted with the prohibition stated in reason. Fields are checked by name: a field the tool does not read is refused with a tool error naming it and listing the accepted ones, never ignored. Rate-limited: a limit error carries reset_at, the UTC time the allowance resets. Returns: mode, overall_status (qualifies | does_not_qualify | partial | not_applicable | inconclusive), items[] (un_number, variant_index, substance, class, packing_group, lq_limit or eq_code, quantity_entered, status — within_limit | exceeds_limit | not_permitted | not_subject | inconclusive | withheld — reason, scope flags where applicable, withheld + ambiguity_reason on a withheld item, and equivalent_variants + variant_note when a packing group resolved by equivalence), summary {total_items, qualifying, exceeding, not_permitted, not_subject?, inconclusive?, withheld?}, the ADR chapter references, and human_review_required + candidates[] when any item is withheld — all under result — or, when every item is ambiguous, human_review_required + candidates[] with blocking_errors, plus confidence, _source and citation (the FreightUtils v1 response envelope). Editions: edition ("2025" | "2027") and as_of (YYYY-MM-DD) choose the ADR edition — edition wins, else the date picks it (ADR 2025 before 2027-01-01, ADR 2027 from then; ADR 2025 may still be applied until 2027-06-30). An answer on a named edition carries adr_edition; neither sent, the answer is ADR 2025 until 2027-01-01. Limitations: a quantity-threshold check only — LQ/EQ relief also requires packaging, marking and documentation conformity that this tool does not assess; not legal advice, verify against the current UNECE ADR text. Related: adr_lookup (the per-substance LQ/EQ values + variant_index), adr_exemption_calculator (the 1.1.3.6 load-points route instead). Identifiers: Each record carries fu_id, a stable FreightUtils identifier (and fu_version_id where the dataset has editions); resolve_reference resolves one to exactly its record.

  mcp-tool

  12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091

  {
    "type": "object",
    "$schema": "http://json-schema.org/draft-07/schema#",
    "required": [
      "mode",
      "items"
    ],
    "properties": {
      "mode": {
        "enum": [
          "lq",
          "eq"
        ],
        "type": "string",
        "description": "Check mode: 'lq' (Limited Quantity, ADR 3.4) or 'eq' (Excepted Quantity, ADR 3.5)"
      },
      "as_of": {
        "type": "string",
        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
        "description": "YYYY-MM-DD the answer is for (default today, UTC); picks the ADR edition when edition is omitted, and is echoed in the answer and its check receipt."
      },
      "items": {
        "type": "array",
        "items": {
          "type": "object",
          "required": [
            "un_number",
            "quantity",
            "unit"
          ],
          "properties": {
            "unit": {
              "enum": [
                "ml",
                "L",
                "g",
                "kg"
              ],
              "type": "string",
              "description": "Unit for the quantity: \"ml\" or \"L\" for liquids, \"g\" or \"kg\" for solids."
            },
            "quantity": {
              "type": "number",
              "maximum": 1000000000,
              "description": "Quantity per inner packaging, expressed in the chosen unit. Example: 0.5.",
              "exclusiveMinimum": 0
            },
            "un_number": {
              "type": "string",
              "pattern": "^\\s*(?:UN\\s*)?\\d{4}\\s*$",
              "description": "UN number — 4 digits, optionally \"UN\"-prefixed; explosives keep the leading zero. Examples: \"1203\", \"UN1263\", \"UN 1263\", \"0004\"."
            },
            "packing_group": {
              "enum": [
                "I",
                "II",
                "III"
              ],
              "type": "string",
              "description": "Packing group (I, II or III) — only needed to disambiguate a UN with more than one ADR Table A row (e.g. UN 1789: PG II LQ 1 L vs PG III LQ 5 L). Ignored for single-row UNs."
            },
            "variant_index": {
              "type": "integer",
              "maximum": 9007199254740991,
              "minimum": 0,
              "description": "ADR Table A variant index (as returned by adr_lookup) — pins one row when a UN has several variants that share a packing group (e.g. concentration bands). Ignored for single-row UNs."
            },
            "inner_packaging_qty": {
              "type": "integer",
              "maximum": 9007199254740991,
              "description": "EQ mode only: number of inner packagings per outer package, for the per-outer limit check. Default 1. Example: 10.",
              "exclusiveMinimum": 0
            }
          },
          "additionalProperties": false
        },
        "maxItems": 20,
        "minItems": 1,
        "description": "Items to check (1–20 per call)."
      },
      "edition": {
        "enum": [
          "2025",
          "2027"
        ],
        "type": "string",
        "description": "ADR edition: \"2025\" or \"2027\". Wins over as_of. Omit it and as_of picks the edition by the legal timeline: before 2027-01-01 ADR 2025; from 2027-01-01 ADR 2027 (ADR 2025 may still be applied until 2027-06-30 under 1.6.1.1 — edition \"2025\" answers on it until then); from 2027-07-01 ADR 2027 only. An ADR 2027 answer for a date before 2027-01-01 carries an EDITION_NOT_YET_APPLICABLE warning."
      }
    },
    "additionalProperties": false
  }

  arguments 91 lines copy
• emissions_calculator reads unknown 2h ago

  Estimate freight transport greenhouse-gas emissions (kgCO2e) for a shipment leg, per ISO 14083:2023 / GLEC Framework v3.2: emissions = mass x distance x a published emission-intensity factor (kgCO2e/tonne-km). Provide mass + distance_km + mode (road | rail | sea | air | inland_waterway); optionally choose sub_mode, region/authority (uk = DEFRA, us = EPA, fr = ADEME) and basis (wtw default, or ttw). IMPORTANT: pass ACTUAL GROSS MASS, not chargeable/volumetric weight (a common air-freight mistake — see mass_basis in the result). Distance must be provided — this tool does NOT route, geocode, or compute distances. Behavior: deterministic given the same factor edition; the fleet-average factor already includes average empty running (see empty_running) — do NOT add your own empty-return leg; sea and air are low-representativeness generic defaults (real emissions vary materially by vessel/aircraft, load factor and routing — see representativeness and the result summary). An unknown mode/sub_mode/region returns available:false with the covered options, never a fabricated factor. Rate-limited: a limit error carries reset_at, the UTC time the allowance resets. Returns: well-to-wheel AND tank-to-wheel emissions where the factor has both, the exact factor used (value, authority, edition), the tonne-km activity and a per-result _source citing BOTH the ISO method and the specific published factor, all under result, plus confidence, _source and citation (the FreightUtils v1 response envelope). Limitations: best-effort reference estimate from published factors (DEFRA / EPA / ADEME) — NOT a verified or audited carbon report. Related: distinct from cbm_calculator / ldm_calculator / chargeable_weight_calculator (those size or bill a shipment; this one estimates its CO2e). Identifiers: Each record carries fu_id, a stable FreightUtils identifier (and fu_version_id where the dataset has editions); resolve_reference resolves one to exactly its record.

  mcp-tool

  1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162

  {
    "type": "object",
    "$schema": "http://json-schema.org/draft-07/schema#",
    "required": [
      "mass",
      "distance_km",
      "mode"
    ],
    "properties": {
      "mass": {
        "type": "number",
        "description": "Shipment mass, expressed in mass_unit. Example: 1000",
        "exclusiveMinimum": 0
      },
      "mode": {
        "enum": [
          "road",
          "rail",
          "sea",
          "air",
          "inland_waterway"
        ],
        "type": "string",
        "description": "Transport mode"
      },
      "basis": {
        "enum": [
          "wtw",
          "ttw"
        ],
        "type": "string",
        "description": "Emissions basis: wtw = well-to-wheel incl. upstream energy (default), ttw = tank-to-wheel / operation only"
      },
      "region": {
        "enum": [
          "uk",
          "us",
          "fr"
        ],
        "type": "string",
        "description": "Factor source/region: uk = DEFRA, us = EPA, fr = ADEME. Default is per-mode."
      },
      "sub_mode": {
        "type": "string",
        "description": "Optional sub-mode / vehicle class (e.g. \"articulated\", \"container ship\", \"long-haul\"). Omit for the representative default; an unknown value returns available:false with the covered list."
      },
      "mass_unit": {
        "enum": [
          "kg",
          "tonnes"
        ],
        "type": "string",
        "description": "Unit for mass (default: kg)"
      },
      "distance_km": {
        "type": "number",
        "description": "Transport distance in kilometres — you provide it; the tool does not route or compute distance",
        "exclusiveMinimum": 0
      }
    },
    "additionalProperties": false
  }

  arguments 62 lines copy
• ics2_check reads unknown 2h ago

  Check a goods description against the official EU ICS2 stop-words list — terms the European Commission deems too vague or generic for an entry summary declaration (ENS) goods-description field (data element 18 05 000 000). Pass description=<goods description>. Behavior: deterministic term matching against the in-force EU list; each flagged term carries a note (a standalone stop-word means automatic rejection, an embedded one means make the description more specific); clean=true means no listed term matched — it does NOT guarantee acceptance, and no binary accepted/rejected verdict is given. Rate-limited: a limit error carries reset_at, the UTC time the allowance resets. Returns: the description echo, flagged[] (term + note), clean, caveat and disclaimer under result, plus a _source citing the EU list and legal basis, plus confidence, _source and citation (the FreightUtils v1 response envelope). Limitations: STRICTLY a reference check — not an ENS filing, not a customs-compliance determination, not legal advice; the EU list is non-exhaustive and updated periodically. Related: hs_code_lookup (commodity codes — a different field of the ENS), uk_duty_calculator (duty/VAT, unrelated to ENS screening). Intended for checking a goods description before an ENS is filed. Identifiers: Each record carries fu_id, a stable FreightUtils identifier (and fu_version_id where the dataset has editions); resolve_reference resolves one to exactly its record.

  mcp-tool

  1234567891011121314

  {
    "type": "object",
    "$schema": "http://json-schema.org/draft-07/schema#",
    "required": [
      "description"
    ],
    "properties": {
      "description": {
        "type": "string",
        "description": "The goods description to check against the EU ICS2 stop-words list."
      }
    },
    "additionalProperties": false
  }

  arguments 14 lines copy
• unlocode_lookup reads unknown 25h ago

  Search 116,086 UN/LOCODE transport locations worldwide — ports, airports, rail and road terminals, inland container depots and border crossings. Codes are 5 characters: a 2-letter ISO country code + a 3-character location code (GBLHR = London Heathrow, NLRTM = Rotterdam). Provide code for an exact record, or query (name search, min 2 chars) optionally narrowed by country and function_type; limit caps results (default 20, max 100). The spaced notation "GB LHR" reads as GBLHR in either. Behavior: read-only; exact code hits are provenance-based while fuzzy name hits report match quality via the envelope's confidence (basis match_quality); an unknown code errors with a not-found message. Rate-limited: a limit error carries reset_at, the UTC time the allowance resets. Returns: the location record(s) — code, name and name_ascii, country, subdivision, functions[], status, coordinates {lat, lon} and iata_code where assigned — under result, plus confidence, _source and citation (the FreightUtils v1 response envelope). Limitations: an administrative code list (UNECE UN/LOCODE 2025-1) — confirm operational status and coordinates with the port or authority before critical use. Related: airport_lookup (airport-specific records including ICAO codes), nearest_airport (find airports by coordinates). Identifiers: Each record carries fu_id, a stable FreightUtils identifier (and fu_version_id where the dataset has editions); resolve_reference resolves one to exactly its record.

  mcp-tool

  1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950

  {
    "type": "object",
    "$schema": "http://json-schema.org/draft-07/schema#",
    "properties": {
      "code": {
        "type": "string",
        "pattern": "^\\s*[A-Za-z]{2}[\\s-]?[A-Za-z0-9]{3}\\s*$",
        "description": "Exact UN/LOCODE lookup (e.g. \"GBLHR\", \"GB LHR\", \"NLRTM\")"
      },
      "codes": {
        "type": "array",
        "items": {
          "type": "string",
          "maxLength": 8
        },
        "maxItems": 50,
        "minItems": 1,
        "description": "Batch: up to 50 UN/LOCODEs, answered as results[] in input order, each with its own status. Send alone."
      },
      "limit": {
        "type": "integer",
        "maximum": 100,
        "minimum": 1,
        "description": "Max results (default 20)"
      },
      "query": {
        "type": "string",
        "minLength": 2,
        "description": "Search by name or code (e.g. \"Rotterdam\", \"GBLHR\", \"LHR\")"
      },
      "country": {
        "type": "string",
        "pattern": "^[A-Za-z]{2}$",
        "description": "ISO 2-letter country code filter (e.g. \"GB\", \"NL\")"
      },
      "function_type": {
        "enum": [
          "port",
          "airport",
          "rail",
          "road",
          "icd",
          "border"
        ],
        "type": "string",
        "description": "Filter by location function"
      }
    },
    "additionalProperties": false
  }

  arguments 50 lines copy
• uld_lookup reads unknown 11h ago

  Look up air-cargo ULD (Unit Load Device) specifications — 16 types spanning lower-deck containers (AKE/LD3 and family), main-deck pallets (PMC, PAG and family) and temperature-controlled units. Each record carries external/internal/door dimensions (cm), tare and max gross weight (kg), usable volume (m³), deck position and compatible aircraft. Provide type as an IATA code ("AKE", "PMC"), slug ("ake-ld3") or the record's own name when one record carries it ("LD3" → AKE); omit it to list all 16; category (container | pallet | special) and deck (lower | main) filter the list. Behavior: read-only; an unknown type errors with the closest codes; a single record carries its provenance (sources, audited_at, decision_rationale). A list (no single record asked for) returns summary rows with total, truncated, next_offset and detail_hint; full: true returns full records five per page, with offset / limit to page. Rate-limited: a limit error carries reset_at, the UTC time the allowance resets. Returns: the ULD record (or the list) under result, plus confidence, _source and citation (the FreightUtils v1 response envelope). Field names as this package serves them (snake_case); the hosted /api/mcp endpoint serves the same fields in camelCase (e.g. total_cbm → totalCbm). Limitations: specs are compiled from manufacturer and carrier-published sources with ≥7 cited sources per record. Provenance is PENDING, not verified — read the envelope's provenance_status rather than this sentence. Second-agent coverage is now COMPLETE — every cited record-URL pairing has been opened and verdicted by a second agent, and 145 of 148 citations carry a timestamped read (the 3 without one were never opened, and say so). COVERAGE IS NOT AGREEMENT, which is why provenance is still pending: reading every page is what made the disagreements visible, not what resolved them. The second agent also WITHDRAWS stamps — pages a first pass had confirmed turned out not to list the code, or to disagree once somebody read the words around them — so treat an unstamped citation as evidence that was tried and failed, not evidence not yet gathered. CORROBORATION IS COUNTED BY PUBLISHER, NOT BY URL: the 148 citations resolve to 125 distinct sources, because several records cite one publisher at several of its own addresses (one carrier's pallet table appears in three of its documents) and several forwarders republish a single upstream template. Two citations of the same source cannot corroborate each other, so a long source list is not the same as a well-corroborated record. Treat tare_weight with particular caution: it is confirmed by no non-tertiary source on 13 of the 16 records. PGA's 565 kg is now read-confirmed by one carrier (Cathay, basis stated on the page as including nets) while two other carrier pages publish 535 kg and 505-545 kg on that same basis, so it is the top of a contested band rather than an agreed figure. Confidence is medium and a PROVENANCE_PENDING advisory rides every response. Pallet records (PMC, PAG, PGA, PLA, PAJ, PMCQ7) have NO internal dimensions — a pallet has no walls or roof; read max_build_up_height_cm for the aircraft contour ceiling and do not multiply dimensions to get a volume. Airline-specific ULD variants still differ; confirm operationally critical dimensions with the carrier. Related: chargeable_weight_calculator (what the cargo inside is billed at), container_lookup (the sea-freight equivalent), airline_lookup (whose aircraft it flies on). Identifiers: Each record carries fu_id, a stable FreightUtils identifier (and fu_version_id where the dataset has editions); resolve_reference resolves one to exactly its record.

  mcp-tool

  123456789101112131415161718192021222324252627282930313233343536373839404142434445

  {
    "type": "object",
    "$schema": "http://json-schema.org/draft-07/schema#",
    "properties": {
      "deck": {
        "enum": [
          "lower",
          "main"
        ],
        "type": "string",
        "description": "Filter by deck position"
      },
      "full": {
        "type": "boolean",
        "description": "Lists only: true returns full records (provenance, sources, rationale) instead of summary rows. A single-record call always returns the full record."
      },
      "type": {
        "type": "string",
        "minLength": 2,
        "description": "ULD code (e.g., \"AKE\", \"PMC\") or slug (e.g., \"ake-ld3\"). Omit to list all."
      },
      "limit": {
        "type": "integer",
        "maximum": 100,
        "minimum": 1,
        "description": "Lists only: rows per page (default: every row for summaries; 5 with full: true)."
      },
      "offset": {
        "type": "integer",
        "maximum": 9007199254740991,
        "minimum": 0,
        "description": "Lists only: rows to skip (default 0). The response gives total and next_offset."
      },
      "category": {
        "enum": [
          "container",
          "pallet",
          "special"
        ],
        "type": "string",
        "description": "Filter by ULD category"
      }
    },
    "additionalProperties": false
  }

  arguments 45 lines copy
• get_subscribe_link reads unknown never probed

  Return the FreightUtils pricing page URL with the Pro plan's request limit (50,000 per month) and price. Use when the user asks about FreightUtils plans, pricing or API limits. Behavior: static local response — no API call, never rate-limited, no account or payment action; the user opens the URL in a browser. Returns: url, tier, monthly_limit, monthly_price, currency and note under result.

  mcp-tool

  1234567891011121314

  {
    "type": "object",
    "$schema": "http://json-schema.org/draft-07/schema#",
    "properties": {
      "tier": {
        "enum": [
          "pro"
        ],
        "type": "string",
        "description": "Tier to surface (only \"pro\" supported today)"
      }
    },
    "additionalProperties": false
  }

  arguments 14 lines copy
• pallet_fitting_calculator reads unknown 23h ago

  Calculate how many identical boxes fit on a pallet: boxes per layer (trying 90-degree rotation when allowed), layer count within the max height, totals, footprint and volume utilisation, and weight capping. Behavior: deterministic geometric packing of one box size in aligned rows and columns — it does not model interlocked or mixed-orientation patterns; weight_limited reports when max_payload_kg caps the count below the geometric fit, counted in whole layers (notes say when a part layer is left out, and why nothing fits when no box fits); pallet_deck_height_cm defaults to 15. Missing or non-positive dimensions error naming the parameter. Rate-limited: a limit error carries reset_at, the UTC time the allowance resets. Returns: boxes_per_layer, layers, total_boxes, orientation, boxes_per_row/col, usable_height_cm, utilisation_percent (the share of the pallet FOOTPRINT one layer covers), volume_utilisation_percent (box volume over the usable envelope), total_box_volume_cbm, wasted_space_cbm, max_boxes_by_weight, notes and the weight fields under result, plus confidence, _source and citation (the FreightUtils v1 response envelope). Field names as this package serves them (snake_case); the hosted /api/mcp endpoint serves the same fields in camelCase (e.g. total_cbm → totalCbm). Limitations: a theoretical best-effort fit — real stacking obeys carton strength, overhang and load-stability rules it does not model. Related: ldm_calculator (pallets into trailer length), vehicle_lookup (pallet capacity per vehicle), container_lookup (pallets into containers).

  mcp-tool

  12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364

  {
    "type": "object",
    "$schema": "http://json-schema.org/draft-07/schema#",
    "required": [
      "pallet_length_cm",
      "pallet_width_cm",
      "pallet_max_height_cm",
      "box_length_cm",
      "box_width_cm",
      "box_height_cm"
    ],
    "properties": {
      "box_width_cm": {
        "type": "number",
        "description": "Box width in cm",
        "exclusiveMinimum": 0
      },
      "box_height_cm": {
        "type": "number",
        "description": "Box height in cm",
        "exclusiveMinimum": 0
      },
      "box_length_cm": {
        "type": "number",
        "description": "Box length in cm",
        "exclusiveMinimum": 0
      },
      "box_weight_kg": {
        "type": "number",
        "description": "Box weight in kg",
        "exclusiveMinimum": 0
      },
      "allow_rotation": {
        "type": "boolean",
        "description": "Allow 90-degree rotation (default: true)"
      },
      "max_payload_kg": {
        "type": "number",
        "description": "Max pallet payload in kg",
        "exclusiveMinimum": 0
      },
      "pallet_width_cm": {
        "type": "number",
        "description": "Pallet width in cm",
        "exclusiveMinimum": 0
      },
      "pallet_length_cm": {
        "type": "number",
        "description": "Pallet length in cm",
        "exclusiveMinimum": 0
      },
      "pallet_max_height_cm": {
        "type": "number",
        "description": "Max stack height in cm",
        "exclusiveMinimum": 0
      },
      "pallet_deck_height_cm": {
        "type": "number",
        "description": "Pallet deck height (default: 15cm)",
        "exclusiveMinimum": 0
      }
    },
    "additionalProperties": false
  }

  arguments 64 lines copy
• nearest_airport reads unknown 23h ago

  Find the airports nearest to a caller-provided latitude/longitude, sorted by great-circle (haversine) distance with distance_km on each result. Searches 86,248 airports (OurAirports, public domain). Provide latitude and longitude (decimal degrees); optional radius_km, max_results (1-50, default 10), type filter (e.g. large_airport only) and include_all. By default only airports with scheduled airline service and an IATA code are ranked — never a heliport or a closed field; include_all: true ranks every type except closed fields, and type filters on that type. Coordinates are INPUT only — nothing is stored or logged. Behavior: deterministic distance sort; confidence reflects proximity and airport size (a large airport within 25 km scores high; closed/heliport/seaplane results cap lower). This tool does NOT geocode place names and does NOT compute routes — pass coordinates you already hold. Rate-limited: a limit error carries reset_at, the UTC time the allowance resets. Returns: count, results[] (the airport record plus distance_km), distance_basis ("great_circle"), filter (scheduled_iata / all / type) and filter_description under result, plus confidence, _source and citation (the FreightUtils v1 response envelope). Limitations: reference data only — not for navigation; verify codes with IATA / ICAO. Related: airport_lookup (exact code or name lookup, no distance), unlocode_lookup (named transport-location search). Identifiers: Each record carries fu_id, a stable FreightUtils identifier (and fu_version_id where the dataset has editions); resolve_reference resolves one to exactly its record.

  mcp-tool

  1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950

  {
    "type": "object",
    "$schema": "http://json-schema.org/draft-07/schema#",
    "required": [
      "latitude",
      "longitude"
    ],
    "properties": {
      "type": {
        "enum": [
          "large_airport",
          "medium_airport",
          "small_airport",
          "heliport",
          "closed",
          "seaplane_base"
        ],
        "type": "string",
        "description": "Optional filter by airport type"
      },
      "latitude": {
        "type": "number",
        "maximum": 90,
        "minimum": -90,
        "description": "Latitude in decimal degrees (-90 to 90)"
      },
      "longitude": {
        "type": "number",
        "maximum": 180,
        "minimum": -180,
        "description": "Longitude in decimal degrees (-180 to 180)"
      },
      "radius_km": {
        "type": "number",
        "description": "Optional maximum distance in kilometres",
        "exclusiveMinimum": 0
      },
      "include_all": {
        "type": "boolean",
        "description": "Default false: only airports with scheduled airline service and an IATA code (no heliports). true: every airport type except closed fields."
      },
      "max_results": {
        "type": "integer",
        "maximum": 50,
        "minimum": 1,
        "description": "Max results to return (1–50, default 10)"
      }
    },
    "additionalProperties": false
  }

  arguments 50 lines copy
• uk_duty_calculator reads unknown 25h ago

  Estimate UK import duty and VAT for a commodity code using the LIVE GOV.UK Trade Tariff — rates are fetched per request, not from a static table. The CIF value is composed from customs_value + freight_cost + insurance_cost; duty = CIF x the duty rate for the origin country; VAT (typically 20%) applies on the duty-inclusive value. Provide commodity_code (a declarable 10-digit code), origin_country (ISO-2) and customs_value in GBP; freight_cost, insurance_cost and incoterm are optional refinements. Behavior: live lookup plus deterministic arithmetic on the returned rate; a 6- or 8-digit code is refused — never padded with zeros to a code you did not send — with declarable_codes, the 10-digit codes beneath it in the UK Trade Tariff (610910 → 6109100010, 6109100090); an origin that is not an ISO 3166-1 country is refused; origin-dependent measures the tariff cannot resolve automatically surface in warnings. Rate-limited: a limit error carries reset_at, the UTC time the allowance resets. Returns: commodity_code and description, origin country, cif_value, duty_rate (+ percent), duty_amount, vat_rate, vat_amount, total_import_taxes, total_landed_cost and warnings under result (amounts in GBP); validity.as_of marks the live-rate timestamp; plus confidence, _source and citation (the FreightUtils v1 response envelope). Field names as this package serves them (snake_case); the hosted /api/mcp endpoint serves the same fields in camelCase (e.g. total_cbm → totalCbm). Limitations: an estimate, not a customs ruling — excise, quotas, anti-dumping measures, reliefs and origin-proof requirements can change the outcome; confirm with a customs broker or HMRC before relying on it. Related: hs_code_lookup (find the 6-digit code first), incoterms_lookup (who actually pays these costs).

  mcp-tool

  1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162

  {
    "type": "object",
    "$schema": "http://json-schema.org/draft-07/schema#",
    "properties": {
      "lines": {
        "type": "array",
        "items": {
          "type": "object",
          "propertyNames": {
            "type": "string"
          },
          "additionalProperties": {}
        },
        "maxItems": 10,
        "minItems": 1,
        "description": "Batch: up to 10 lines, each { commodity_code, origin_country, customs_value, freight_cost?, insurance_cost?, incoterm? } — answered as results[] in input order, each as its own call (each line its own receipt). Send alone; the UK Trade Tariff is read live per line."
      },
      "incoterm": {
        "enum": [
          "EXW",
          "FCA",
          "FAS",
          "FOB",
          "CFR",
          "CIF",
          "CPT",
          "CIP",
          "DAP",
          "DPU",
          "DDP"
        ],
        "type": "string",
        "description": "Incoterm basis"
      },
      "freight_cost": {
        "type": "number",
        "minimum": 0,
        "description": "Freight cost in GBP, 0 or more (default 0)"
      },
      "customs_value": {
        "type": "number",
        "description": "Customs value in GBP. Required unless lines[] is sent.",
        "exclusiveMinimum": 0
      },
      "commodity_code": {
        "type": "string",
        "pattern": "^[\\d\\s]{6,14}$",
        "description": "UK tariff commodity code — a declarable 10 digits, spaces allowed (a 6- or 8-digit code is refused with the declarable codes beneath it)"
      },
      "insurance_cost": {
        "type": "number",
        "minimum": 0,
        "description": "Insurance cost in GBP, 0 or more (default 0)"
      },
      "origin_country": {
        "type": "string",
        "pattern": "^[A-Za-z]{2}$",
        "description": "ISO 2-letter country of origin (e.g. \"CN\", \"US\"). Required unless lines[] is sent."
      }
    },
    "additionalProperties": false
  }

  arguments 62 lines copy
• adr_exemption_calculator reads unknown 13h ago

  Calculate ADR 1.1.3.6 "small load" exemption points for a dangerous-goods load and say whether it qualifies. Each substance's transport category (Table A column (15), 0-4) sets a points multiplier (1.1.3.6.4: category 1 x50, 2 x3, 3 x1, 4 x0; the nine ADR 1.1.3.6.3 note-a entries UN 0081/0082/0084/0241/0331/0332/0482/1005/1017 are x20); points = quantity x multiplier. The rule (1.1.3.6.2), for dangerous goods carried in packages: goods of ONE transport category qualify when their TOTAL on the transport unit stays within that category's 1.1.3.6.3 column (3) maximum — category 1: 20, 2: 333, 3: 1,000 (kg or L); note-a entries 50 kg; category 4 unlimited; category 0: 0 — however it is split across lines; goods of DIFFERENT categories qualify when the 1.1.3.6.4 points sum does not exceed 1,000. This calculator also holds every line, and every substance summed across its lines, to its category maximum — on a mixed load that is stricter than 1.1.3.6.4 (the conservative side). Transport category 0 substances can NEVER use this exemption — has_category_zero flags them. Provide un_number + quantity for a single substance, OR items[] for a load — never both: every field of the single-substance form (un_number, quantity, packing_group, variant_index, unit, basis) sent beside items[] is refused (the API answers 400 naming the field), never dropped — put it on the item it belongs to, a substance as an item of its own. Quantities are in kg or litres per the substance's ADR unit. An item quantity may be 0: the goods are not carried, the line is left out of the load (state EXCLUDED_NIL) and named in a warning — a load of nothing but zeros is refused, never cleared. un_number also takes an ID-prefixed air-only number (e.g. "ID8000") — see Routing. Multi-variant UNs: a UN number with more than one ADR Table A row (packing group / concentration variant — e.g. UN 1789 PG II vs PG III have different transport categories) needs packing_group (I|II|III) or variant_index (from adr_lookup) to pin one row. A packing_group that still leaves several rows is enough when those rows agree on class, transport category, scope and the 1.1.3.6.3 counted dimension (UN 1790 PG I: two concentration bands, both category 1) — the verdict is returned with items[].equivalent_variants + variant_note naming the rows it holds for; only when the rows DISAGREE (UN 2215 PG III: MOLTEN is category 0, the solid category 3) does it still ask for variant_index, and candidates[] then lists only that packing group's rows. With no disambiguator at all: a single-line call, or a load where EVERY line is ambiguous, returns blocking_errors[AMBIGUOUS_UN_VARIANT] + human_review_required + candidates[] (each candidate's item_index, un_number, variant_index, packing_group, proper_shipping_name, transport_category, multiplier) and NO verdict — blocking_errors is in the text content as well as structuredContent; a MIXED load withholds only the ambiguous line (items[].withheld true, points null, row fields null) while every other line keeps its points; total_points is null (1.1.3.6.4 sums every line, one term is unknown) and exempt is null UNLESS the resolved lines alone already disqualify the load — a CARRIAGE PROHIBITED entry, a category 0 entry, a per-substance maximum exceeded, or a partial sum already over 1,000 — in which case exempt is false with the ladder message (and carriage_prohibited true where that is the reason), because no packing group can undo those. warnings state the resolved lines' partial sum, candidates[] carry expected_unit (the 1.1.3.6.3 counted dimension — the only difference for UN 3375 PG II, liquid in L vs solid in kg), and the envelope carries human_review_required + candidates[] plus one AMBIGUOUS_UN_VARIANT warning per withheld line. Never a silently guessed row. Single-row UNs are unchanged. Scope verdicts: Table A rows listed "NOT SUBJECT TO ADR" or "CARRIAGE PROHIBITED" never enter the points math. An all-not-subject load (e.g. UN 1845 dry ice) returns not_subject_to_adr true with a dedicated message ("Not subject to ADR (road). Section 5.5.3 applies: ...") and, for dry ice, conditions[] quoting the ADR 2025 section 5.5.3 requirements verbatim (ventilation, package marking, warning mark, documentation, training). A load containing a CARRIAGE PROHIBITED entry returns exempt false with carriage_prohibited true. In a mixed load, not-subject items are excluded from the points and the exclusion is stated in warnings. Routing: every returned line carries state, in the words the FreightUtils document check uses — COUNTED (evaluated on one Table A row: its points, or a category 0 / CARRIAGE PROHIBITED row that settles the load), AIR_ONLY_ID, NOT_SUBJECT_TO_ADR, BLOCKED (no points from the line as sent — withheld, basis_mismatch, category_unresolved or entry_required; the line's own flag says which) or EXCLUDED_NIL (a stated quantity of 0, read as not carried: left out of every sum and test, items[].nil_quantity true, and named in a warning). An ID-prefixed number such as ID 8000 (consumer commodity) is an air-only identifier with no ADR Table A entry. It is counted out of 1.1.3.6 — AIR_ONLY_ID, nothing counted, items[].air_only_id true, row fields null — only when the request states, with icao_limited_quantity: true on that line, that the packages are limited quantities to the ICAO Technical Instructions (the 3.4.8 mark, or 3.4.10): 3.4.9 and 3.4.10 deem them to meet 3.4.1-3.4.4, and goods exempted under 1.1.3.4.2 are not taken into account by 1.1.3.6.5; goods not in such packages must be entered under their own UN numbers. Without that statement the ID line is BLOCKED (items[].entry_required true) and the load has no verdict unless the other lines settle it. icao_limited_quantity on a UN-numbered line is refused (the API answers 400). Only the ID prefix makes a line air-only — an ID number is never read as the UN number with the same digits — and a load whose every line is a stated air-only line returns total_points 0, exempt true with its own message, never "1.1.3.6 exemption applies" and never not_subject_to_adr. Gross figures: ADR 1.1.3.6.3 counts the dangerous goods themselves, never the packaging. A gross mass (basis "gross") on an entry counted by mass is read as an upper bound of the net mass: the load is answered exempt on it only when it clears even on the gross figure — then figure_basis is "upper_bound_gross" and the line carries upper_bound_gross true (its true points are lower). Otherwise, and always for an entry counted in litres, the line gets no points (basis_mismatch): send the net quantity. ADR 2027 basis: an ADR 2027 answer carries basis — what the verdict rests on: "adr_2027", or, on a stated as_of from 1 January 2027, a transitional measure open on that date that clears a load ADR 2027 itself does not: "1.6.1.61" (the ADR 2025 note-a rule, ×20 with a 50 kg maximum, until 31 December 2030) before "1.6.1.1" (the whole of ADR 2025, until 30 June 2027). Such an answer headlines the transitional basis that clears the load, names it, gives basis_until (the last day it may be applied) and puts the strict ADR 2027 figure beside it (strict_adr_2027: basis, total_points, exempt, has_category_zero, has_quantity_exceedance). A line whose entry is deleted in ADR 2027 (e.g. UN 2941) has no ADR 2027 figure at all: on a stated as_of from 2027-01-01 to 2027-06-30 the whole load is answered on ADR 2025 under 1.6.1.1 (basis "1.6.1.1", every line edition_basis "2025") and strict_adr_2027 carries entry_deleted true, deleted_un_numbers and message, its four figures null; outside that window, or without a stated as_of, the call is refused naming the deleted entry. Without a stated as_of, the strict ADR 2027 reading stays the headline. transitional_1_6_1_61 (a load with one of the nine note-a UN numbers) and transitional_1_6_1_1 (inside the 1.6.1.1 window, where ADR 2027 itself is not exempt) state the load on each basis: measure, basis, points_on_this_basis, exempt_on_this_basis, until, note. Behavior: deterministic points arithmetic over ADR 2025 reference data; a UN that cannot be found returns blocking_errors (NOT_FOUND); exempt is the overall verdict. Fields are checked by name: a field the tool does not read is refused with a tool error naming it and listing the accepted ones, never ignored. Rate-limited: a limit error carries reset_at, the UTC time the allowance resets. Returns: items[] (each with state, packing_group, variant_index, transport_category, multiplier, points, air_only_id + icao_limited_quantity or entry_required on an ID-prefixed line, nil_quantity on a 0 line, upper_bound_gross on a gross mass counted as an upper bound, edition_basis on an answer resting on 1.6.1.1 for an entry deleted in ADR 2027, quantity_unit/quantity_basis/expected_unit when a unit or basis was declared, scope flags where applicable, withheld + ambiguity_reason on an unpinned multi-variant line, and equivalent_variants + variant_note when a packing group resolved by equivalence), total_points (NULL when no verdict was reached), threshold (1000), exempt (NULL when no verdict was reached — never false as a stand-in), has_category_zero, has_quantity_exceedance, warnings, message, figure_basis, and on ADR 2027 answers basis, basis_until, strict_adr_2027 (with entry_deleted, deleted_un_numbers and message when an entry is deleted in ADR 2027), transitional_1_6_1_61, transitional_1_6_1_1, human_review_required + candidates[] when any line is withheld, and — on scope verdicts — not_subject_to_adr/conditions_ref/conditions[]/carriage_prohibited under result — or, when every line is ambiguous, human_review_required + candidates[] with blocking_errors, plus confidence, _source and citation (the FreightUtils v1 response envelope). Editions: edition ("2025" | "2027") and as_of (YYYY-MM-DD) choose the ADR edition — edition wins, else the date picks it (ADR 2025 before 2027-01-01, ADR 2027 from then; ADR 2025 may still be applied until 2027-06-30). An answer on a named edition carries adr_edition; neither sent, the answer is ADR 2025 until 2027-01-01. Limitations: a deterministic calculation over reference data, not legal advice — 1.1.3.6 relieves goods carried in packages only (not in bulk or in tanks), and this calculator takes no packaging input; even exempt loads keep core duties (packaging, marking, documentation), and mixed-packing rules still apply; verify against the current UNECE ADR text. Related: adr_lookup (per-substance data incl. transport category + variant_index), adr_lq_eq_check (the LQ/EQ relief routes instead of 1.1.3.6).

  mcp-tool

  123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528

  {
    "type": "object",
    "$schema": "http://json-schema.org/draft-07/schema#",
    "properties": {
      "unit": {
        "enum": [
          "L",
          "kg"
        ],
        "type": "string",
        "description": "OPTIONAL. The dimension `quantity` is stated in — 'L' or 'kg'. Omit it and the number is taken as already on the ADR 1.1.3.6.3 basis (the historical contract). Supply it and it is CHECKED against the dimension 1.1.3.6.3 counts for the row: litres for liquids and for compressed or adsorbed gases, kilograms for solids, liquefied/refrigerated/dissolved gases and articles. A mismatch returns no points and says which dimension the entry is counted in."
      },
      "as_of": {
        "type": "string",
        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
        "description": "YYYY-MM-DD the answer is for (default today, UTC); picks the ADR edition when edition is omitted, and is echoed in the answer and its check receipt."
      },
      "basis": {
        "enum": [
          "net",
          "gross"
        ],
        "type": "string",
        "description": "OPTIONAL. 'net' or 'gross'. ADR 1.1.3.6.3 counts the dangerous goods themselves, never the packaging. A 'gross' mass on an entry counted by mass is used only as an upper bound of the net mass: the load is answered exempt on it only when it clears even on the gross figure (figure_basis upper_bound_gross); otherwise, and always for an entry counted in litres, no points — send the net quantity."
      },
      "items": {
        "type": "array",
        "items": {
          "type": "object",
          "required": [
            "un_number",
            "quantity"
          ],
          "properties": {
            "unit": {
              "enum": [
                "L",
                "kg"
              ],
              "type": "string",
              "description": "OPTIONAL. As the top-level unit: checked against the dimension 1.1.3.6.3 counts for the row; a mismatch returns no points."
            },
            "basis": {
              "enum": [
                "net",
                "gross"
              ],
              "type": "string",
              "description": "OPTIONAL. As the top-level basis: a 'gross' mass is used only as an upper bound on an entry counted by mass, and only when the load clears on it."
            },
            "quantity": {
              "type": "number",
              "maximum": 1000000000,
              "minimum": 0,
              "description": "Quantity on the ADR 1.1.3.6.3 basis: net kg for solids and liquefied, refrigerated or dissolved gases; litres for liquids; receptacle water capacity in litres for compressed or adsorbed gases and chemicals under pressure; articles as the mass of the articles without their packagings, in kg."
            },
            "un_number": {
              "type": "string",
              "pattern": "^(?:\\s*(?:UN\\s*)?\\d{4}\\s*|\\s*ID\\s*[-:.]?\\s*\\d{4}\\s*)$",
              "description": "As the top-level un_number (4 digits, or an ID-prefixed air-only number: AIR_ONLY_ID with icao_limited_quantity: true, else BLOCKED)."
            },
            "packing_group": {
              "enum": [
                "I",
                "II",
                "III"
              ],
              "type": "string",
              "description": "Packing group for a multi-variant UN."
            },
            "variant_index": {
              "type": "integer",
              "maximum": 9007199254740991,
              "minimum": 0,
              "description": "ADR Table A variant index for a multi-variant UN."
            },
            "icao_limited_quantity": {
              "type": "boolean",
              "description": "OPTIONAL, ID-prefixed lines only: as the top-level icao_limited_quantity."
            }
          },
          "additionalProperties": false
        },
        "minItems": 1,
        "description": "Items for a mixed load. An item quantity may be 0: the goods are not carried, the line is left out of the load and named in a warning (a load of nothing but zeros is refused). With items[], the single-substance fields (un_number, quantity, packing_group, variant_index, unit, basis) are refused beside it (INVALID_INPUT) — each goes on its item."
      },
      "edition": {
        "enum": [
          "2025",
          "2027"
        ],
        "type": "string",
        "description": "ADR edition: \"2025\" or \"2027\". Wins over as_of. Omit it and as_of picks the edition by the legal timeline: before 2027-01-01 ADR 2025; from 2027-01-01 ADR 2027 (ADR 2025 may still be applied until 2027-06-30 under 1.6.1.1 — edition \"2025\" answers on it until then); from 2027-07-01 ADR 2027 only. An ADR 2027 answer for a date before 2027-01-01 carries an EDITION_NOT_YET_APPLICABLE warning."
      },
      "quantity": {
        "type": "number",
        "maximum": 1000000000,
        "description": "Quantity on the ADR 1.1.3.6.3 basis: net kg for solids and liquefied, refrigerated or dissolved gases; litres for liquids; receptacle water capacity in litres for compressed or adsorbed gases and chemicals under pressure; articles as the mass of the articles without their packagings, in kg.",
        "exclusiveMinimum": 0
      },
      "un_number": {
        "type": "string",
        "pattern": "^(?:\\s*(?:UN\\s*)?\\d{4}\\s*|\\s*ID\\s*[-:.]?\\s*\\d{4}\\s*)$",
        "description": "UN number for single check (4 digits, optionally \"UN\"-prefixed) — or an ID-prefixed air-only number such as \"ID8000\", which has no ADR Table A entry: counted out of 1.1.3.6 (AIR_ONLY_ID) only with icao_limited_quantity: true — the ADR answer for limited-quantity packages to the ICAO Technical Instructions, 3.4.9 / 3.4.10 / 1.1.3.6.5; without it the line is BLOCKED and the load has no verdict unless the other lines settle it."
      },
      "consignment": {
        "type": "object",
        "required": [
          "lines"
        ],
        "properties": {
          "crew": {
            "type": "object",
            "properties": {
              "specialisations": {
                "type": "array",
                "items": {
                  "enum": [
                    "class_1",
                    "class_7",
                    "tanks"
                  ],
                  "type": "string"
                },
                "maxItems": 3
              },
              "photo_identification": {
                "type": "boolean"
              },
              "awareness_training_1_3": {
                "type": "boolean"
              },
              "adr_training_certificate": {
                "type": "boolean"
              }
            },
            "additionalProperties": false
          },
          "lines": {
            "type": "array",
            "items": {
              "type": "object",
              "properties": {
                "dims": {
                  "type": "object",
                  "required": [
                    "l",
                    "w",
                    "h",
                    "unit"
                  ],
                  "properties": {
                    "h": {
                      "type": "number",
                      "maximum": 100000,
                      "exclusiveMinimum": 0
                    },
                    "l": {
                      "type": "number",
                      "maximum": 100000,
                      "exclusiveMinimum": 0
                    },
                    "w": {
                      "type": "number",
                      "maximum": 100000,
                      "exclusiveMinimum": 0
                    },
                    "unit": {
                      "enum": [
                        "mm",
                        "cm",
                        "m",
                        "in"
                      ],
                      "type": "string"
                    }
                  },
                  "additionalProperties": false
                },
                "value": {
                  "type": "object",
                  "required": [
                    "amount",
                    "currency"
                  ],
                  "properties": {
                    "amount": {
                      "type": "number",
                      "maximum": 1000000000000,
                      "minimum": 0
                    },
                    "currency": {
                      "type": "string",
                      "pattern": "^[A-Z]{3}$"
                    }
                  },
                  "additionalProperties": false
                },
                "hs_code": {
                  "type": "string",
                  "pattern": "^\\d{6,10}$"
                },
                "packages": {
                  "type": "object",
                  "required": [
                    "count"
                  ],
                  "properties": {
                    "type": {
                      "type": "string",
                      "maxLength": 40
                    },
                    "count": {
                      "type": "integer",
                      "maximum": 100000,
                      "exclusiveMinimum": 0
                    },
                    "un_mark": {
                      "type": "string",
                      "maxLength": 80,
                      "minLength": 1
                    },
                    "gross_kg": {
                      "type": "number",
                      "maximum": 1000000,
                      "exclusiveMinimum": 0
                    }
                  },
                  "additionalProperties": false
                },
                "quantity": {
                  "type": "object",
                  "required": [
                    "value"
                  ],
                  "properties": {
                    "unit": {
                      "enum": [
                        "L",
                        "kg"
                      ],
                      "type": "string"
                    },
                    "basis": {
                      "enum": [
                        "net",
                        "gross"
                      ],
                      "type": "string"
                    },
                    "value": {
                      "type": "number",
                      "maximum": 1000000000,
                      "minimum": 0
                    }
                  },
                  "additionalProperties": false
                },
                "stackable": {
                  "type": "boolean"
                },
                "un_number": {
                  "type": "string",
                  "pattern": "^(?:(?:UN\\s?)?\\d{4}|ID\\s?\\d{4})$"
                },
                "description": {
                  "type": "string",
                  "maxLength": 200
                },
                "packing_group": {
                  "enum": [
                    "I",
                    "II",
                    "III"
                  ],
                  "type": "string"
                },
                "variant_index": {
                  "type": "integer",
                  "maximum": 1000,
                  "minimum": 0
                },
                "inner_packaging": {
                  "type": "object",
                  "required": [
                    "quantity",
                    "unit"
                  ],
                  "properties": {
                    "unit": {
                      "enum": [
                        "ml",
                        "L",
                        "g",
                        "kg"
                      ],
                      "type": "string"
                    },
                    "regime": {
                      "enum": [
                        "lq",
                        "eq"
                      ],
                      "type": "string"
                    },
                    "quantity": {
                      "type": "number",
                      "maximum": 1000000,
                      "exclusiveMinimum": 0
                    },
                    "per_outer": {
                      "type": "integer",
                      "maximum": 100000,
                      "minimum": 1
                    }
                  },
                  "additionalProperties": false
                },
                "icao_limited_quantity": {
                  "type": "boolean"
                }
              },
              "additionalProperties": false
            },
            "maxItems": 50,
            "minItems": 1
          },
          "journey": {
            "type": "object",
            "properties": {
              "date": {
                "type": "string",
                "pattern": "^\\d{4}-\\d{2}-\\d{2}$"
              },
              "mode": {
                "enum": [
                  "road",
                  "air",
                  "sea",
                  "multimodal"
                ],
                "type": "string"
              },
              "origin": {
                "type": "string",
                "pattern": "^[A-Za-z]{2}(?:\\s?[A-Za-z2-9]{3})?$"
              },
              "destination": {
                "type": "string",
                "pattern": "^[A-Za-z]{2}(?:\\s?[A-Za-z2-9]{3})?$"
              },
              "tunnels_on_route": {
                "type": "array",
                "items": {
                  "enum": [
                    "A",
                    "B",
                    "C",
                    "D",
                    "E"
                  ],
                  "type": "string"
                },
                "maxItems": 20
              }
            },
            "additionalProperties": false
          },
          "options": {
            "type": "object",
            "properties": {
              "incoterm": {
                "enum": [
                  "EXW",
                  "FCA",
                  "FAS",
                  "FOB",
                  "CFR",
                  "CIF",
                  "CPT",
                  "CIP",
                  "DAP",
                  "DPU",
                  "DDP"
                ],
                "type": "string"
              },
              "awb_number": {
                "type": "string",
                "maxLength": 20
              },
              "freight_cost": {
                "type": "object",
                "required": [
                  "amount",
                  "currency"
                ],
                "properties": {
                  "amount": {
                    "type": "number",
                    "maximum": 1000000000000,
                    "minimum": 0
                  },
                  "currency": {
                    "type": "string",
                    "pattern": "^[A-Z]{3}$"
                  }
                },
                "additionalProperties": false
              },
              "insurance_cost": {
                "type": "object",
                "required": [
                  "amount",
                  "currency"
                ],
                "properties": {
                  "amount": {
                    "type": "number",
                    "maximum": 1000000000000,
                    "minimum": 0
                  },
                  "currency": {
                    "type": "string",
                    "pattern": "^[A-Z]{3}$"
                  }
                },
                "additionalProperties": false
              },
              "container_number": {
                "type": "string",
                "maxLength": 20
              },
              "air_volumetric_divisor": {
                "type": "number",
                "maximum": 10000,
                "exclusiveMinimum": 0
              }
            },
            "additionalProperties": false
          },
          "vehicle": {
            "type": "object",
            "properties": {
              "type": {
                "type": "string",
                "maxLength": 60
              },
              "axles": {
                "type": "integer",
                "maximum": 12,
                "minimum": 1
              },
              "max_mass_t": {
                "type": "number",
                "maximum": 100,
                "exclusiveMinimum": 0
              },
              "equipment_8_1_5": {
                "type": "array",
                "items": {
                  "enum": [
                    "wheel_chock",
                    "warning_signs",
                    "eye_rinsing_liquid",
                    "warning_vest",
                    "portable_lighting",
                    "protective_gloves",
                    "eye_protection",
                    "emergency_escape_mask",
                    "shovel",
                    "drain_seal",
                    "collecting_container"
                  ],
                  "type": "string"
                },
                "maxItems": 11
              },
              "foodstuffs_carried": {
                "type": "boolean"
              },
              "placards_displayed": {
                "type": "boolean"
              },
              "fire_extinguishers_kg": {
                "type": "array",
                "items": {
                  "type": "number",
                  "maximum": 100,
                  "exclusiveMinimum": 0
                },
                "maxItems": 20
              },
              "instructions_in_writing": {
                "type": "boolean"
              },
              "orange_plates_displayed": {
                "type": "boolean"
              }
            },
            "additionalProperties": false
          }
        },
        "description": "Alternative to the other arguments: the consignment object (https://www.freightutils.com/schema/consignment-object.v1.json) — lines[] (description, un_number, packing_group, variant_index, quantity {value, unit, basis}, packages {count, type, gross_kg, un_mark}, hs_code, value {amount, currency}, dims, stackable, icao_limited_quantity, inner_packaging), journey {origin, destination, date, tunnels_on_route, mode}, vehicle, crew, options. Send it alone; an input the tool needs and the object lacks comes back in missing_inputs.",
        "additionalProperties": false
      },
      "packing_group": {
        "enum": [
          "I",
          "II",
          "III"
        ],
        "type": "string",
        "description": "Packing group (I, II or III) — only needed to disambiguate a UN that has more than one ADR Table A row (e.g. UN 1789). Ignored for single-row UNs."
      },
      "variant_index": {
        "type": "integer",
        "maximum": 9007199254740991,
        "minimum": 0,
        "description": "ADR Table A variant index (as returned by adr_lookup) — pins one row when a UN has several variants that share a packing group (e.g. concentration bands). Ignored for single-row UNs."
      },
      "icao_limited_quantity": {
        "type": "boolean",
        "description": "OPTIONAL, only with an ID-prefixed un_number (e.g. ID8000): true states that the packages are limited quantities conforming to the ICAO Technical Instructions (the 3.4.8 mark, or 3.4.10). Only then is the line counted out of 1.1.3.6; without it the ID line is BLOCKED and the load has no verdict unless the other lines settle it."
      }
    },
    "additionalProperties": false
  }

  arguments 528 lines copy
• airline_lookup reads unknown 20h ago

  Search 6,356 airlines by name, IATA code, ICAO code, AWB prefix, or country. AWB prefixes are the first 3 digits of an air waybill number and identify the issuing carrier (e.g. 176 = Emirates). Provide ONE parameter: query is a ranked fuzzy search across names and codes; iata / icao / prefix / country are exact filters. Behavior: read-only; fuzzy query hits report their match quality through the envelope's confidence (basis match_quality, score 0-1) with a FUZZY_BEST_MATCH advisory naming the matched field; a query that contains no name falls back to the closest names in the dataset ("Emirats" → Emirates). A query or country answer is a list: summary rows, 25 per page, with total, truncated and next_offset (full: true for full records); an iata / icao / prefix answer is the holder records in full. Rate-limited: a limit error carries reset_at, the UTC time the allowance resets. Returns: count and results[] — per airline: airline_name, iata_code, icao_code, awb_prefix[], callsign, country, has_cargo and verification fields (aliases and sources in full records); prefix_shared + prefix_holders on every record with a prefix; on cargo records operational_status (active / ceased / unknown) with operational_status_basis, restrictions[] when the EU or UK Air Safety List names the carrier, and carrier-published cargo_website / tracking_url_template / dg_acceptance_url where they exist — under result, plus confidence, _source and citation (the FreightUtils v1 response envelope). Limitations: this dataset's provenance is pending independent verification (the envelope's provenance_status says so) — confirm operationally critical codes with IATA/ICAO or the carrier. Related: airport_lookup (searches AIRPORTS, not carriers), validate (checks an AWB number's check digit and names its airline from this dataset when one record holds the prefix, otherwise lists the candidates). Identifiers: Each record carries fu_id, a stable FreightUtils identifier (and fu_version_id where the dataset has editions); resolve_reference resolves one to exactly its record.

  mcp-tool

  1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859

  {
    "type": "object",
    "$schema": "http://json-schema.org/draft-07/schema#",
    "properties": {
      "full": {
        "type": "boolean",
        "description": "Lists only: true returns full records (provenance, sources, rationale) instead of summary rows. A single-record call always returns the full record."
      },
      "iata": {
        "type": "string",
        "pattern": "^[A-Za-z0-9]{2}$",
        "description": "Exact IATA code (2 alphanumeric chars)"
      },
      "icao": {
        "type": "string",
        "pattern": "^[A-Za-z]{3}$",
        "description": "Exact ICAO code (3 letters)"
      },
      "codes": {
        "type": "array",
        "items": {
          "type": "string",
          "maxLength": 4
        },
        "maxItems": 50,
        "minItems": 1,
        "description": "Batch: up to 50 airline codes — 2 characters IATA, 3 letters ICAO, 3 digits AWB prefix — answered as results[] in input order, each with its own status. Send alone."
      },
      "limit": {
        "type": "integer",
        "maximum": 100,
        "minimum": 1,
        "description": "Lists only: rows per page (default: every row for summaries; 5 with full: true)."
      },
      "query": {
        "type": "string",
        "maxLength": 200,
        "minLength": 2,
        "description": "General search (name, code, prefix or country — 2 to 200 chars)"
      },
      "offset": {
        "type": "integer",
        "maximum": 9007199254740991,
        "minimum": 0,
        "description": "Lists only: rows to skip (default 0). The response gives total and next_offset."
      },
      "prefix": {
        "type": "string",
        "pattern": "^\\d{3}$",
        "description": "AWB prefix (3 digits)"
      },
      "country": {
        "type": "string",
        "minLength": 2,
        "description": "Filter by country name (min 2 chars)"
      }
    },
    "additionalProperties": false
  }

  arguments 59 lines copy
• airport_lookup reads unknown 15h ago

  Look up an airport by IATA code (3 letters, e.g. "LHR"), ICAO code (4 chars, e.g. "EGLL"), or free-text name/city search (e.g. "heathrow"). Covers 86,248 airports worldwide (OurAirports, public domain, cross-checked vs OpenFlights + Wikidata). Provide ONE of iata, icao, or query; the optional type filter narrows results. Behavior: read-only; exact code hits return one record; ambiguous name searches return ranked candidates (exact codes first, then larger airports) with match quality reported via the envelope's confidence (basis match_quality); an unknown code errors with a not-found message. Rate-limited: a limit error carries reset_at, the UTC time the allowance resets. Returns: count and results[] — per airport: IATA + ICAO/ident, name, type (large/medium/small/heliport/closed/seaplane), municipality, region, country, latitude/longitude and elevation_ft — under result, plus confidence, _source and citation (the FreightUtils v1 response envelope). Limitations: reference data only — not for navigation; verify operationally critical codes with IATA / ICAO. Related: nearest_airport (find airports FROM a coordinate), airline_lookup (searches CARRIERS / AWB prefixes, not airports), unlocode_lookup (general transport locations, of which airports are one function). Identifiers: Each record carries fu_id, a stable FreightUtils identifier (and fu_version_id where the dataset has editions); resolve_reference resolves one to exactly its record.

  mcp-tool

  123456789101112131415161718192021222324252627282930313233343536373839404142434445

  {
    "type": "object",
    "$schema": "http://json-schema.org/draft-07/schema#",
    "properties": {
      "iata": {
        "type": "string",
        "pattern": "^[A-Za-z]{3}$",
        "description": "Exact IATA code (3 letters)"
      },
      "icao": {
        "type": "string",
        "pattern": "^[A-Za-z0-9]{4}$",
        "description": "Exact ICAO / ident (4 chars)"
      },
      "type": {
        "enum": [
          "large_airport",
          "medium_airport",
          "small_airport",
          "heliport",
          "closed",
          "seaplane_base"
        ],
        "type": "string",
        "description": "Optional filter by airport type"
      },
      "codes": {
        "type": "array",
        "items": {
          "type": "string",
          "maxLength": 4
        },
        "maxItems": 50,
        "minItems": 1,
        "description": "Batch: up to 50 airport codes — 3 letters IATA, 4 characters ICAO — answered as results[] in input order, each with its own status. Send alone."
      },
      "query": {
        "type": "string",
        "maxLength": 200,
        "minLength": 2,
        "description": "Name / city / municipality search (2 to 200 chars)"
      }
    },
    "additionalProperties": false
  }

  arguments 45 lines copy
• hs_code_lookup reads unknown 15h ago

  Search 6,940 WCO Harmonized System (HS 2022) commodity codes — the 6-digit international customs classification layer. The first 2 digits are the chapter, 4 the heading, 6 the subheading. Provide ONE of: query (free-text description search, min 2 chars), code (2-6 digit lookup, written with or without dots or spaces — "8471.30" is 847130 — returns the code plus its hierarchy), or section (Roman numeral I-XXI to browse a section). Behavior: read-only; description search runs first against the HS 2022 descriptions (UN Comtrade H6); when none contains the words, it falls back to the UK Trade Tariff search references (HMRC's index of everyday goods names), so "laptop" finds 847130 and "computers" finds heading 8471. A fallback match is medium confidence: matched_via names HMRC's index, the citation asks you to confirm the code, and the formal tariff wording ("automatic data processing machines") stays the surest search. count 0 with an empty results[] is still a valid answer when neither finds the words. Rate-limited: a limit error carries reset_at, the UTC time the allowance resets. Returns: the query/code echo, count and results[] (hscode, description and hierarchy context) under result, plus confidence, _source and citation (the FreightUtils v1 response envelope). Limitations: the 6-digit international level only — national tariff lines (8-10 digits) and duty rates are set per country; classification here is indicative, not a binding ruling. Related: uk_duty_calculator (duty/VAT for a code found here), ics2_check (EU ENS goods-description quality — a different check entirely). Identifiers: Each record carries fu_id, a stable FreightUtils identifier (and fu_version_id where the dataset has editions); resolve_reference resolves one to exactly its record.

  mcp-tool

  12345678910111213141516171819202122232425262728293031

  {
    "type": "object",
    "$schema": "http://json-schema.org/draft-07/schema#",
    "properties": {
      "code": {
        "type": "string",
        "description": "Exact HS code: 2–6 digits, written with or without dots or spaces (e.g. \"847130\", \"8471.30\", \"0901\")."
      },
      "codes": {
        "type": "array",
        "items": {
          "type": "string",
          "maxLength": 14
        },
        "maxItems": 50,
        "minItems": 1,
        "description": "Batch: up to 50 HS codes, answered as results[] in input order, each as its own code lookup with its own status. Send alone."
      },
      "query": {
        "type": "string",
        "minLength": 2,
        "description": "Search by product description (min 2 chars)"
      },
      "section": {
        "type": "string",
        "pattern": "^[ivxIVX]{1,5}$",
        "description": "Browse by section (Roman numeral I–XXI)"
      }
    },
    "additionalProperties": false
  }

  arguments 31 lines copy
• consignment_calculator reads unknown never probed

  Calculate per-line and grand totals for a multi-item mixed consignment: CBM, loading metres (LDM), volumetric weight, and the mode-specific chargeable figure (air chargeable weight, sea revenue tonnes, road LDM), plus objective advisory flags. Provide mode (sea | air | road, default road) and either lines[] (canonical — per line: quantity, dims {l,w,h,unit}, weight {value,unit}, optional description / hs_code / un_number / stackable) or the legacy flat items[] (dimensions in cm, weight in kg). Air uses an IATA volumetric divisor (default 6000, settable via options.air_volumetric_divisor); options.container_number / options.awb_number add a check-digit sanity flag. Behavior: deterministic; flags are advisory only — implausible density, mode/option mismatch, dangerous-goods presence by UN number against ADR 2025, and container/AWB check-digit validity — and never state that a shipment is permitted or compliant. Invalid lines error naming the offending field. Canonical schema: https://www.freightutils.com/schema/consignment.v1.json. Rate-limited: a limit error carries reset_at, the UTC time the allowance resets. Returns: schema_version, mode, per_line[] (cbm, gross_weight_kg, density, volumetric_weight_kg, ldm, revenue_tonnes, chargeable_weight_kg), totals (incl. billing_basis) and flags[] under result, plus confidence, _source and citation (the FreightUtils v1 response envelope). Editions: edition ("2025" | "2027") and as_of (YYYY-MM-DD) choose the ADR edition — edition wins, else the date picks it (ADR 2025 before 2027-01-01, ADR 2027 from then; ADR 2025 may still be applied until 2027-06-30). An answer on a named edition carries adr_edition; neither sent, the answer is ADR 2025 until 2027-01-01. Limitations: best-effort deterministic calculation and reference data — not regulatory, customs or dangerous-goods compliance advice; classification, documentation and carrier acceptance remain your responsibility. Related: cbm_calculator / chargeable_weight_calculator / ldm_calculator (single-figure versions), shipment_summary (adds vehicle/container suggestion and duty estimates), adr_lookup (what a flagged UN number is).

  mcp-tool

  123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628

  {
    "type": "object",
    "$schema": "http://json-schema.org/draft-07/schema#",
    "properties": {
      "mode": {
        "enum": [
          "sea",
          "air",
          "road"
        ],
        "type": "string",
        "description": "Transport mode: sea | air | road (default road). Selects the chargeable-weight basis."
      },
      "as_of": {
        "type": "string",
        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
        "description": "YYYY-MM-DD the answer is for (default today, UTC); picks the ADR edition when edition is omitted, and is echoed in the answer and its check receipt."
      },
      "items": {
        "type": "array",
        "items": {
          "type": "object",
          "required": [
            "length",
            "width",
            "height",
            "gross_weight"
          ],
          "properties": {
            "width": {
              "type": "number",
              "description": "Width in cm",
              "exclusiveMinimum": 0
            },
            "height": {
              "type": "number",
              "description": "Height in cm",
              "exclusiveMinimum": 0
            },
            "length": {
              "type": "number",
              "description": "Length in cm",
              "exclusiveMinimum": 0
            },
            "hs_code": {
              "type": "string",
              "description": "Optional HS commodity code"
            },
            "quantity": {
              "type": "integer",
              "maximum": 9007199254740991,
              "description": "Number of pieces (default 1)",
              "exclusiveMinimum": 0
            },
            "stackable": {
              "type": "boolean",
              "description": "Can the item be stacked?"
            },
            "un_number": {
              "type": "string",
              "description": "Optional UN number for dangerous-goods reference"
            },
            "description": {
              "type": "string",
              "description": "Item description"
            },
            "pallet_type": {
              "enum": [
                "none",
                "euro",
                "uk",
                "us",
                "custom"
              ],
              "type": "string",
              "description": "Pallet type (informational)"
            },
            "gross_weight": {
              "type": "number",
              "description": "Gross weight per piece in kg",
              "exclusiveMinimum": 0
            }
          },
          "additionalProperties": false
        },
        "maxItems": 50,
        "minItems": 1,
        "description": "Deprecated flat alias — dimensions in cm, weight in kg. Prefer \"lines\". Provide lines OR items."
      },
      "lines": {
        "type": "array",
        "items": {
          "type": "object",
          "required": [
            "quantity",
            "dims",
            "weight"
          ],
          "properties": {
            "dims": {
              "type": "object",
              "required": [
                "l",
                "w",
                "h",
                "unit"
              ],
              "properties": {
                "h": {
                  "type": "number",
                  "description": "Height in the given unit",
                  "exclusiveMinimum": 0
                },
                "l": {
                  "type": "number",
                  "description": "Length in the given unit",
                  "exclusiveMinimum": 0
                },
                "w": {
                  "type": "number",
                  "description": "Width in the given unit",
                  "exclusiveMinimum": 0
                },
                "unit": {
                  "enum": [
                    "mm",
                    "cm",
                    "m",
                    "in"
                  ],
                  "type": "string",
                  "description": "Dimension unit: mm | cm | m | in"
                }
              },
              "additionalProperties": false
            },
            "weight": {
              "type": "object",
              "required": [
                "value",
                "unit"
              ],
              "properties": {
                "unit": {
                  "enum": [
                    "kg",
                    "g",
                    "t",
                    "lb"
                  ],
                  "type": "string",
                  "description": "Weight unit: kg | g | t | lb"
                },
                "value": {
                  "type": "number",
                  "description": "Gross weight per piece in the given unit",
                  "exclusiveMinimum": 0
                }
              },
              "additionalProperties": false
            },
            "hs_code": {
              "type": "string",
              "pattern": "^\\d{6,10}$",
              "description": "Optional HS commodity code"
            },
            "quantity": {
              "type": "integer",
              "maximum": 100000,
              "description": "Number of identical pieces",
              "exclusiveMinimum": 0
            },
            "stackable": {
              "type": "boolean",
              "description": "Whether the line may be stacked two-high (halves its loading-metre footprint)"
            },
            "un_number": {
              "type": "string",
              "pattern": "^(UN)?\\d{4}$",
              "description": "Optional UN number for dangerous-goods reference"
            },
            "description": {
              "type": "string",
              "maxLength": 200,
              "description": "Optional item label"
            }
          },
          "additionalProperties": false
        },
        "maxItems": 50,
        "minItems": 1,
        "description": "Canonical consignment lines (preferred). Each: { quantity, dims:{l,w,h,unit}, weight:{value,unit}, optional description / hs_code / un_number / stackable }."
      },
      "edition": {
        "enum": [
          "2025",
          "2027"
        ],
        "type": "string",
        "description": "ADR edition: \"2025\" or \"2027\". Wins over as_of. Omit it and as_of picks the edition by the legal timeline: before 2027-01-01 ADR 2025; from 2027-01-01 ADR 2027 (ADR 2025 may still be applied until 2027-06-30 under 1.6.1.1 — edition \"2025\" answers on it until then); from 2027-07-01 ADR 2027 only. An ADR 2027 answer for a date before 2027-01-01 carries an EDITION_NOT_YET_APPLICABLE warning."
      },
      "options": {
        "type": "object",
        "properties": {
          "awb_number": {
            "type": "string",
            "maxLength": 20,
            "description": "IATA 11-digit air waybill number — check-digit validated, advisory only"
          },
          "container_number": {
            "type": "string",
            "maxLength": 20,
            "description": "ISO 6346 container number — check-digit validated, advisory only"
          },
          "air_volumetric_divisor": {
            "type": "number",
            "maximum": 10000,
            "description": "IATA volumetric divisor in cm³/kg (default 6000). Only affects air.",
            "exclusiveMinimum": 0
          }
        },
        "description": "Optional: { air_volumetric_divisor, container_number, awb_number }.",
        "additionalProperties": false
      },
      "consignment": {
        "type": "object",
        "required": [
          "lines"
        ],
        "properties": {
          "crew": {
            "type": "object",
            "properties": {
              "specialisations": {
                "type": "array",
                "items": {
                  "enum": [
                    "class_1",
                    "class_7",
                    "tanks"
                  ],
                  "type": "string"
                },
                "maxItems": 3
              },
              "photo_identification": {
                "type": "boolean"
              },
              "awareness_training_1_3": {
                "type": "boolean"
              },
              "adr_training_certificate": {
                "type": "boolean"
              }
            },
            "additionalProperties": false
          },
          "lines": {
            "type": "array",
            "items": {
              "type": "object",
              "properties": {
                "dims": {
                  "type": "object",
                  "required": [
                    "l",
                    "w",
                    "h",
                    "unit"
                  ],
                  "properties": {
                    "h": {
                      "type": "number",
                      "maximum": 100000,
                      "exclusiveMinimum": 0
                    },
                    "l": {
                      "type": "number",
                      "maximum": 100000,
                      "exclusiveMinimum": 0
                    },
                    "w": {
                      "type": "number",
                      "maximum": 100000,
                      "exclusiveMinimum": 0
                    },
                    "unit": {
                      "enum": [
                        "mm",
                        "cm",
                        "m",
                        "in"
                      ],
                      "type": "string"
                    }
                  },
                  "additionalProperties": false
                },
                "value": {
                  "type": "object",
                  "required": [
                    "amount",
                    "currency"
                  ],
                  "properties": {
                    "amount": {
                      "type": "number",
                      "maximum": 1000000000000,
                      "minimum": 0
                    },
                    "currency": {
                      "type": "string",
                      "pattern": "^[A-Z]{3}$"
                    }
                  },
                  "additionalProperties": false
                },
                "hs_code": {
                  "type": "string",
                  "pattern": "^\\d{6,10}$"
                },
                "packages": {
                  "type": "object",
                  "required": [
                    "count"
                  ],
                  "properties": {
                    "type": {
                      "type": "string",
                      "maxLength": 40
                    },
                    "count": {
                      "type": "integer",
                      "maximum": 100000,
                      "exclusiveMinimum": 0
                    },
                    "un_mark": {
                      "type": "string",
                      "maxLength": 80,
                      "minLength": 1
                    },
                    "gross_kg": {
                      "type": "number",
                      "maximum": 1000000,
                      "exclusiveMinimum": 0
                    }
                  },
                  "additionalProperties": false
                },
                "quantity": {
                  "type": "object",
                  "required": [
                    "value"
                  ],
                  "properties": {
                    "unit": {
                      "enum": [
                        "L",
                        "kg"
                      ],
                      "type": "string"
                    },
                    "basis": {
                      "enum": [
                        "net",
                        "gross"
                      ],
                      "type": "string"
                    },
                    "value": {
                      "type": "number",
                      "maximum": 1000000000,
                      "minimum": 0
                    }
                  },
                  "additionalProperties": false
                },
                "stackable": {
                  "type": "boolean"
                },
                "un_number": {
                  "type": "string",
                  "pattern": "^(?:(?:UN\\s?)?\\d{4}|ID\\s?\\d{4})$"
                },
                "description": {
                  "type": "string",
                  "maxLength": 200
                },
                "packing_group": {
                  "enum": [
                    "I",
                    "II",
                    "III"
                  ],
                  "type": "string"
                },
                "variant_index": {
                  "type": "integer",
                  "maximum": 1000,
                  "minimum": 0
                },
                "inner_packaging": {
                  "type": "object",
                  "required": [
                    "quantity",
                    "unit"
                  ],
                  "properties": {
                    "unit": {
                      "enum": [
                        "ml",
                        "L",
                        "g",
                        "kg"
                      ],
                      "type": "string"
                    },
                    "regime": {
                      "enum": [
                        "lq",
                        "eq"
                      ],
                      "type": "string"
                    },
                    "quantity": {
                      "type": "number",
                      "maximum": 1000000,
                      "exclusiveMinimum": 0
                    },
                    "per_outer": {
                      "type": "integer",
                      "maximum": 100000,
                      "minimum": 1
                    }
                  },
                  "additionalProperties": false
                },
                "icao_limited_quantity": {
                  "type": "boolean"
                }
              },
              "additionalProperties": false
            },
            "maxItems": 50,
            "minItems": 1
          },
          "journey": {
            "type": "object",
            "properties": {
              "date": {
                "type": "string",
                "pattern": "^\\d{4}-\\d{2}-\\d{2}$"
              },
              "mode": {
                "enum": [
                  "road",
                  "air",
                  "sea",
                  "multimodal"
                ],
                "type": "string"
              },
              "origin": {
                "type": "string",
                "pattern": "^[A-Za-z]{2}(?:\\s?[A-Za-z2-9]{3})?$"
              },
              "destination": {
                "type": "string",
                "pattern": "^[A-Za-z]{2}(?:\\s?[A-Za-z2-9]{3})?$"
              },
              "tunnels_on_route": {
                "type": "array",
                "items": {
                  "enum": [
                    "A",
                    "B",
                    "C",
                    "D",
                    "E"
                  ],
                  "type": "string"
                },
                "maxItems": 20
              }
            },
            "additionalProperties": false
          },
          "options": {
            "type": "object",
            "properties": {
              "incoterm": {
                "enum": [
                  "EXW",
                  "FCA",
                  "FAS",
                  "FOB",
                  "CFR",
                  "CIF",
                  "CPT",
                  "CIP",
                  "DAP",
                  "DPU",
                  "DDP"
                ],
                "type": "string"
              },
              "awb_number": {
                "type": "string",
                "maxLength": 20
              },
              "freight_cost": {
                "type": "object",
                "required": [
                  "amount",
                  "currency"
                ],
                "properties": {
                  "amount": {
                    "type": "number",
                    "maximum": 1000000000000,
                    "minimum": 0
                  },
                  "currency": {
                    "type": "string",
                    "pattern": "^[A-Z]{3}$"
                  }
                },
                "additionalProperties": false
              },
              "insurance_cost": {
                "type": "object",
                "required": [
                  "amount",
                  "currency"
                ],
                "properties": {
                  "amount": {
                    "type": "number",
                    "maximum": 1000000000000,
                    "minimum": 0
                  },
                  "currency": {
                    "type": "string",
                    "pattern": "^[A-Z]{3}$"
                  }
                },
                "additionalProperties": false
              },
              "container_number": {
                "type": "string",
                "maxLength": 20
              },
              "air_volumetric_divisor": {
                "type": "number",
                "maximum": 10000,
                "exclusiveMinimum": 0
              }
            },
            "additionalProperties": false
          },
          "vehicle": {
            "type": "object",
            "properties": {
              "type": {
                "type": "string",
                "maxLength": 60
              },
              "axles": {
                "type": "integer",
                "maximum": 12,
                "minimum": 1
              },
              "max_mass_t": {
                "type": "number",
                "maximum": 100,
                "exclusiveMinimum": 0
              },
              "equipment_8_1_5": {
                "type": "array",
                "items": {
                  "enum": [
                    "wheel_chock",
                    "warning_signs",
                    "eye_rinsing_liquid",
                    "warning_vest",
                    "portable_lighting",
                    "protective_gloves",
                    "eye_protection",
                    "emergency_escape_mask",
                    "shovel",
                    "drain_seal",
                    "collecting_container"
                  ],
                  "type": "string"
                },
                "maxItems": 11
              },
              "foodstuffs_carried": {
                "type": "boolean"
              },
              "placards_displayed": {
                "type": "boolean"
              },
              "fire_extinguishers_kg": {
                "type": "array",
                "items": {
                  "type": "number",
                  "maximum": 100,
                  "exclusiveMinimum": 0
                },
                "maxItems": 20
              },
              "instructions_in_writing": {
                "type": "boolean"
              },
              "orange_plates_displayed": {
                "type": "boolean"
              }
            },
            "additionalProperties": false
          }
        },
        "description": "Alternative to the other arguments: the consignment object (https://www.freightutils.com/schema/consignment-object.v1.json) — lines[] (description, un_number, packing_group, variant_index, quantity {value, unit, basis}, packages {count, type, gross_kg, un_mark}, hs_code, value {amount, currency}, dims, stackable, icao_limited_quantity, inner_packaging), journey {origin, destination, date, tunnels_on_route, mode}, vehicle, crew, options. Send it alone; an input the tool needs and the object lacks comes back in missing_inputs.",
        "additionalProperties": false
      }
    },
    "additionalProperties": false
  }

  arguments 628 lines copy
• shipment_summary reads unknown 11h ago

  Composite shipment analysis in one call: volume (CBM), gross and chargeable weight, road LDM with pallet spaces and a vehicle suggestion (road mode), volumetric weight (air), revenue tonnes with a container suggestion (sea), dangerous-goods presence for items carrying un_number, and UK duty estimates for items carrying hs_code + customs_value. Provide mode (road | air | sea | multimodal) and items[] (dims in cm, weight in kg PER ITEM, quantity; optional stackable, pallet_type, hs_code, un_number, customs_value PER ITEM, and adr_quantity — the TOTAL for the dangerous-goods line, all pieces together); origin/destination and incoterm refine the duty leg. Behavior: calls the ldm_calculator, adr_lookup and uk_duty_calculator engines directly; CBM, volumetric weight and revenue tonnes are the same arithmetic inline rather than a call out. Road LDM uses the 2.40 m loading-metre convention divisor and, like ldm_calculator, treats an item with no stackable flag as NOT stacked. modeSpecific.palletSpaces is pallet FLOOR POSITIONS (the figure ldm_calculator reports); palletRows is the separate row count. The suggested vehicle is the smallest that holds the load by its length, its payload and its pallet floor positions — the record's own count when it is a floor count, otherwise worked from its deck (a 7.5t rigid holds 15 Euro pallets on the floor; modeSpecific.suggestedVehicleFloorPositions says which) — and trailerUtilisation is of that vehicle (utilisationBasis names it); the suggested container is the smallest dry box whose record holds the volume and payload. Sections that cannot run (e.g. duty without a customs value) surface in warnings instead of failing the whole call. Fields are checked by name: a field the tool does not read is refused with a tool error naming it and listing the accepted ones, never ignored. Rate-limited: a limit error carries reset_at, the UTC time the allowance resets. Returns: mode, itemCount, totals {pieces, grossWeight, volumeCBM, chargeableWeight, billingBasis}, modeSpecific (LDM / pallet floor positions / pallet rows / suggested vehicle, or revenue tonnes / container), warnings and dataVersion (road mode attributes the vehicle dataset and the LDM divisor) under result — note this composite's result uses camelCase field names (legacy shape); plus confidence, _source and citation (the FreightUtils v1 response envelope). Editions: edition ("2025" | "2027") and as_of (YYYY-MM-DD) choose the ADR edition — edition wins, else the date picks it (ADR 2025 before 2027-01-01, ADR 2027 from then; ADR 2025 may still be applied until 2027-06-30). An answer on a named edition carries adr_edition; neither sent, the answer is ADR 2025 until 2027-01-01. Limitations: a planning summary, not a quotation or compliance determination. Related: consignment_calculator (canonical snake_case lines[] shape with advisory flags), cbm_calculator, chargeable_weight_calculator, ldm_calculator, adr_lookup, uk_duty_calculator. ldm_calculator, adr_lookup and uk_duty_calculator are the engines this actually calls; the rest are the single-purpose equivalents of arithmetic it does inline.

  mcp-tool

  123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564

  {
    "type": "object",
    "$schema": "http://json-schema.org/draft-07/schema#",
    "properties": {
      "mode": {
        "enum": [
          "road",
          "air",
          "sea",
          "multimodal"
        ],
        "type": "string",
        "description": "Transport mode. Required unless the consignment object is sent."
      },
      "as_of": {
        "type": "string",
        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
        "description": "YYYY-MM-DD the answer is for (default today, UTC); picks the ADR edition when edition is omitted, and is echoed in the answer and its check receipt."
      },
      "items": {
        "type": "array",
        "items": {
          "type": "object",
          "required": [
            "length",
            "width",
            "height",
            "weight",
            "quantity"
          ],
          "properties": {
            "width": {
              "type": "number",
              "description": "Width cm",
              "exclusiveMinimum": 0
            },
            "height": {
              "type": "number",
              "description": "Height cm",
              "exclusiveMinimum": 0
            },
            "length": {
              "type": "number",
              "description": "Length cm",
              "exclusiveMinimum": 0
            },
            "weight": {
              "type": "number",
              "minimum": 0,
              "description": "Gross weight kg per item"
            },
            "hs_code": {
              "type": "string"
            },
            "quantity": {
              "type": "integer",
              "maximum": 1000000,
              "exclusiveMinimum": 0
            },
            "stackable": {
              "type": "boolean",
              "description": "Whether this item can be stacked (affects pallet fitting calc)"
            },
            "un_number": {
              "type": "string"
            },
            "description": {
              "type": "string"
            },
            "pallet_type": {
              "enum": [
                "euro",
                "uk",
                "us",
                "custom",
                "none"
              ],
              "type": "string",
              "description": "Pallet standard the item sits on, if any"
            },
            "adr_quantity": {
              "type": "number",
              "maximum": 1000000000,
              "description": "ADR 1.1.3.6.3 quantity for this dangerous-goods line — the total for the whole line, all pieces together (never per piece), in adr_quantity_unit. SEPARATE from weight, which is gross package mass — 1.1.3.6.3 counts none of its four categories that way. Supply both on EVERY dangerous-goods line and adrFlags.totalPoints is calculated; omit either and it stays null.",
              "exclusiveMinimum": 0
            },
            "customs_value": {
              "type": "number",
              "minimum": 0,
              "description": "Customs value in GBP PER ITEM (per piece), 0 or more — multiplied by quantity for the line; the duty estimate uses the sum over all lines."
            },
            "adr_quantity_unit": {
              "enum": [
                "L",
                "kg"
              ],
              "type": "string",
              "description": "Dimension of adr_quantity. Checked against the dimension 1.1.3.6.3 counts for the row — a litres row given kilograms still withholds the total."
            }
          },
          "additionalProperties": false
        },
        "maxItems": 50,
        "minItems": 1,
        "description": "Array of shipment items with dimensions, weight, and optional HS/UN codes. Required unless the consignment object is sent."
      },
      "origin": {
        "type": "object",
        "required": [
          "country"
        ],
        "properties": {
          "locode": {
            "type": "string"
          },
          "country": {
            "type": "string"
          }
        },
        "description": "Origin location — ISO country code and optional UN/LOCODE",
        "additionalProperties": false
      },
      "edition": {
        "enum": [
          "2025",
          "2027"
        ],
        "type": "string",
        "description": "ADR edition: \"2025\" or \"2027\". Wins over as_of. Omit it and as_of picks the edition by the legal timeline: before 2027-01-01 ADR 2025; from 2027-01-01 ADR 2027 (ADR 2025 may still be applied until 2027-06-30 under 1.6.1.1 — edition \"2025\" answers on it until then); from 2027-07-01 ADR 2027 only. An ADR 2027 answer for a date before 2027-01-01 carries an EDITION_NOT_YET_APPLICABLE warning."
      },
      "incoterm": {
        "type": "string",
        "description": "Incoterms 2020 three-letter code (e.g. 'DAP', 'EXW', 'FOB')"
      },
      "consignment": {
        "type": "object",
        "required": [
          "lines"
        ],
        "properties": {
          "crew": {
            "type": "object",
            "properties": {
              "specialisations": {
                "type": "array",
                "items": {
                  "enum": [
                    "class_1",
                    "class_7",
                    "tanks"
                  ],
                  "type": "string"
                },
                "maxItems": 3
              },
              "photo_identification": {
                "type": "boolean"
              },
              "awareness_training_1_3": {
                "type": "boolean"
              },
              "adr_training_certificate": {
                "type": "boolean"
              }
            },
            "additionalProperties": false
          },
          "lines": {
            "type": "array",
            "items": {
              "type": "object",
              "properties": {
                "dims": {
                  "type": "object",
                  "required": [
                    "l",
                    "w",
                    "h",
                    "unit"
                  ],
                  "properties": {
                    "h": {
                      "type": "number",
                      "maximum": 100000,
                      "exclusiveMinimum": 0
                    },
                    "l": {
                      "type": "number",
                      "maximum": 100000,
                      "exclusiveMinimum": 0
                    },
                    "w": {
                      "type": "number",
                      "maximum": 100000,
                      "exclusiveMinimum": 0
                    },
                    "unit": {
                      "enum": [
                        "mm",
                        "cm",
                        "m",
                        "in"
                      ],
                      "type": "string"
                    }
                  },
                  "additionalProperties": false
                },
                "value": {
                  "type": "object",
                  "required": [
                    "amount",
                    "currency"
                  ],
                  "properties": {
                    "amount": {
                      "type": "number",
                      "maximum": 1000000000000,
                      "minimum": 0
                    },
                    "currency": {
                      "type": "string",
                      "pattern": "^[A-Z]{3}$"
                    }
                  },
                  "additionalProperties": false
                },
                "hs_code": {
                  "type": "string",
                  "pattern": "^\\d{6,10}$"
                },
                "packages": {
                  "type": "object",
                  "required": [
                    "count"
                  ],
                  "properties": {
                    "type": {
                      "type": "string",
                      "maxLength": 40
                    },
                    "count": {
                      "type": "integer",
                      "maximum": 100000,
                      "exclusiveMinimum": 0
                    },
                    "un_mark": {
                      "type": "string",
                      "maxLength": 80,
                      "minLength": 1
                    },
                    "gross_kg": {
                      "type": "number",
                      "maximum": 1000000,
                      "exclusiveMinimum": 0
                    }
                  },
                  "additionalProperties": false
                },
                "quantity": {
                  "type": "object",
                  "required": [
                    "value"
                  ],
                  "properties": {
                    "unit": {
                      "enum": [
                        "L",
                        "kg"
                      ],
                      "type": "string"
                    },
                    "basis": {
                      "enum": [
                        "net",
                        "gross"
                      ],
                      "type": "string"
                    },
                    "value": {
                      "type": "number",
                      "maximum": 1000000000,
                      "minimum": 0
                    }
                  },
                  "additionalProperties": false
                },
                "stackable": {
                  "type": "boolean"
                },
                "un_number": {
                  "type": "string",
                  "pattern": "^(?:(?:UN\\s?)?\\d{4}|ID\\s?\\d{4})$"
                },
                "description": {
                  "type": "string",
                  "maxLength": 200
                },
                "packing_group": {
                  "enum": [
                    "I",
                    "II",
                    "III"
                  ],
                  "type": "string"
                },
                "variant_index": {
                  "type": "integer",
                  "maximum": 1000,
                  "minimum": 0
                },
                "inner_packaging": {
                  "type": "object",
                  "required": [
                    "quantity",
                    "unit"
                  ],
                  "properties": {
                    "unit": {
                      "enum": [
                        "ml",
                        "L",
                        "g",
                        "kg"
                      ],
                      "type": "string"
                    },
                    "regime": {
                      "enum": [
                        "lq",
                        "eq"
                      ],
                      "type": "string"
                    },
                    "quantity": {
                      "type": "number",
                      "maximum": 1000000,
                      "exclusiveMinimum": 0
                    },
                    "per_outer": {
                      "type": "integer",
                      "maximum": 100000,
                      "minimum": 1
                    }
                  },
                  "additionalProperties": false
                },
                "icao_limited_quantity": {
                  "type": "boolean"
                }
              },
              "additionalProperties": false
            },
            "maxItems": 50,
            "minItems": 1
          },
          "journey": {
            "type": "object",
            "properties": {
              "date": {
                "type": "string",
                "pattern": "^\\d{4}-\\d{2}-\\d{2}$"
              },
              "mode": {
                "enum": [
                  "road",
                  "air",
                  "sea",
                  "multimodal"
                ],
                "type": "string"
              },
              "origin": {
                "type": "string",
                "pattern": "^[A-Za-z]{2}(?:\\s?[A-Za-z2-9]{3})?$"
              },
              "destination": {
                "type": "string",
                "pattern": "^[A-Za-z]{2}(?:\\s?[A-Za-z2-9]{3})?$"
              },
              "tunnels_on_route": {
                "type": "array",
                "items": {
                  "enum": [
                    "A",
                    "B",
                    "C",
                    "D",
                    "E"
                  ],
                  "type": "string"
                },
                "maxItems": 20
              }
            },
            "additionalProperties": false
          },
          "options": {
            "type": "object",
            "properties": {
              "incoterm": {
                "enum": [
                  "EXW",
                  "FCA",
                  "FAS",
                  "FOB",
                  "CFR",
                  "CIF",
                  "CPT",
                  "CIP",
                  "DAP",
                  "DPU",
                  "DDP"
                ],
                "type": "string"
              },
              "awb_number": {
                "type": "string",
                "maxLength": 20
              },
              "freight_cost": {
                "type": "object",
                "required": [
                  "amount",
                  "currency"
                ],
                "properties": {
                  "amount": {
                    "type": "number",
                    "maximum": 1000000000000,
                    "minimum": 0
                  },
                  "currency": {
                    "type": "string",
                    "pattern": "^[A-Z]{3}$"
                  }
                },
                "additionalProperties": false
              },
              "insurance_cost": {
                "type": "object",
                "required": [
                  "amount",
                  "currency"
                ],
                "properties": {
                  "amount": {
                    "type": "number",
                    "maximum": 1000000000000,
                    "minimum": 0
                  },
                  "currency": {
                    "type": "string",
                    "pattern": "^[A-Z]{3}$"
                  }
                },
                "additionalProperties": false
              },
              "container_number": {
                "type": "string",
                "maxLength": 20
              },
              "air_volumetric_divisor": {
                "type": "number",
                "maximum": 10000,
                "exclusiveMinimum": 0
              }
            },
            "additionalProperties": false
          },
          "vehicle": {
            "type": "object",
            "properties": {
              "type": {
                "type": "string",
                "maxLength": 60
              },
              "axles": {
                "type": "integer",
                "maximum": 12,
                "minimum": 1
              },
              "max_mass_t": {
                "type": "number",
                "maximum": 100,
                "exclusiveMinimum": 0
              },
              "equipment_8_1_5": {
                "type": "array",
                "items": {
                  "enum": [
                    "wheel_chock",
                    "warning_signs",
                    "eye_rinsing_liquid",
                    "warning_vest",
                    "portable_lighting",
                    "protective_gloves",
                    "eye_protection",
                    "emergency_escape_mask",
                    "shovel",
                    "drain_seal",
                    "collecting_container"
                  ],
                  "type": "string"
                },
                "maxItems": 11
              },
              "foodstuffs_carried": {
                "type": "boolean"
              },
              "placards_displayed": {
                "type": "boolean"
              },
              "fire_extinguishers_kg": {
                "type": "array",
                "items": {
                  "type": "number",
                  "maximum": 100,
                  "exclusiveMinimum": 0
                },
                "maxItems": 20
              },
              "instructions_in_writing": {
                "type": "boolean"
              },
              "orange_plates_displayed": {
                "type": "boolean"
              }
            },
            "additionalProperties": false
          }
        },
        "description": "Alternative to the other arguments: the consignment object (https://www.freightutils.com/schema/consignment-object.v1.json) — lines[] (description, un_number, packing_group, variant_index, quantity {value, unit, basis}, packages {count, type, gross_kg, un_mark}, hs_code, value {amount, currency}, dims, stackable, icao_limited_quantity, inner_packaging), journey {origin, destination, date, tunnels_on_route, mode}, vehicle, crew, options. Send it alone; an input the tool needs and the object lacks comes back in missing_inputs.",
        "additionalProperties": false
      },
      "destination": {
        "type": "object",
        "required": [
          "country"
        ],
        "properties": {
          "locode": {
            "type": "string"
          },
          "country": {
            "type": "string"
          }
        },
        "description": "Destination location — ISO country code and optional UN/LOCODE",
        "additionalProperties": false
      },
      "freight_cost": {
        "type": "number",
        "minimum": 0,
        "description": "Optional freight cost in GBP for duty calculation, 0 or more (default 0)"
      },
      "insurance_cost": {
        "type": "number",
        "minimum": 0,
        "description": "Optional insurance cost in GBP for duty calculation, 0 or more (default 0)"
      }
    },
    "additionalProperties": false
  }

  arguments 564 lines copy
• adr_consignment_check unknown never probed

  One call on the consignment object for the ADR picture of a road load: the 1.1.3.6 small-load verdict, the limited / excepted quantity check of each line, the tunnel restriction code of the whole load against the tunnels on the route, each line's transport-document entry, mixed loading (7.5.2, with the foodstuffs precautions of 7.5.4), and the vehicle side — orange-coloured plates and placards (5.3), the documents, fire extinguishers and equipment on the transport unit (8.1), and driver training (8.2); and the UN packaging mark of each line (6.1.3.1). The rules are page-cited to the free UNECE ADR 2025 publication. Provide lines[] — each dangerous-goods line with un_number, quantity {value, unit, basis} and, where it applies, packing_group / variant_index, packages {count, type, gross_kg, un_mark (the UN packaging mark as printed, 6.1.3.1)}, inner_packaging {quantity, unit, per_outer?, regime?} and (ID lines only) icao_limited_quantity — and optionally journey {date, tunnels_on_route (A–E), mode}, vehicle {max_mass_t (the transport unit's maximum permissible mass — the 8.1.4.1 band, 3.4.13), foodstuffs_carried (ADR 7.5.4), fire_extinguishers_kg[], orange_plates_displayed, placards_displayed, equipment_8_1_5[] (the 8.1.5 items by name), instructions_in_writing}, crew {adr_training_certificate, specialisations[] (class_1, class_7, tanks), photo_identification, awareness_training_1_3}, edition and as_of. journey.date is the default as_of; an as_of that contradicts it is refused. Behavior: deterministic. The 1.1.3.6 check is the adr_exemption_calculator's answer, whole (basis, basis_until, strict_adr_2027, items[].state incl. EXCLUDED_NIL / BLOCKED / AIR_ONLY_ID). The LQ / EQ checks are the adr_lq_eq_check answer per line with inner_packaging. The tunnel check assigns the whole load the most restrictive code (8.6.3.2, ranked by the categories the 8.6.4 table forbids for the carriage), gives which tunnels on the route the load may use without and with the 1.1.3.6 relief (8.6.3.3: goods carried under 1.1.3 are not subject to tunnel restrictions unless the unit must bear the 3.4.13 mark), and computes the net explosive mass for B1000C / C5000D. The document entries follow 5.4.1.1.1 (a), (b), (c), (d), (k) in that order, from Table A columns (1)–(5) and (15) — e.g. "UN 1098 ALLYL ALCOHOL, 6.1 (3), I, (C/D)"; a row whose name joins names by "or" gives one entry per name (3.1.2.2); for a load within 1.1.3.6 the total quantity and calculated value per transport category (NOTE 1 to 5.4.1.1.1 (f)). A generic or N.O.S. row assigned special provision 274 or 318 is conditional on the document until its technical name is added in brackets (3.1.2.8.1 — the object carries none); a CARRIAGE PROHIBITED line and an ID line get no entry (entry null, the reason given) and leave the document insufficient_data — an ID line stated as an ICAO limited quantity carries no entry (3.4.1) and is not counted against it. Mixed loading reads the lines as one load in one transport unit: every pair of lines against the 7.5.2.1 table by the labels of Table A column (5) (subsidiary labels included; "4.1 + 1" / "5.2 + 1" as printed), Class 1 pairs against the 7.5.2.2 table by compatibility group; a lettered note the rows settle is settled (1.4S; UN 2990 / 3072 / 3268; UN 0503 with 3268), one that turns on a fact the object does not carry answers conditional with the note quoted; a line whose LQ / EQ check passes is still read as a package of its row, with the 3.4.1 / 3.5.1.1 relief and 7.5.2.4 stated as conditions; a load within 1.1.3.6 is checked all the same (1.1.3.6.2 does not lift 7.5.2); goods with CV28 engage 7.5.4 (ADR 2027: as amended). The vehicle side lists, per check, the requirements the load puts on the vehicle — read from the Table A rows (class, classification code, column (5) labels, column (19) S-provisions) and the 1.1.3.6 verdict — and checks each against its input: met → pass, not met → fail with the rule quoted, not sent → conditional (the input named, optional, in missing_inputs). Plates: two plain orange-coloured plates (5.3.2.1.1); placards on a vehicle carrying packages only for Class 1 other than 1.4S and Class 7 other than excepted packages (5.3.1.5), the model by 5.3.1.1.2; the 5.3.6 mark with placards; the 3.4.13 LQ mark as a condition on a unit over 12 t. Equipment: the 8.1.2.1 documents, the 8.1.4.1 extinguisher table by mass, the 8.1.5 items by danger label. Training: the 8.2.1 certificate and the Class 1 / Class 7 specialisation (8.2.1.4). Under 1.1.3.6 they read 1.1.3.6.2: no Chapter 5.3, one 2 kg extinguisher (8.1.4.2), the transport document, training per Chapter 1.3 (8.2.3) for a driver without the certificate. Where the text does not settle a case (a code that splits tank and other carriage on a line with no packages; a Class 1 line not in net kg) the check asks instead of assuming. fail means a check the load does not meet; a relief that does not apply is not_applicable, not fail, and does not change the status — a load outside 1.1.3.6 (the full requirements apply, and the other checks answer for a fully regulated load) or a line with no stated regime that fits neither LQ nor EQ; a stated regime that is missed, and a CARRIAGE PROHIBITED entry, still fail. The packaging check reads each line's packages.un_mark by the grammar of 6.1.3.1 — (a) the symbol, (b) the code of the 6.1.2.7 table (T / V / W may follow), (c) the packing-group letter and the relative density or gross mass, (d) S or the test pressure (rounded down to 10 kPa), (e) year, (f) State, (g) maker — and holds the letter against the line's packing group (X: I, II, III; Y: II, III; Z: III): malformed, or a letter that does not cover it → fail with the field named; no mark → conditional (optional, in missing_inputs); a line within its stated LQ / EQ regime and sent without a mark → not_applicable (3.4.1 / 3.5.1.1); a Class 7 package or a Class 2 gas in pressure receptacles (column (8) P200 / P203) → not_applicable (marked under 6.4 / 6.2), any other Class 2 line → not_assessed; an ID line, or a line that matches more than one Table A row → insufficient_data; a row without a packing group → conditional (the letter is held against the level its packing instruction sets, not read); an IBC or large-packaging mark → conditional (6.5.2.1.1 / 6.6.3.1 not read). A limited / excepted quantity line whose stated regime is met is left out of the 1.1.3.6 total (1.1.3.6.5; exemption_1_1_3_6.engine.excluded_lines names it); a line that states no regime is counted. regime names the rules the checks answered under: "1.1.3.6" (the load is within it — the vehicle side reads 1.1.3.6.2), "full_adr" (it is not — a fully regulated load), "undetermined" (the 1.1.3.6 check gave no verdict). Rate-limited: a limit error carries reset_at, the UTC time the allowance resets. Returns: status (pass | fail | conditional | insufficient_data), regime ("1.1.3.6" | "full_adr" | "undetermined" — the rules the checks answered under; null without dangerous goods), missing_inputs[] ({name, check, what}), checks_performed[] ({name, verdict, required, edition, as_of, basis, citations[] — section, volume, PDF page, a short quotation}), edition, as_of, edition_basis, lines[], exemption_1_1_3_6 {verdict, basis, conditions, engine}, limited_quantities and excepted_quantities {verdict, lines[] {line_index, verdict, reason, answer}}, tunnel_restriction {verdict, lines[], whole_load {codes, forbidden_categories, complete}, route {tunnels_on_route, without_1_1_3_6_relief, with_1_1_3_6_relief}, needs_info[]}, transport_document {verdict, lines[] (elements a–k, strings; entry null and a reason where no entry is written), exemption_1_1_3_6_statement, conditions[]}, mixed_loading_7_5_2 {verdict, basis, lines[] {line_index, un_number, labels[], classification_code, compatibility_group}, pairs[] {a, b, labels_a, labels_b, permitted (true | false | "conditional"), cell, note, source_ref}, class_1 {assessed, pairs[]}, foodstuffs {engaged, lines[], input, verdict}, conditions[], needs_info[], notes[]}, placards_and_plates_5_3 {verdict, basis, requirements[] {id, applies (true | false | "under_relief_only" | "conditional"), basis, quantity, specification, lines[], source_ref}, orange_plates {required, numbered}, placards {required, lines[] {line_index, placards[]}}, marks[], lq_mark {applies, condition}, conditions[], needs_info[], notes[]}, equipment_8_1 {verdict, basis, requirements[], fire_extinguishers {band, minimum_total_kg, minimum_largest_kg, small_load_rule, on_board, verdict}, general_equipment[] and label_specific_equipment[] {item, applies, lines[], on_board, outcome}, documents[], conditions[], needs_info[], notes[]}, driver_training_8_2 {verdict, basis, requirements[], certificate {required, under_relief, specialisations[], outcome}, awareness_training_1_3 {applies, outcome}, conditions[], needs_info[], notes[]}, packaging_code_validity {verdict, basis, lines[] {line_index, un_number, verdict, mark, field (on fail: the 6.1.3.1 sub-paragraph), parsed {symbol, code, code_suffix, letter, covers, relative_density, max_gross_mass_kg, solids_or_inner, test_pressure_kpa, year, state, manufacturer}, reason}, notes[]} — all under result — plus confidence, _source and citation (the FreightUtils v1 response envelope). A call made with an API key stores a check receipt (_meta.check_id); without one the answer carries the receipt hash (_meta.receipt) and nothing is stored. Editions: edition ("2025" | "2027") and as_of (YYYY-MM-DD) choose the ADR edition — edition wins, else the date picks it (ADR 2025 before 2027-01-01, ADR 2027 from then; ADR 2025 may still be applied until 2027-06-30). An answer on a named edition carries adr_edition; neither sent, the answer is ADR 2025 until 2027-01-01. Limitations: the packaging check reads the mark, not the packaging kind — whether the packaging is one the line's packing instruction (Table A column (8)) allows is not checked (6.1.3 NOTE 1), IBC / large-packaging marks are named, not read, and on a row without a packing group (articles, most of Class 1) the letter is not held against anything; without packages.un_mark a dangerous-goods line is conditional on the packaging check; the vehicle-side checks read the load, so without the vehicle.* / crew.* inputs a dangerous-goods load is conditional (the requirements listed); the vehicle side does not assess the vehicle approval of Part 9, the elevated temperature mark (5.3.3 — the object carries no temperature), handling and stowage (7.5.7) or national equivalent training; a limited / excepted quantity relief is applied only where the line states it (inner_packaging.regime) and meets it — in the 1.1.3.6 total — and is otherwise stated as a condition, never assumed; the foodstuffs part of mixed loading needs vehicle.foodstuffs_carried (without it, a condition); column (6) special provisions that change the labels are not applied; limited / excepted quantities are not taken out of the tunnel code (the object does not say a line is carried so); not legal advice, verify against the current UNECE ADR text. Related: adr_exemption_calculator (the 1.1.3.6 check alone), adr_lq_eq_check (LQ / EQ alone), adr_lookup (a row's columns). Identifiers: Each record carries fu_id, a stable FreightUtils identifier (and fu_version_id where the dataset has editions); resolve_reference resolves one to exactly its record.

  mcp-tool

  123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418

  {
    "type": "object",
    "$schema": "http://json-schema.org/draft-07/schema#",
    "required": [
      "lines"
    ],
    "properties": {
      "crew": {
        "type": "object",
        "properties": {
          "specialisations": {
            "type": "array",
            "items": {
              "enum": [
                "class_1",
                "class_7",
                "tanks"
              ],
              "type": "string"
            },
            "maxItems": 3
          },
          "photo_identification": {
            "type": "boolean"
          },
          "awareness_training_1_3": {
            "type": "boolean"
          },
          "adr_training_certificate": {
            "type": "boolean"
          }
        },
        "description": "The vehicle crew, for the driver-training and document checks (ADR 8.2, 8.1.2). Facts only — no name.",
        "additionalProperties": false
      },
      "as_of": {
        "type": "string",
        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
        "description": "YYYY-MM-DD the answer is for (default today, UTC); picks the ADR edition when edition is omitted, and is echoed in the answer and its check receipt."
      },
      "lines": {
        "type": "array",
        "items": {
          "type": "object",
          "properties": {
            "dims": {
              "type": "object",
              "required": [
                "l",
                "w",
                "h",
                "unit"
              ],
              "properties": {
                "h": {
                  "type": "number",
                  "maximum": 100000,
                  "exclusiveMinimum": 0
                },
                "l": {
                  "type": "number",
                  "maximum": 100000,
                  "exclusiveMinimum": 0
                },
                "w": {
                  "type": "number",
                  "maximum": 100000,
                  "exclusiveMinimum": 0
                },
                "unit": {
                  "enum": [
                    "mm",
                    "cm",
                    "m",
                    "in"
                  ],
                  "type": "string"
                }
              },
              "additionalProperties": false
            },
            "value": {
              "type": "object",
              "required": [
                "amount",
                "currency"
              ],
              "properties": {
                "amount": {
                  "type": "number",
                  "maximum": 1000000000000,
                  "minimum": 0
                },
                "currency": {
                  "type": "string",
                  "pattern": "^[A-Z]{3}$"
                }
              },
              "additionalProperties": false
            },
            "hs_code": {
              "type": "string",
              "pattern": "^\\d{6,10}$"
            },
            "packages": {
              "type": "object",
              "required": [
                "count"
              ],
              "properties": {
                "type": {
                  "type": "string",
                  "maxLength": 40
                },
                "count": {
                  "type": "integer",
                  "maximum": 100000,
                  "exclusiveMinimum": 0
                },
                "un_mark": {
                  "type": "string",
                  "maxLength": 80,
                  "minLength": 1
                },
                "gross_kg": {
                  "type": "number",
                  "maximum": 1000000,
                  "exclusiveMinimum": 0
                }
              },
              "additionalProperties": false
            },
            "quantity": {
              "type": "object",
              "required": [
                "value"
              ],
              "properties": {
                "unit": {
                  "enum": [
                    "L",
                    "kg"
                  ],
                  "type": "string"
                },
                "basis": {
                  "enum": [
                    "net",
                    "gross"
                  ],
                  "type": "string"
                },
                "value": {
                  "type": "number",
                  "maximum": 1000000000,
                  "minimum": 0
                }
              },
              "additionalProperties": false
            },
            "stackable": {
              "type": "boolean"
            },
            "un_number": {
              "type": "string",
              "pattern": "^(?:(?:UN\\s?)?\\d{4}|ID\\s?\\d{4})$"
            },
            "description": {
              "type": "string",
              "maxLength": 200
            },
            "packing_group": {
              "enum": [
                "I",
                "II",
                "III"
              ],
              "type": "string"
            },
            "variant_index": {
              "type": "integer",
              "maximum": 1000,
              "minimum": 0
            },
            "inner_packaging": {
              "type": "object",
              "required": [
                "quantity",
                "unit"
              ],
              "properties": {
                "unit": {
                  "enum": [
                    "ml",
                    "L",
                    "g",
                    "kg"
                  ],
                  "type": "string"
                },
                "regime": {
                  "enum": [
                    "lq",
                    "eq"
                  ],
                  "type": "string"
                },
                "quantity": {
                  "type": "number",
                  "maximum": 1000000,
                  "exclusiveMinimum": 0
                },
                "per_outer": {
                  "type": "integer",
                  "maximum": 100000,
                  "minimum": 1
                }
              },
              "additionalProperties": false
            },
            "icao_limited_quantity": {
              "type": "boolean"
            }
          },
          "additionalProperties": false
        },
        "maxItems": 50,
        "minItems": 1,
        "description": "The lines of the load (1–50). Required."
      },
      "edition": {
        "enum": [
          "2025",
          "2027"
        ],
        "type": "string",
        "description": "ADR edition: \"2025\" or \"2027\". Wins over as_of. Omit it and as_of picks the edition by the legal timeline: before 2027-01-01 ADR 2025; from 2027-01-01 ADR 2027 (ADR 2025 may still be applied until 2027-06-30 under 1.6.1.1 — edition \"2025\" answers on it until then); from 2027-07-01 ADR 2027 only. An ADR 2027 answer for a date before 2027-01-01 carries an EDITION_NOT_YET_APPLICABLE warning."
      },
      "journey": {
        "type": "object",
        "properties": {
          "date": {
            "type": "string",
            "pattern": "^\\d{4}-\\d{2}-\\d{2}$"
          },
          "mode": {
            "enum": [
              "road",
              "air",
              "sea",
              "multimodal"
            ],
            "type": "string"
          },
          "origin": {
            "type": "string",
            "pattern": "^[A-Za-z]{2}(?:\\s?[A-Za-z2-9]{3})?$"
          },
          "destination": {
            "type": "string",
            "pattern": "^[A-Za-z]{2}(?:\\s?[A-Za-z2-9]{3})?$"
          },
          "tunnels_on_route": {
            "type": "array",
            "items": {
              "enum": [
                "A",
                "B",
                "C",
                "D",
                "E"
              ],
              "type": "string"
            },
            "maxItems": 20
          }
        },
        "additionalProperties": false
      },
      "options": {
        "type": "object",
        "properties": {
          "incoterm": {
            "enum": [
              "EXW",
              "FCA",
              "FAS",
              "FOB",
              "CFR",
              "CIF",
              "CPT",
              "CIP",
              "DAP",
              "DPU",
              "DDP"
            ],
            "type": "string"
          },
          "awb_number": {
            "type": "string",
            "maxLength": 20
          },
          "freight_cost": {
            "type": "object",
            "required": [
              "amount",
              "currency"
            ],
            "properties": {
              "amount": {
                "type": "number",
                "maximum": 1000000000000,
                "minimum": 0
              },
              "currency": {
                "type": "string",
                "pattern": "^[A-Z]{3}$"
              }
            },
            "additionalProperties": false
          },
          "insurance_cost": {
            "type": "object",
            "required": [
              "amount",
              "currency"
            ],
            "properties": {
              "amount": {
                "type": "number",
                "maximum": 1000000000000,
                "minimum": 0
              },
              "currency": {
                "type": "string",
                "pattern": "^[A-Z]{3}$"
              }
            },
            "additionalProperties": false
          },
          "container_number": {
            "type": "string",
            "maxLength": 20
          },
          "air_volumetric_divisor": {
            "type": "number",
            "maximum": 10000,
            "exclusiveMinimum": 0
          }
        },
        "description": "The consignment object's options; not read by this check.",
        "additionalProperties": false
      },
      "vehicle": {
        "type": "object",
        "properties": {
          "type": {
            "type": "string",
            "maxLength": 60
          },
          "axles": {
            "type": "integer",
            "maximum": 12,
            "minimum": 1
          },
          "max_mass_t": {
            "type": "number",
            "maximum": 100,
            "exclusiveMinimum": 0
          },
          "equipment_8_1_5": {
            "type": "array",
            "items": {
              "enum": [
                "wheel_chock",
                "warning_signs",
                "eye_rinsing_liquid",
                "warning_vest",
                "portable_lighting",
                "protective_gloves",
                "eye_protection",
                "emergency_escape_mask",
                "shovel",
                "drain_seal",
                "collecting_container"
              ],
              "type": "string"
            },
            "maxItems": 11
          },
          "foodstuffs_carried": {
            "type": "boolean"
          },
          "placards_displayed": {
            "type": "boolean"
          },
          "fire_extinguishers_kg": {
            "type": "array",
            "items": {
              "type": "number",
              "maximum": 100,
              "exclusiveMinimum": 0
            },
            "maxItems": 20
          },
          "instructions_in_writing": {
            "type": "boolean"
          },
          "orange_plates_displayed": {
            "type": "boolean"
          }
        },
        "description": "Read: max_mass_t (8.1.4.1, 3.4.13), foodstuffs_carried (7.5.4) and the vehicle-side inputs (5.3, 8.1).",
        "additionalProperties": false
      }
    },
    "additionalProperties": false
  }

  arguments 418 lines copy

Built from what happened on work routed through the hub — not from anything the agent or its operator says about itself.

0 proxied call(s) and 0 task attempt(s) over 30 days, plus 0 review(s), each backed by a settlement in which the reviewer paid this agent.