Introducción

curl -X POST https://api.fulter.net/oauth/token \
  -H "Content-Type: application/json" \
  -d '{"grant_type":"client_credentials","client_id":"mi-client-id","client_secret":"mi-secret"}'

const res = await fetch('https://api.fulter.net/oauth/token', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({ grant_type: 'client_credentials', client_id: 'mi-client-id', client_secret: 'mi-secret' }),
});
const { access_token } = await res.json();

data = requests.post('https://api.fulter.net/oauth/token',
    json={'grant_type':'client_credentials','client_id':'mi-client-id','client_secret':'mi-secret'}).json()
access_token = data['access_token']

const { data } = await axios.post('https://api.fulter.net/oauth/token', {
  grant_type: 'client_credentials', client_id: 'mi-client-id', client_secret: 'mi-secret',
});
const accessToken: string = data.access_token;

var req = HttpRequest.newBuilder()
    .uri(URI.create("https://api.fulter.net/oauth/token"))
    .header("Content-Type", "application/json")
    .POST(HttpRequest.BodyPublishers.ofString(
        "{\"grant_type\":\"client_credentials\",\"client_id\":\"mi-client-id\",\"client_secret\":\"mi-secret\"}"))
    .build();
var response = client.send(req, HttpResponse.BodyHandlers.ofString());

var res = await http.PostAsJsonAsync("https://api.fulter.net/oauth/token", new {
    grant_type = "client_credentials", client_id = "mi-client-id", client_secret = "mi-secret" });
var json = await res.Content.ReadFromJsonAsync<JsonElement>();
var accessToken = json.GetProperty("access_token").GetString();

curl "https://api.fulter.net/shipments?status=inProgress&page=1&pageSize=20" \
  -H "Authorization: Bearer $TOKEN"

const params = new URLSearchParams({ status: 'inProgress', page: '1', pageSize: '20' });
const { data, pagination } = await fetch(`https://api.fulter.net/shipments?${params}`, {
  headers: { Authorization: `Bearer ${accessToken}` },
}).then(r => r.json());

result = requests.get('https://api.fulter.net/shipments',
    params={'status':'inProgress','page':1,'pageSize':20},
    headers={'Authorization':f'Bearer {access_token}'}).json()

const { data: result } = await axios.get('https://api.fulter.net/shipments', {
  params: { status: 'inProgress', page: 1, pageSize: 20 },
  headers: { Authorization: `Bearer ${accessToken}` },
});

curl "https://api.fulter.net/shipments/id/a1b2c3d4-e5f6-7890-abcd-ef1234567890" \
  -H "Authorization: Bearer $TOKEN"

const shipment = await fetch(`https://api.fulter.net/shipments/id/${id}`,
  { headers: { Authorization: `Bearer ${accessToken}` } }).then(r => r.json());

shipment = requests.get(f'https://api.fulter.net/shipments/id/{id}',
    headers={'Authorization':f'Bearer {access_token}'}).json()

const { data: shipment } = await axios.get(`https://api.fulter.net/shipments/id/${id}`,
  { headers: { Authorization: `Bearer ${accessToken}` } });

curl "https://api.fulter.net/shipments/awb/020-98765432" \
  -H "Authorization: Bearer $TOKEN"

const shipment = await fetch(`https://api.fulter.net/shipments/awb/${awb}`,
  { headers: { Authorization: `Bearer ${accessToken}` } }).then(r => r.json());

shipment = requests.get(f'https://api.fulter.net/shipments/awb/{awb}',
    headers={'Authorization':f'Bearer {access_token}'}).json()

curl "https://api.fulter.net/shipments/bl/MSCUXX1234567" \
  -H "Authorization: Bearer $TOKEN"

const shipment = await fetch(`https://api.fulter.net/shipments/bl/${bl}`,
  { headers: { Authorization: `Bearer ${accessToken}` } }).then(r => r.json());

shipment = requests.get(f'https://api.fulter.net/shipments/bl/{bl}',
    headers={'Authorization':f'Bearer {access_token}'}).json()

curl "https://api.fulter.net/shipments/referenceNumber/REF-2026-001" \
  -H "Authorization: Bearer $TOKEN"

const shipments = await fetch(`https://api.fulter.net/shipments/referenceNumber/${ref}`,
  { headers: { Authorization: `Bearer ${accessToken}` } }).then(r => r.json());
// Devuelve un array — puede tener más de un elemento

