How to Integrate Replit with FedEx API

1import os
2import time
3import requests
4from typing import Optional
5
6CLIENT_ID = os.environ["FEDEX_CLIENT_ID"]
7CLIENT_SECRET = os.environ["FEDEX_CLIENT_SECRET"]
8ACCOUNT_NUMBER = os.environ.get("FEDEX_ACCOUNT_NUMBER", "")
9ENV = os.environ.get("FEDEX_ENV", "sandbox")
10
11BASE_URL = (
12    "https://apis-sandbox.fedex.com" if ENV == "sandbox"
13    else "https://apis.fedex.com"
14)
15
16# Token cache: stores {'token': str, 'expires_at': float}
17_token_cache = {}
18
19def get_access_token() -> str:
20    """Get a valid FedEx OAuth access token, refreshing if expired."""
21    now = time.time()
22    if _token_cache.get('token') and _token_cache.get('expires_at', 0) > now + 60:
23        return _token_cache['token']
24
25    response = requests.post(
26        f"{BASE_URL}/oauth/token",
27        data={
28            "grant_type": "client_credentials",
29            "client_id": CLIENT_ID,
30            "client_secret": CLIENT_SECRET
31        },
32        headers={"Content-Type": "application/x-www-form-urlencoded"}
33    )
34    response.raise_for_status()
35    data = response.json()
36    _token_cache['token'] = data['access_token']
37    _token_cache['expires_at'] = now + data.get('expires_in', 3600)
38    return _token_cache['token']
39
40def get_rates(shipper_zip: str, recipient_zip: str, weight_lb: float,
41              length: int = 12, width: int = 10, height: int = 8) -> list:
42    """Get FedEx shipping rates between two US zip codes."""
43    token = get_access_token()
44    payload = {
45        "accountNumber": {"value": ACCOUNT_NUMBER or "510087240"},  # Test account for sandbox
46        "requestedShipment": {
47            "shipper": {"address": {"postalCode": shipper_zip, "countryCode": "US"}},
48            "recipient": {"address": {"postalCode": recipient_zip, "countryCode": "US"}},
49            "pickupType": "DROPOFF_AT_FEDEX_LOCATION",
50            "rateRequestType": ["LIST", "ACCOUNT"],
51            "requestedPackageLineItems": [{
52                "weight": {"units": "LB", "value": weight_lb},
53                "dimensions": {"length": length, "width": width, "height": height, "units": "IN"}
54            }]
55        }
56    }
57    response = requests.post(
58        f"{BASE_URL}/rate/v1/rates/quotes",
59        json=payload,
60        headers={"Authorization": f"Bearer {token}", "Content-Type": "application/json", "X-locale": "en_US"}
61    )
62    response.raise_for_status()
63    data = response.json()
64    rates = []
65    for rate_reply in data.get('output', {}).get('rateReplyDetails', []):
66        for rated_shipment in rate_reply.get('ratedShipmentDetails', []):
67            total = rated_shipment.get('totalNetCharge')
68            if total:
69                rates.append({
70                    'service': rate_reply.get('serviceType'),
71                    'transit_days': rate_reply.get('commit', {}).get('dateDetail', {}).get('dayOfWeek'),
72                    'total_charge': total,
73                    'currency': rated_shipment.get('currency', 'USD')
74                })
75    return rates
76
77def track_package(tracking_number: str) -> Optional[dict]:
78    """Track a FedEx package by tracking number."""
79    token = get_access_token()
80    payload = {
81        "includeDetailedScans": True,
82        "trackingInfo": [{"trackingNumberInfo": {"trackingNumber": tracking_number}}]
83    }
84    response = requests.post(
85        f"{BASE_URL}/track/v1/trackingnumbers",
86        json=payload,
87        headers={"Authorization": f"Bearer {token}", "Content-Type": "application/json", "X-locale": "en_US"}
88    )
89    response.raise_for_status()
90    output = response.json().get('output', {})
91    complete_track = output.get('completeTrackResults', [])
92    if not complete_track:
93        return None
94    track_results = complete_track[0].get('trackResults', [])
95    if not track_results:
96        return None
97    result = track_results[0]
98    return {
99        'tracking_number': tracking_number,
100        'status': result.get('latestStatusDetail', {}).get('code'),
101        'description': result.get('latestStatusDetail', {}).get('description'),
102        'estimated_delivery': result.get('estimatedDeliveryTimeWindow', {}).get('window', {}).get('ends'),
103        'actual_delivery': result.get('actualDeliveryTime'),
104        'events': result.get('scanEvents', [])
105    }
106
107if __name__ == "__main__":
108    print("Getting FedEx rates from 10001 to 90210 for 5lb package...")
109    rates = get_rates("10001", "90210", 5.0)
110    for r in rates:
111        print(f"  {r['service']}: ${r['total_charge']} ({r['currency']})")

