ShipEngine vs RevAddress: What the ShipStation API Rename Changes for USPS Teams

Start with the thing on ShipEngine’s own pricing page: “ShipEngine is becoming ShipStation API.” Every documentation link in their own navigation already points at docs.shipstation.com, and the pricing page title reads ShipStation API. Integrations keep working. Documentation URLs, support paths, and branding are moving, which matters if you are choosing a stack you expect to leave alone for three years.

Underneath the rename, the comparison is unchanged in shape. ShipEngine is a 200-carrier platform for logistics companies and marketplaces. RevAddress is a USPS layer for businesses whose parcels are mostly USPS. The question is not which has more features, because ShipEngine has more features. The question is what you pay to carry the ones you never call.

What ShipEngine charges, as published

Overage on Advanced steps down with the tier you sit on: $0.075 per additional label at 1,000, $0.065 at 5,000, $0.060 at 10,000.

Two details in that table are load-carrying and rarely quoted.

The Free plan cannot validate an address on its own. ShipEngine footnotes it directly: US and global address validation on Free is performed as part of the Get Rates or Create Label actions. If your use case is checkout validation with no label at the end of it, Free does not serve it, and the entry price is $75 a month.

Advanced’s allowance is per endpoint, not pooled. ShipEngine’s FAQ describes the plan as 1,000, 5,000, or 10,000 API calls per month to each of order imports, create labels, track parcels, validate addresses, rate shopping, and PUDO searches. That is genuinely generous for a mixed workload, and it is the opposite of how RevAddress meters. Six endpoints at 1,000 calls each is six thousand calls for $75, as long as your traffic distributes the way the buckets do.

RevAddress pools everything into one monthly number: 1,000 requests on Free, 5,000 on Starter at $29, 25,000 on Growth at $79, 100,000 on Pro at $199. One bucket is simpler to reason about and worse at the boundary, because a spike in one endpoint eats another endpoint’s headroom.

The unit problem

ShipEngine’s headline price is per label. RevAddress’s is per API request. USPS’s own fee, which BYOK teams pay directly, is per address lookup. Three units, and a comparison that ignores them produces a number that is not wrong so much as meaningless.

The honest version is per workload. A team shipping 5,000 USPS parcels a month, validating each address once:

• ShipEngine Advanced at the 5,000 tier: the plan, plus label volume, plus validation inside the validate-addresses bucket. Labels and validation both fit in their own allowances.
• RevAddress: Starter at $29 covers 5,000 pooled requests. Validating 5,000 addresses consumes the whole budget, so a real shipping workload wants Growth at $79 for 25,000. On top of that, USPS bills your own Enterprise Payment Account $22.50 for 5,000 address lookups. Label creation needs Pro at $199.
• Postage is paid to USPS in both cases and is not part of either fee.

If the entire job is labels, ShipEngine’s model is built for it. If the job is a lot of address work and a smaller number of labels, the pooled model gets cheaper fast, because RevAddress does not charge per validation at all.

Architecture

ShipEngine has more surface. Free-text address parsing, multi-carrier rate comparison, insurance, taxes and duties, PUDO lookup, branded tracking portals, and the broadest SDK coverage in the category. Each of those is a real capability RevAddress does not have.

RevAddress goes deeper on one carrier. Raw DPV confirmation codes and DPV footnotes, ZIP+4, carrier route, CMRA, vacancy and business flags, all returned on your own USPS license, plus Census-based standardization and geocoding that need no USPS license at all. A layer over one carrier can expose that carrier’s fields; a layer over two hundred has to normalize them.

What comes back from a validation

import shipengine

se = shipengine.ShipEngine(api_key="TEST_xxx")

result = se.validate_addresses([{
  "address_line1": "1600 Pennsylvania Ave NW",
  "city_locality": "Washington",
  "state_province": "DC",
  "postal_code": "20500",
  "country_code": "US",
}])

addr = result[0]
if addr.status == "verified":
  print(f"Valid: {addr.matched_address.address_line1}")
else:
  for msg in addr.messages:
      print(f"{msg.type}: {msg.message}")

from usps_v3 import USPSClient

client = USPSClient(api_key="rv_live_your_key_here")

result = client.addresses.validate(
  street_address="1600 Pennsylvania Ave NW",
  city="Washington",
  state="DC",
  zip_code="20500",
)

if result.dpv_confirmation == "Y":
  print(f"Valid: {result.address.street_address}")
  print(f"Carrier route: {result.carrier_route}")
  print(f"Delivery point: {result.delivery_point}")
else:
  print(f"DPV: {result.dpv_confirmation}")

ShipEngine returns a verified or unverified status plus a message list. It has to: the same call has to describe a Canadian address and a German one, and a USPS-specific code has nowhere to go in that response.

RevAddress returns the DPV confirmation code as USPS issues it. Y confirmed, N not confirmed, D confirmed to the building with a missing secondary, S confirmed with an extra secondary USPS ignored, plus the DPV footnotes. Three of those four fail a boolean check and each one is a different repair. The status-plus-messages shape carries most of that information in prose; the code carries it in a field you can group by.

Labels, on whose credentials

This is where the two models diverge most and where comparison posts tend to overclaim.

ShipEngine buys postage through its own carrier accounts on Free, or through yours on Advanced. Either way, one API call produces a label.