shipments = requests.get(
    f'https://api.fulter.net/shipments/referenceNumber/{ref}',
    headers={'Authorization':f'Bearer {access_token}'}).json()
# Devuelve una lista

curl "https://api.fulter.net/shipments/containers/MSCU1234567" \
  -H "Authorization: Bearer $TOKEN"

const shipment = await fetch(`https://api.fulter.net/shipments/containers/${containerNumber}`,
  { headers: { Authorization: `Bearer ${accessToken}` } }).then(r => r.json());

shipment = requests.get(
    f'https://api.fulter.net/shipments/containers/{container_number}',
    headers={'Authorization':f'Bearer {access_token}'}).json()

curl "https://api.fulter.net/shipments/a1b2c3d4-e5f6-7890-abcd-ef1234567890/events" \
  -H "Authorization: Bearer $TOKEN"

const events = await fetch(`https://api.fulter.net/shipments/${id}/events`,
  { headers: { Authorization: `Bearer ${accessToken}` } }).then(r => r.json());

events = requests.get(f'https://api.fulter.net/shipments/{id}/events',
    headers={'Authorization':f'Bearer {access_token}'}).json()

curl -X POST https://api.fulter.net/shipments \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "awb": "020-98765432",
    "enterpriseCode": 999,
    "origin": "MIA", "destiny": "EZE",
    "land": "aerial", "operationType": "importAerial",
    "shipper": "ACME Corp",
    "ETD": "2026-09-01", "ETA": "2026-09-02"
  }'

const shipment = await fetch('https://api.fulter.net/shipments', {
  method: 'POST',
  headers: { Authorization: `Bearer ${accessToken}`, 'Content-Type': 'application/json' },
  body: JSON.stringify({
    awb: '020-98765432', enterpriseCode: 999,
    origin: 'MIA', destiny: 'EZE',
    land: 'aerial', operationType: 'importAerial',
    shipper: 'ACME Corp', ETD: '2026-09-01', ETA: '2026-09-02',
  }),
}).then(r => r.json());

shipment = requests.post('https://api.fulter.net/shipments',
    json={'awb':'020-98765432','enterpriseCode':999,'origin':'MIA','destiny':'EZE',
          'land':'aerial','operationType':'importAerial','shipper':'ACME Corp',
          'ETD':'2026-09-01','ETA':'2026-09-02'},
    headers={'Authorization':f'Bearer {access_token}'}).json()

const { data: shipment } = await axios.post('https://api.fulter.net/shipments', {
  awb: '020-98765432', enterpriseCode: 999,
  origin: 'MIA', destiny: 'EZE',
  land: 'aerial', operationType: 'importAerial',
  shipper: 'ACME Corp', ETD: '2026-09-01', ETA: '2026-09-02',
}, { headers: { Authorization: `Bearer ${accessToken}` } });

var body = """{"awb":"020-98765432","enterpriseCode":999,"origin":"MIA","destiny":"EZE",
 "land":"aerial","operationType":"importAerial","shipper":"ACME Corp",
 "ETD":"2026-09-01","ETA":"2026-09-02"}""";
var req = HttpRequest.newBuilder()
    .uri(URI.create("https://api.fulter.net/shipments"))
    .header("Authorization","Bearer "+accessToken).header("Content-Type","application/json")
    .POST(HttpRequest.BodyPublishers.ofString(body)).build();

var res = await http.PostAsJsonAsync("https://api.fulter.net/shipments", new {
    awb = "020-98765432", enterpriseCode = 999,
    origin = "MIA", destiny = "EZE",
    land = "aerial", operationType = "importAerial",
    shipper = "ACME Corp", ETD = "2026-09-01", ETA = "2026-09-02" });

curl -X PATCH \
  https://api.fulter.net/shipments/id/c3d4e5f6-a7b8-9012-cdef-012345678901 \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"ETA": "2026-11-10"}'

const updated = await fetch(`https://api.fulter.net/shipments/id/${id}`, {
  method: 'PATCH',
  headers: { Authorization: `Bearer ${accessToken}`, 'Content-Type': 'application/json' },
  body: JSON.stringify({ ETA: '2026-11-10' }),
}).then(r => r.json());

updated = requests.patch(f'https://api.fulter.net/shipments/id/{id}',
    json={'ETA':'2026-11-10'},
    headers={'Authorization':f'Bearer {access_token}'}).json()

