GLEC v3.1 Framework Compliant

Freight Shipping
Carbon Emissions API

Calculate CO₂e for any shipment across road, rail, sea, and air. Integrate into your TMS, ERP, or e-commerce platform today. No sales calls required.

Get Free API Key Try Interactive Demo

View transparent pricing · 500 free requests/month

GHG Protocol IPCC AR6 GWP100 GLEC Framework

Calculate shipping emissions · Rotterdam → Chicago

// Request

GET /v1/freight/emissions

origin_country=NL

origin_location=Rotterdam

destination_country=US

destination_location=Chicago

weight=2500

transport_mode=sea

// Response (data.attributes)

{
"emissions": {
"co2e": 847.3,
"co2e_unit": "kg",
"ghg_protocol_scopes": { ... }
},
"route": {
"total_distance_km": 8142,
"transport_mode": "sea",
"transit_countries": ["NL", "GB", "US"]
},
"source_trail": [{ "source": "GLEC", ... }]
}

// Full audit trail included in every response

200 OK 89ms · Audit-ready response

All transport modes. One API.

Calculate emissions for road, rail, sea, and air freight with mode-specific emission factors.

Road Freight

Small vans to articulated lorries with fuel-specific factors for diesel, electric, HVO, hydrogen, and 9 more fuel types. Real road routing with optional polyline for map rendering.

Rail Freight

Intermodal container and bulk rail with regional grid carbon intensity for electric traction.

Sea Freight

Container ships, bulk carriers and average vessel types with real shipping lane distances via Suez, Panama, and Cape routes.

Air Freight

Belly cargo and dedicated freighters with distance-based haul factors and great circle routing.

Real-world use cases

See how logistics platforms, e-commerce stores, and TMS providers integrate freight carbon emissions.

E-commerce Checkout

Show customers the carbon footprint of their delivery at checkout. Compare shipping options by emissions, not just price and speed.

Display CO₂e per delivery option
Offer carbon-neutral shipping upgrades
Compare road vs rail for the same route
Differentiate with sustainability data

Eco-conscious shoppers convert 17% higher when shown carbon data.

javascript Shopify / WooCommerce integration

// Compare delivery emissions at checkout
const modes = ["road", "rail"];
const base = "https://api.emissions.dev/v1/freight/emissions?"
  + `origin_country=US&origin_location=Chicago`
  + `&destination_country=US&destination_location=Denver`
  + `&weight=${cart.totalWeightKg}`;

const results = await Promise.all(
  modes.map(mode =>
    fetch(`${base}&transport_mode=${mode}`, {
      headers: { Authorization: `Bearer ${apiKey}` }
    }).then(r => r.json())
  )
);

// Extract from standard response envelope
const [road, rail] = results.map(r => ({
  co2e: r.data.attributes.emissions.co2e,
  km:   r.data.attributes.route.total_distance_km,
}));

// Display to customer
// 🚚 Standard (road): 2.4 kg CO₂e — 1,610 km — $4.99
// 🚂 Eco (rail):      0.8 kg CO₂e — 1,800 km — $5.99 ← 67% less carbon

TMS / Fleet Management

Embed emissions tracking into transport management systems. Calculate CO₂e for every shipment automatically with refrigerated cargo and empty return support.

Batch calculate historical shipments
Real-time emissions for new bookings
Refrigerated cargo surcharge (+20%)
Export data for Scope 3 reporting

python Batch processing with cold chain support

# Calculate emissions for all Q4 shipments
import requests

def calculate_shipment_emissions(shipment):
    params = {
        "origin_country": shipment['origin_country'],
        "origin_location": shipment['origin_city'],
        "destination_country": shipment['dest_country'],
        "destination_location": shipment['dest_city'],
        "weight": shipment['weight_kg'],
        "transport_mode": shipment['mode'],
        "vehicle_type": shipment.get('vehicle', 'average'),
        "fuel_source": shipment.get('fuel', 'diesel'),
    }
    # Cold chain? Adds ~20% to emissions automatically
    if shipment.get('refrigerated'):
        params["refrigerated"] = "true"
    # Dedicated vehicle? Include empty return leg
    if shipment.get('dedicated'):
        params["include_empty_return"] = "true"

    resp = requests.get(
        "https://api.emissions.dev/v1/freight/emissions",
        headers={"Authorization": f"Bearer {API_KEY}"},
        params=params,
    )
    return resp.json()['data']['attributes']['emissions']