RevAddress creates labels on your USPS license, on the Pro plan at $199 a month, drawing on your own Enterprise Payment Account. There is no RevAddress-credential label path, deliberately: postage has to be paid by the entity that owes it, and a shared-credential label is somebody else’s postage liability.

# Carrier-routed: the carrier_id selects USPS out of 200 options
shipment = se.create_label_from_shipment_details(
  shipment={
      "carrier_id": "se-USPS",
      "service_code": "usps_ground_advantage",
      "ship_from": from_addr,
      "ship_to": to_addr,
      "packages": [{
          "weight": {"value": 32, "unit": "ounce"},
          "dimensions": {
              "length": 12, "width": 6,
              "height": 4, "unit": "inch"
          },
      }],
  },
)
label_url = shipment.label_download.pdf

# Runs on YOUR USPS license and EPA. Pro plan.
label = client.labels.create(
  from_address={
      "streetAddress": "123 Sender St",
      "city": "New York",
      "state": "NY",
      "ZIPCode": "10001",
  },
  to_address={
      "streetAddress": "456 Receiver Ave",
      "city": "Los Angeles",
      "state": "CA",
      "ZIPCode": "90001",
  },
  weight=32,
  mail_class="USPS_GROUND_ADVANTAGE",
  processing_category="MACHINABLE",
)
label_url = label.label_url

No carrier_id on the RevAddress side, because there is one carrier. That is a small ergonomic win and not a reason to choose a platform.

The reason to care about BYOK is upstream of the code. USPS tightened API access through 2026: CRID and MID enrollment, app-level approval, a signed Addresses API license, and a funded Enterprise Payment Account. When your access sits inside a reseller’s account, your continuity depends on their compliance posture. When it sits in your own CRID, it depends on yours.

The constraint BYOK adds

Being honest about the cost of the thing we recommend: USPS enforces 60 requests per hour per application on address validation by default, shared across every endpoint your app calls. That is roughly 1,440 a day. A thousand orders a day will break it during peak hours.

RevAddress budgets, caches, and retries against that window, and you can request an increase from USPS, which is a support ticket with its own response time. ShipEngine’s shared-pool model hides this problem from you entirely, which is a real advantage of a reseller and worth naming. The rate limit guide covers the patterns that survive it.

When ShipEngine is the right choice

• You ship with three or more carriers. Multi-carrier rate comparison across FedEx, UPS, DHL, and USPS behind one contract is the product, and it is good.
• You need free-text address parsing. ShipEngine turns “1600 Penn Ave Washington DC” into fields. RevAddress requires structured input.
• You need insurance, duties, or PUDO lookup. RevAddress has none of these.
• Your workload spreads evenly across endpoints. Per-endpoint buckets are strictly better than a pooled budget when no single endpoint dominates.
• You are building a logistics platform or a 3PL. Carrier abstraction is the whole point, and paying for it is correct.
• You need C#, Java, or Ruby. RevAddress ships Python, Node.js, and PHP.

When RevAddress is the right choice

• USPS is most of what you ship. A 200-carrier abstraction has a cost, and it is paid in per-label fees and in USPS fields that get normalized away.
• Your address volume is much larger than your label volume. Validation, standardization, and geocoding are not metered per call on a RevAddress plan; they draw on one monthly budget that costs $29 or $79.
• You want the USPS relationship in your name. BYOK at every plan, including Free. Your CRID, your MID, your EPA, your USPS reporting.
• You want to start at zero. 1,000 requests a month of Census-based standardization, geocoding, and address extract, no USPS license, no card. It will not tell you whether mail arrives; it will get an address into correct postal form with coordinates.
• You need the raw postal fields. DPV codes, DPV footnotes, ZIP+4, carrier route, CMRA, vacancy, business flags, all on your own USPS license.
• You want to read the client library. The SDKs are MIT-licensed and public.

Migrating the USPS endpoints

Non-disruptive, one endpoint at a time. ShipEngine keeps serving your non-USPS carriers throughout.

1. Get a free key at revaddress.com/signup. No card.
2. Install: pip install usps-v3 or npm install usps-v3.
3. Swap validation. se.validate_addresses() becomes client.addresses.validate(). Map verified to DPV Y; read the footnotes for everything ShipEngine put in messages.
4. Run both against real addresses and diff the results before cutting traffic over. Free-tier volume covers a sample.
5. Connect your USPS app from the dashboard for DPV, ZIP+4, rates, and service standards. About three minutes if your license already exists. If it does not, start the CRID and MID enrollment now, because signatures move at legal-department speed.
6. Move labels last, and only if you are on Pro with a funded EPA.
7. Keep ShipEngine for FedEx, UPS, DHL, insurance, and duties.

Budget two to four hours for a validation swap. Budget weeks for the USPS license if you do not have one, and start that clock first.

Sources

• ShipEngine, Pricing, checked August 23, 2026. Plan prices, the overage ladder, the per-endpoint FAQ answer, the Free-plan validation footnote, and the ShipStation API rename banner are all published there. Monthly prices for the 5,000 and 10,000 tiers are not shown on the public page; only the overage rates are.
• USPS, Addresses API Tech Sheet, fee schedule effective August 1, 2026, published August 13, 2026.
• RevAddress plan prices, limits, and per-plan features come from the pricing page, which renders from the same catalog the API meters against.

Start today

• Get a free API key — 1,000 requests a month, no card
• Full pricing · API reference with a live try-it
• Shipping API comparison 2026 — EasyPost, Shippo, ShipEngine, RevAddress side by side