const { data: updated } = await axios.patch(
  `https://api.fulter.net/shipments/id/${id}`,
  { ETA: '2026-11-10' },
  { headers: { Authorization: `Bearer ${accessToken}` } }
);

curl https://api.fulter.net/webhook-subscriptions \
  -H "Authorization: Bearer $TOKEN"

const subs = await fetch('https://api.fulter.net/webhook-subscriptions', {
  headers: { Authorization: `Bearer ${accessToken}` },
}).then(r => r.json());

curl -X POST https://api.fulter.net/webhook-subscriptions \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://mi-sistema.com/webhooks/dh",
    "events": ["shipment.created", "shipment.updated"],
    "secret": "mi-secret-hmac-muy-seguro"
  }'

const sub = await fetch('https://api.fulter.net/webhook-subscriptions', {
  method: 'POST',
  headers: { Authorization: `Bearer ${accessToken}`, 'Content-Type': 'application/json' },
  body: JSON.stringify({
    url: 'https://mi-sistema.com/webhooks/dh',
    events: ['shipment.created', 'shipment.updated'],
    secret: 'mi-secret-hmac-muy-seguro',
  }),
}).then(r => r.json());

sub = requests.post('https://api.fulter.net/webhook-subscriptions',
    json={'url':'https://mi-sistema.com/webhooks/dh',
          'events':['shipment.created','shipment.updated'],'secret':'mi-secret-hmac-muy-seguro'},
    headers={'Authorization':f'Bearer {access_token}'}).json()

const { data: sub } = await axios.post('https://api.fulter.net/webhook-subscriptions', {
  url: 'https://mi-sistema.com/webhooks/dh',
  events: ['shipment.created', 'shipment.updated'],
  secret: 'mi-secret-hmac-muy-seguro',
}, { headers: { Authorization: `Bearer ${accessToken}` } });

curl -X DELETE \
  https://api.fulter.net/webhook-subscriptions/b9c8d7e6-f5a4-3210-fedc-ba9876543210 \
  -H "Authorization: Bearer $TOKEN"

await fetch(`https://api.fulter.net/webhook-subscriptions/${subId}`, {
  method: 'DELETE', headers: { Authorization: `Bearer ${accessToken}` }
}); // 204 No Content

import { createHmac, timingSafeEqual } from 'crypto';

function verifySignature(rawBody: string, signature: string, secret: string): boolean {
  const expected = createHmac('sha256', secret).update(rawBody).digest('hex');
  return timingSafeEqual(Buffer.from(expected), Buffer.from(signature));
}

// Express — leer el body raw antes de parsear JSON:
app.post('/webhooks/dh', express.raw({ type: 'application/json' }), (req, res) => {
  const sig = req.headers['x-dh-signature'] as string;
  if (!verifySignature(req.body.toString(), sig, process.env.WEBHOOK_SECRET!))
    return res.status(401).send('Invalid signature');
  const event = JSON.parse(req.body.toString());
  res.sendStatus(200);
});

import hmac, hashlib

def verify_signature(raw_body: bytes, signature: str, secret: str) -> bool:
    expected = hmac.new(secret.encode(), raw_body, hashlib.sha256).hexdigest()
    return hmac.compare_digest(expected, signature)

# Flask:
@app.route('/webhooks/dh', methods=['POST'])
def webhook():
    sig = request.headers.get('X-DH-Signature', '')
    if not verify_signature(request.get_data(), sig, WEBHOOK_SECRET):
        abort(401)
    event = request.get_json()
    return '', 200

using System.Security.Cryptography;

bool VerifySignature(string rawBody, string signature, string secret) {
    var key = Encoding.UTF8.GetBytes(secret);
    var expected = Convert.ToHexString(HMACSHA256.HashData(key, Encoding.UTF8.GetBytes(rawBody))).ToLower();
    return CryptographicOperations.FixedTimeEquals(Encoding.UTF8.GetBytes(expected), Encoding.UTF8.GetBytes(signature));
}

import javax.crypto.Mac; import javax.crypto.spec.SecretKeySpec;

boolean verifySignature(String rawBody, String sig, String secret) throws Exception {
    Mac mac = Mac.getInstance("HmacSHA256");
    mac.init(new SecretKeySpec(secret.getBytes(), "HmacSHA256"));
    String expected = HexFormat.of().formatHex(mac.doFinal(rawBody.getBytes()));
    return MessageDigest.isEqual(expected.getBytes(), sig.getBytes());
}