# Process shipments (use /v1/freight/batch for 100+ at once)
totals = [calculate_shipment_emissions(s) for s in shipments]
scope_3 = sum(t['ghg_protocol_scopes']['freight_buyer']['scope_3_category_4'] for t in totals)

Route Visualization

Render actual road routes on a map alongside emissions data. Show customers and stakeholders exactly where their shipment travels — with transit countries and estimated duration.

Encoded polyline for smooth map rendering
Compatible with Leaflet, Google Maps, Mapbox
Transit countries for customs awareness
Route duration and distance included

Add detailed_route=true — zero extra API calls, same request.

javascript Leaflet map with real road geometry

// Fetch route with full polyline for map rendering
const resp = await fetch(
  "https://api.emissions.dev/v1/freight/emissions?" +
  "origin_country=GB&origin_location=London" +
  "&destination_country=DE&destination_location=Berlin" +
  "&weight=5000&detailed_route=true",
  { headers: { Authorization: `Bearer ${apiKey}` }}
);
const { data } = await resp.json();
const route = data.attributes.route;

// route.polyline → Google-encoded polyline (precision 5)
// route.duration_formatted → "11h 56m"
// route.total_distance_km → 1098

// Decode and render on Leaflet
const decoded = L.Polyline.fromEncoded(route.polyline);
decoded.addTo(map).setStyle({
  color: '#10b981', weight: 3, opacity: 0.8
});
map.fitBounds(decoded.getBounds(), { padding: [30, 30] });

// Show transit countries: GB → FR → BE → NL → DE
const countries = data.attributes.geography.transit_countries;

// Also works with: google.maps.geometry.encoding.decodePath()
//                  polyline.decode() in Python
//                  Mapbox, OpenLayers, etc.

Multimodal Comparison

Compare emissions across different transport modes and routes. Help shippers choose the lowest-carbon option.

Road vs rail vs sea comparison
Intermodal route optimization
Pre/post-leg drayage included

97%

less carbon via sea vs air

bash Compare modes: Shanghai → Hamburg

# Sea freight (lowest emissions)
$ curl "https://api.emissions.dev/v1/freight/emissions?\
origin_country=CN&origin_location=Shanghai&\
destination_country=DE&destination_location=Hamburg&\
weight=20000&transport_mode=sea" \
  -H "Authorization: Bearer em_live_xxx"

{ "co2e": 4280, "co2e_unit": "kg", "distance_km": 19847 }

# Air freight (fastest, highest emissions)
$ curl "https://api.emissions.dev/v1/freight/emissions?\
origin_country=CN&origin_location=Shanghai&\
destination_country=DE&destination_location=Hamburg&\
weight=20000&transport_mode=air" \
  -H "Authorization: Bearer em_live_xxx"

{ "co2e": 158400, "co2e_unit": "kg", "distance_km": 8861 }

# Sea freight produces 97% less CO₂e than air

Digital Product Passport

Calculate per-product transport carbon footprint for EU Digital Product Passport and Product Carbon Footprint (PCF) compliance. Map emissions to EN 15804 lifecycle stages.

Per-product allocation by mass
EN 15804 lifecycle stages (A2, A4, C2)
ISO 14067 compatible output
Combine multiple transport legs per product

EU DPP regulation requires transport emissions per product from 2027.

python Per-product PCF for EU Digital Product Passport

# Calculate transport footprint per unit for DPP compliance
# Shipment: 500 units × 2.5 kg each, factory → warehouse
resp = requests.get(
    "https://api.emissions.dev/v1/freight/emissions",
    headers={"Authorization": f"Bearer {API_KEY}"},
    params={
        "origin_country": "CN",
        "origin_location": "Shenzhen",
        "destination_country": "DE",
        "destination_location": "Hamburg",
        "weight": 1250,          # 500 × 2.5 kg
        "transport_mode": "sea",
        # DPP allocation parameters
        "lifecycle_stage": "A2",    # Transport to manufacturer
        "product_weight_kg": 2.5,  # Weight per unit
        "product_quantity": 500,   # Units in shipment
    }
)

