DHL API

Go to developer.dhl.com and create a developer account if you don't have one. After registering and verifying your email, log in and navigate to 'My Apps' or the API catalog. Browse the available product APIs and enable the ones your app needs: 'DHL Shipment Tracking' for package tracking, 'DHL Express MyDHL API' for international shipping rates and label creation, or 'DHL Location Finder' for finding DHL service points and drop-off locations. For each API product you enable, DHL provides a separate set of credentials. The free developer tier (sandbox) lets you test with sample tracking numbers and simulated rate quotes without real shipping transactions. For production, you'll need a commercial DHL account to get live credentials. In your DHL developer portal app settings, copy the 'API Key' and 'API Secret' (sometimes labelled 'Consumer Key' and 'Consumer Secret' depending on the product). These are the two values that will be combined and base64-encoded to form the Basic Auth header. Never put these values in FlutterFlow — your next step is placing them in a Firebase Functions config variable. The base URL varies by product: `https://api-eu.dhl.com` is the European endpoint, `https://api.dhl.com` may apply for different regions or products. Always verify the correct base URL in the DHL API documentation for each product you're using — using the wrong base URL returns a 404 even with valid credentials.

The Cloud Function's core job is to build the `Authorization: Basic` header by combining and base64-encoding your DHL credentials, then forwarding the request to the correct DHL endpoint. This keeps the credentials entirely server-side — the FlutterFlow app sends shipment data but never sees the credentials. Set credentials as Firebase Functions config: run `firebase functions:config:set dhl.api_key="your-key" dhl.api_secret="your-secret"` in the Firebase CLI. For multiple DHL product APIs with separate credentials, use `dhl.tracking_key`, `dhl.tracking_secret`, `dhl.express_key`, `dhl.express_secret`, etc. In the Cloud Function, implement exponential backoff for 429 responses: when DHL returns a rate-limit error, wait a short delay (starting at 500ms, doubling each retry) and retry the request up to 3 times before returning the error to FlutterFlow. This prevents burst failures when multiple users trigger rate lookups simultaneously — a common scenario during checkout flows. For the rate quotes path, the function accepts parcel dimensions and addresses from FlutterFlow in the request body, formats them according to the DHL API's schema (which is more complex than most REST APIs — it uses a structured JSON body with `customerDetails`, `packages`, and `productCode`), calls the DHL Express API, and returns a simplified `rates[]` array with service name, price, and transit time. For tracking, it accepts a tracking number and returns a simplified `events[]` array.

1// Firebase Cloud Function — DHL API proxy with Basic Auth
2// functions/index.js
3const functions = require('firebase-functions');
4const https = require('https');
5
6function sleep(ms) { return new Promise(r => setTimeout(r, ms)); }
7
8async function callDHL(path, method, body, apiKey, apiSecret) {
9  const auth = Buffer.from(`${apiKey}:${apiSecret}`).toString('base64');
10  const bodyStr = body ? JSON.stringify(body) : null;
11
12  const options = {
13    hostname: 'api-eu.dhl.com',
14    path,
15    method,
16    headers: {
17      'Authorization': `Basic ${auth}`,
18      'Content-Type': 'application/json',
19      ...(bodyStr ? { 'Content-Length': Buffer.byteLength(bodyStr) } : {})
20    }
21  };
22
23  let attempt = 0;
24  while (attempt < 3) {
25    const result = await new Promise((resolve, reject) => {
26      const req = https.request(options, (res) => {
27        let data = '';
28        res.on('data', c => { data += c; });
29        res.on('end', () => resolve({ status: res.statusCode, body: JSON.parse(data) }));
30      });
31      req.on('error', reject);
32      if (bodyStr) req.write(bodyStr);
33      req.end();
34    });
35    if (result.status === 429) {
36      await sleep(500 * Math.pow(2, attempt));
37      attempt++;
38    } else {
39      return result;
40    }
41  }
42  return { status: 429, body: { error: 'Rate limit exceeded after retries' } };
43}
44
45exports.dhlProxy = functions.https.onRequest(async (req, res) => {
46  res.set('Access-Control-Allow-Origin', '*');
47  res.set('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
48  res.set('Access-Control-Allow-Headers', 'Content-Type');
49  if (req.method === 'OPTIONS') { res.status(204).send(''); return; }
50
51  const cfg = functions.config().dhl;
52  const action = req.query.action;
53
54  try {
55    if (action === 'track') {
56      const trackingNumber = req.query.trackingNumber;
57      const result = await callDHL(
58        `/track/shipments?trackingNumber=${trackingNumber}`,
59        'GET', null, cfg.api_key, cfg.api_secret
60      );
61      res.status(result.status).json(result.body);
62    } else if (action === 'rates') {
63      const result = await callDHL(
64        '/rate', 'POST', req.body, cfg.api_key, cfg.api_secret
65      );
66      res.status(result.status).json(result.body);
67    } else {
68      res.status(400).json({ error: 'Invalid action. Use track or rates.' });
69    }
70  } catch (err) {
71    res.status(500).json({ error: err.message });
72  }
73});

In FlutterFlow, click 'API Calls' in the left navigation panel. Click '+ Add' → 'Create API Group'. Name it 'DHL'. Set the Base URL to your Cloud Function's HTTPS trigger URL (e.g., `https://us-central1-your-project.cloudfunctions.net/dhlProxy`). No group-level headers needed — the function handles DHL auth. For tracking: click '+ Add API Call'. Name it 'Track Shipment'. Set Method to GET. In the Variables tab, add a variable `trackingNumber` (String type). In the URL, append `?action=track&trackingNumber={{ trackingNumber }}`. Click 'Response & Test' and paste a sample DHL tracking response. DHL's tracking endpoint returns a `shipments[]` array where each shipment has a `status` object and an `events[]` array. Generate JSON paths for `$.shipments[0].status.statusCode`, `$.shipments[0].status.description`, and `$.shipments[0].events[*].timestamp`, `$.shipments[0].events[*].location.address.addressLocality`, `$.shipments[0].events[*].description`. For rates: add a second API Call named 'Get Rates'. Set Method to POST. In the Body tab, add a JSON body with variables for `weight`, `originCountry`, `originCity`, `destinationCountry`, and `destinationCity`. These become the POST body that the function forwards to DHL's rates endpoint (formatted according to DHL's schema inside the function). Generate JSON paths for the rate options in the response — `$.products[*].productName`, `$.products[*].price[0].price`, `$.products[*].deliveryCapabilities.estimatedDeliveryDateAndTime`.