1const express = require('express');
2const axios = require('axios');
3
4const app = express();
5app.use(express.json());
6
7const CLIENT_ID = process.env.FEDEX_CLIENT_ID;
8const CLIENT_SECRET = process.env.FEDEX_CLIENT_SECRET;
9const ACCOUNT_NUMBER = process.env.FEDEX_ACCOUNT_NUMBER || '510087240';
10const ENV = process.env.FEDEX_ENV || 'sandbox';
11const BASE_URL = ENV === 'production' ? 'https://apis.fedex.com' : 'https://apis-sandbox.fedex.com';
12
13// Token cache
14let tokenCache = { token: null, expiresAt: 0 };
15
16async function getAccessToken() {
17  if (tokenCache.token && tokenCache.expiresAt > Date.now() + 60000) {
18    return tokenCache.token;
19  }
20  const params = new URLSearchParams();
21  params.append('grant_type', 'client_credentials');
22  params.append('client_id', CLIENT_ID);
23  params.append('client_secret', CLIENT_SECRET);
24
25  const response = await axios.post(`${BASE_URL}/oauth/token`, params, {
26    headers: { 'Content-Type': 'application/x-www-form-urlencoded' }
27  });
28  tokenCache.token = response.data.access_token;
29  tokenCache.expiresAt = Date.now() + (response.data.expires_in || 3600) * 1000;
30  return tokenCache.token;
31}
32
33// POST /rates — get shipping rates
34app.post('/rates', async (req, res) => {
35  const { shipperZip, recipientZip, weightLb, length = 12, width = 10, height = 8 } = req.body;
36  if (!shipperZip || !recipientZip || !weightLb) {
37    return res.status(400).json({ error: 'shipperZip, recipientZip, and weightLb are required' });
38  }
39  try {
40    const token = await getAccessToken();
41    const payload = {
42      accountNumber: { value: ACCOUNT_NUMBER },
43      requestedShipment: {
44        shipper: { address: { postalCode: shipperZip, countryCode: 'US' } },
45        recipient: { address: { postalCode: recipientZip, countryCode: 'US' } },
46        pickupType: 'DROPOFF_AT_FEDEX_LOCATION',
47        rateRequestType: ['LIST'],
48        requestedPackageLineItems: [{
49          weight: { units: 'LB', value: weightLb },
50          dimensions: { length, width, height, units: 'IN' }
51        }]
52      }
53    };
54    const response = await axios.post(`${BASE_URL}/rate/v1/rates/quotes`, payload, {
55      headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json', 'X-locale': 'en_US' }
56    });
57    const rateDetails = response.data?.output?.rateReplyDetails || [];
58    const rates = rateDetails.map(r => ({
59      service: r.serviceType,
60      charge: r.ratedShipmentDetails?.[0]?.totalNetCharge
61    }));
62    res.json(rates);
63  } catch (err) {
64    console.error('FedEx rates error:', err.response?.data);
65    res.status(500).json({ error: err.message });
66  }
67});
68
69// GET /track/:number — track a package
70app.get('/track/:number', async (req, res) => {
71  try {
72    const token = await getAccessToken();
73    const payload = {
74      includeDetailedScans: true,
75      trackingInfo: [{ trackingNumberInfo: { trackingNumber: req.params.number } }]
76    };
77    const response = await axios.post(`${BASE_URL}/track/v1/trackingnumbers`, payload, {
78      headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json', 'X-locale': 'en_US' }
79    });
80    const result = response.data?.output?.completeTrackResults?.[0]?.trackResults?.[0];
81    if (!result) return res.status(404).json({ error: 'Tracking number not found' });
82    res.json({
83      status: result.latestStatusDetail?.code,
84      description: result.latestStatusDetail?.description,
85      estimatedDelivery: result.estimatedDeliveryTimeWindow?.window?.ends,
86      events: result.scanEvents?.slice(0, 10)
87    });
88  } catch (err) {
89    res.status(500).json({ error: err.message });
90  }
91});
92
93app.listen(3000, '0.0.0.0', () => {
94  console.log(`FedEx proxy running on port 3000 (${ENV})`)
95});