allocation = resp.json()['data']['attributes']['allocation']
# {
#   "co2e_per_product_kg": 0.0427,
#   "product_quantity": 500,
#   "allocation_method": "mass",
#   "lifecycle_stage": "A2"
# }

# Add to product DPP record
product.transport_a2_co2e = allocation['co2e_per_product_kg']
# Repeat for A4 (to site) and C2 (end-of-life) legs

ESG & Carbon Reporting

Automate Scope 3 Category 4 reporting by calculating emissions across your entire supply chain. Every response maps directly to GHG Protocol disclosure categories.

Aggregate emissions by route, mode, or period
GHG Protocol scope mapping in every response
Source trail satisfies auditor documentation requirements
Well-to-wheel breakdown (TTW + WTT) included

php Annual Scope 3 disclosure report

// Generate Scope 3 Category 4 totals for annual disclosure
$shipments = Shipment::whereYear('shipped_at', 2025)->get();

$results = $shipments->map(function ($shipment) {
    $response = Http::withToken(config('services.emissions.key'))
        ->get('https://api.emissions.dev/v1/freight/emissions', [
            'origin_country'    => $shipment->origin_country,
            'origin_location'   => $shipment->origin_city,
            'destination_country' => $shipment->dest_country,
            'destination_location' => $shipment->dest_city,
            'weight'             => $shipment->weight_kg,
            'transport_mode'     => $shipment->mode,
        ]);

    return $response->json('data.attributes.emissions');
});

// Map to GHG Protocol scopes — ready for disclosure
$report = [
    'scope_3_category_4' => $results->sum('ghg_protocol_scopes.freight_buyer.scope_3_category_4'),
    'vehicle_operation'  => $results->sum('lifecycle_breakdown.vehicle_operation'),
    'energy_provision'   => $results->sum('lifecycle_breakdown.energy_provision'),
    'methodology'        => 'GLEC Framework v3.1',
    'gwp'                => 'IPCC AR6 GWP100',
    'shipments_counted'  => $results->count(),
    'source_trails'      => $results->pluck('source_trail'),
];

Audit-ready methodology

Transparent calculations backed by internationally recognised standards.
Every response includes a full source trail, protecting your platform from greenwashing claims.

GLEC Framework v3.1

The only globally recognised methodology for logistics emissions, developed by Smart Freight Centre.

GHG Protocol

Compatible with corporate Scope 3 reporting under the Greenhouse Gas Protocol standard.

ISO 14083

Every response includes full source trail with emission factor source, version, year, and region.

Well-to-Wheel

Full lifecycle emissions including fuel extraction, refining, and combustion (WTT + TTW).

json source_trail — included in every response

{
  "emissions": {
    "co2e": 156.78,
    "co2e_unit": "kg",
    "co2e_calculation_method": "ipcc_ar6_gwp100",
    "lifecycle_breakdown": {
      "vehicle_operation": 125.42,
      "energy_provision": 31.36
    },
    "ghg_protocol_scopes": {
      "freight_buyer": { "scope_3_category_4": 156.78 }
    },
    "source_trail": [{
      "data_category": "emission_factor",
      "name": "Articulated HGV - Diesel",
      "source": "GLEC",
      "source_dataset": "Default fuel efficiency and GHG emission intensity values v3.1",
      "year": "2025",
      "region": "GLOBAL"
    }]
  },
  "meta": {
    "methodology": "GLEC Framework v3.1",
    "standards_compliance": {
      "ISO_14083": true,
      "EN_16258": true,
      "GHG_Protocol": "Scope 3 Category 4"
    }
  }
}

Global coverage

Calculate emissions for any international freight route. We support addresses, postcodes, and city names with automatic geocoding.

Road networks

Real driving distances

Shipping lanes

Real sea routes

Great circles

Air freight routing

Rail networks

Intermodal routing

200+

Countries

Fuel sources

Vehicle classes

<100ms

Avg response

Integrate in minutes

Simple REST API. No complex setup or configuration.

Get your API key

Make your first request

Pass origin, destination, weight, and transport mode. Get CO₂e in JSON.

Ship to production