Go to Settings → Data Types → + Add Data Type. Name it 'TrackingEvent'. Add fields: `timestamp` (String), `location` (String), `description` (String), `statusCode` (String). Create a second Data Type 'ShippingRate' with fields: `productName` (String), `price` (String), `deliveryDate` (String). For the tracking screen, add a Column widget at the top for the current shipment status (large text showing the most recent status description and code). Below, add a ListView for the events timeline. In the ListView's Backend Query, set it to 'API Call' → 'Track Shipment'. In the list item template, create a Row widget with: a colored circle icon on the left (change color conditionally based on the `statusCode` — green for 'delivered', amber for 'transit', grey for older events), and on the right a Column with the event `description` as bold text, the `location` as secondary text, and the `timestamp` formatted to a readable date/time. For conditional icon color: in the circle icon's Color property, add a conditional value — if `statusCode == 'delivered'`, color is green; if `statusCode == 'transit'`, color is amber; else grey. This creates a visual distinction between milestone events. For the rates screen, add a Column with form fields for parcel weight and addresses. Below, add a ListView that executes 'Get Rates' when the user taps a 'Get Quotes' button. Map `productName`, `price`, and `deliveryDate` to Text widgets in each rate card. Add a 'Select' button on each card that stores the chosen rate in App State for use in the checkout flow.

If your app needs to create DHL shipments (not just track or quote), extend the Cloud Function with a label creation path. DHL shipment creation uses the Express API's `POST /expressRate/v1/shipments` endpoint and returns a `shipmentTrackingNumber` and a `label` object containing the base64-encoded PDF label. In the Cloud Function, accept the full shipment details from FlutterFlow, call DHL's creation endpoint, and return the tracking number and a label download URL. For label printing: DHL returns the label as a base64-encoded PDF in the response. The Cloud Function can decode this, upload it to Firebase Storage (using the Admin SDK), and return a public download URL to FlutterFlow. In FlutterFlow, display this URL in a 'Download Label' button that opens the URL in the device browser for printing — or use a WebView if you want in-app preview. For production credential swap: DHL's sandbox credentials (from the developer portal free tier) do not create real shipments or generate real labels. For production, you need a commercial DHL account and live credentials. Update your Firebase Functions config with the production credentials (`firebase functions:config:set dhl.api_key="live-key" dhl.api_secret="live-secret"`) and redeploy. No changes needed in FlutterFlow — the app always calls the Cloud Function URL, and the function uses whichever credentials are configured. If you need DHL credentials, RapidDev's team handles FlutterFlow integrations like this every week, including helping set up commercial DHL accounts — free scoping call at rapidevelopers.com/contact.