Swap your test key for a live key. Scale to millions of requests.

Get Free API Key Try Interactive Demo

Freight API FAQ

Common questions about transport carbon emissions.

At minimum, you need:

Origin — Country code (origin_country) + optional city/postcode (origin_location)
Destination — Country code (destination_country) + optional city/postcode (destination_location)
Weight — Cargo weight (weight) in kg, g, lb, or tonnes

For more accurate results, you can also specify: transport_mode, vehicle_type, fuel_source, service_type, and whether the cargo is refrigerated. For route visualization, add detailed_route=true.

We use real shipping lane distances, not straight lines. Our routing considers major shipping routes (Suez Canal, Panama Canal, Cape of Good Hope) and calculates port-to-port distances using maritime network data. This is significantly more accurate than great circle distance for sea freight.

Yes. Our calculations are designed for corporate carbon reporting:

GLEC Framework compliant (the global logistics standard)
GHG Protocol Category 4 (upstream) & 9 (downstream) compatible
All factors expressed in CO₂e using IPCC AR6 GWP100
Full source trail with emission factor names, datasets, and years in every response

Every API response includes the source_trail and standards_compliance fields so your auditors can verify the calculations.

We support six vehicle classes via the vehicle_type parameter:

small_van — Small van (under 1.5t)
van — Van (up to 3.5t)
truck — Truck (7.5–17t)
hgv — HGV Rigid (17–26t)
articulated — Articulated lorry (33–44t)
average — Fleet average (default)

Each vehicle type supports 13 fuel sources across four categories:

Fossil: diesel, petrol, lng, cng
Electric/Hybrid: electric, hybrid, plugin_hybrid
Biofuels: hvo, biodiesel, b20, biogas
Future fuels: hydrogen, e_fuel

Yes. By default, we calculate well-to-wheel (WTW) emissions which include both well-to-tank (WTT) — fuel extraction and refining — and tank-to-wheel (TTW) — fuel combustion. The response includes a lifecycle_breakdown showing vehicle_operation (TTW) and energy_provision (WTT) separately, plus ghg_protocol_scopes mapping these to Scope 1 and Scope 3 Category 3.

Yes. Add detailed_route=true to any road freight request and the response includes:

An encoded polyline (Google format, precision 5) for smooth map rendering
Sampled waypoints for lightweight rendering
Duration (duration_seconds and duration_formatted)
Transit countries the route passes through

The polyline works with Leaflet, Google Maps, Mapbox, OpenLayers, and any library that supports Google's polyline encoding. This adds zero extra API calls — it's the same request with richer route geometry.

Rate limits depend on your plan:

Plan	Requests/month	Rate limit
Free	500	2 req/sec
Launch ($39/mo)	5,000	5 req/sec (burst 10)
Starter ($79/mo)	10,000	10 req/sec (burst 25)
Growth ($199/mo)	50,000	15 req/sec (burst 40)
Scale ($499/mo)	200,000	25 req/sec (burst 75)

All responses include X-RateLimit-Remaining and X-Monthly-Usage headers. Growth and Scale plans include batch processing. Need higher limits? Contact us for Enterprise pricing.

No. We do not store, log, or retain any shipment details (origins, destinations, weights, or customer information). We only store anonymised usage metrics (request counts, response times) for billing and performance monitoring. Your logistics data never leaves your infrastructure beyond the API call itself.

Yes. Growth and Scale plans include batch processing:

POST /v1/freight/batch
Content-Type: application/json

{
  "shipments": [
    {
      "origin_country": "NL",
      "origin_location": "Rotterdam",
      "destination_country": "DE",
      "destination_location": "Munich",
      "weight": 2500
    },
    {
      "origin_country": "US",
      "origin_location": "Chicago",
      "destination_country": "US",
      "destination_location": "Houston",
      "weight": 1200
    }
    // Growth: up to 100, Scale: up to 500 per request
  ]
}

Batch requests are processed in parallel and return all results in a single response. This is significantly faster than individual requests for bulk historical analysis or TMS integrations.

Start calculating freight emissions

Get your API key in 30 seconds. 500 free requests per month. No credit card required.

Get Free API Key → View Pricing

Freight Shipping Carbon Emissions API