Class ReferenceRateCard

java.lang.Object
com.eqixiac.equinix.design.value.ratecard.ReferenceRateCard
All Implemented Interfaces:
RateCard
public final class ReferenceRateCard extends Object implements RateCard
A RateCard backed by a bundled, dated table of indicative reference figures - published cloud-provider egress rates, interconnect port fees, and on-prem/colocation midpoints - compiled so the value-realization models work out of the box without a live connection or caller-supplied rates.

Every value it returns is tagged PriceSource.REFERENCE and the card carries a disclaimer() making clear these are estimates, not quotes: cloud egress rates are standard-tier US/North-America headline prices, and Equinix-side figures are indicative fallbacks that should be superseded by the live Fabric Pricing API (use a LayeredRateCard with EquinixRateCard ahead of this one).

Because the bundled table is deliberately coarse, the lookups are coarse too: connection(...) matches on bandwidth alone - the smallest tabulated tier at or above the request, linearly extrapolated (with an EXTRAPOLATED note) above the top tier - and ignores connection type, metro, and term; cloudRouter(...) ignores metro and term, and substitutes the STANDARD figure for an unlisted package with a note naming the substitution; egress(...) matches provider + path, ignoring region and term. The emitted notes identify the tier or substitution; the data vintage is available via asOf() (the engines surface it in their reports' "as of" line).

The bundled data set is loaded once from /json/ratecard_reference_2026_11.json and cached.

Provider interconnect fees

providerConnection(CloudProviderType, ConnectionModel, int) prices the cloud provider's own side of a connection, keyed by provider, ConnectionModel (a dedicated port versus the hosted/partner connection a Fabric cloud connection is) and bandwidth. Every row is a public list price with its source URL and retrieval date; hourly rates are converted at 730 h/month. A look-up returns the exact tabulated tier, or the next tier up with a note "rounded up from X to Y Mbps", or is unpriced with the reason (no row for the provider and model, or a bandwidth above the largest tier). It never extrapolates and never substitutes a dedicated-port fee for a hosted connection. There is no term axis: none of the four providers publishes a term discount for these items.

Beta. multicloudLink(...) and the EgressPath.MULTICLOUD_INTERCONNECT egress rates come from a second, separately dated bundle, /json/ratecard_multicloud_reference_2026_09.json (multicloudAsOf()). It holds only figures copied from the providers' public pricing pages on 2026-09-21; each row records its source URL and retrieval date, and each quote's note repeats them together with the hourly-to-monthly conversion (MulticloudLinkQuote.HOURS_PER_MONTH = 730 h).

Bundled native-link coverage (2026-09)
SidePricedUnpriced (side returned empty with a reason)
AWS Interconnect - multicloud10000 Mbps at path tier 1 (12.33 USD/h) and tier 4 (51.78 USD/h)every other size and tier, including 1000 Mbps: AWS publishes no such rate and third-party reports conflict
Google Partner Cross-Cloud Interconnect transport1000, 5000, 10000 and 100000 Mbps in North America, Europe, APAC and South Americaother sizes; regions outside the four transport locations
Oracle Cloud, Microsoft Azurenothingalways

The lookup is an exact match on bandwidth (and on path tier or transport location where the provider uses one). It does not round up, interpolate or extrapolate, unlike connection(...): both providers sell sizes whose prices they do not publish, so a larger published size says nothing reliable about a smaller link. A Google Cloud side with no region is priced at the North America transport location and its note says so. The AWS free tier (one 500 Mbps tier-1 interconnect per Region per generally-available provider) is applied only when the request sets useAwsFreeTier; it is never a default.

  • Field Details

    • HOURS_PER_MONTH

      public static final int HOURS_PER_MONTH
      Hours per month every hourly reference rate is converted at (the SDK-wide convention).
      See Also:

  • Method Details

    • standard

      public static ReferenceRateCard standard()
      Returns the bundled standard reference rate card (2026-11 figures), loading and caching it on first use.
      Returns:
      the shared reference rate card

    • connection

      public Optional<PriceQuote> connection(ConnectionType type, int bandwidthMbps, MetroCode metro, Term term)
      Description copied from interface: RateCard
      Resolves the price of a single Fabric connection / virtual connection.

      Implementation contract. The matching strategy is implementation-specific, and a card whose data lacks an axis (metro, term, type) still returns its best figure - or empty - rather than failing; callers must not assume every card is sensitive to every parameter. Of the bundled cards: CustomRateCard resolves the most specific declared entry (exact metro+term down to metro/term-agnostic, then a declared default); EquinixRateCard matches bandwidth and type against the live catalogue, honours a requested metro strictly (a wrong-metro row is never returned), and prefers a term-matched row - a different-term row is only ever returned with a note naming the substitution; ReferenceRateCard matches on bandwidth alone (smallest tabulated tier at or above the request, linearly extrapolated with an EXTRAPOLATED note above the top tier) and ignores type, metro, and term entirely.

      Specified by:
      connection in interface RateCard
      Parameters:
      type - the connection type (e.g. EVPL_VC); may be null for any type
      bandwidthMbps - the provisioned bandwidth in Mbps
      metro - the metro the connection originates in (may be null if metro-agnostic)
      term - the commitment term (may be null if term-agnostic)
      Returns:
      the resolved quote, or Optional.empty() if this card cannot price the connection

    • cloudRouter

      public Optional<PriceQuote> cloudRouter(String packageCode, MetroCode metro, Term term)
      Description copied from interface: RateCard
      Resolves the price of a single Fabric Cloud Router instance.

      Implementation contract. As with RateCard.connection(ConnectionType, int, MetroCode, Term), matching is implementation-specific and cards without a metro/term axis return their best figure regardless. Of the bundled cards: CustomRateCard resolves the most specific declared (packageCode, metro, term) entry; EquinixRateCard matches the package code and metro structurally against the row's own descriptor (exact package equality, the row's own metro code) and prefers a term-matched row, labelling any term substitution; ReferenceRateCard ignores metro and term, and substitutes its STANDARD figure for an unlisted package with a note naming the substitution.

      Specified by:
      cloudRouter in interface RateCard
      Parameters:
      packageCode - the router package / tier code (e.g. "STANDARD"); may be null for any
      metro - the metro the router is deployed in (may be null if metro-agnostic)
      term - the commitment term (may be null if term-agnostic)
      Returns:
      the resolved quote, or Optional.empty() if this card cannot price the router

    • egress

      public Optional<EgressRate> egress(CloudProviderType provider, String region, EgressPath path, Term term)
      Description copied from interface: RateCard
      Resolves the per-GB data-egress rate for a cloud provider over a given path.

      Equinix does not sell cloud egress, so EquinixRateCard returns Optional.empty() here (the default); egress rates come from a CustomRateCard (your figures), a ReferenceRateCard (bundled indicative figures), or a provider-pricing-API card. The default returns empty so cards that do not model egress need not override it. Cards whose data has no region or term axis ignore those parameters - the custom and reference cards match on provider + path alone; only the provider-API adapters are region-sensitive.

      Specified by:
      egress in interface RateCard
      Parameters:
      provider - the cloud provider the data is leaving
      region - the provider region (may be null for a provider-wide rate)
      path - internet vs. private interconnect
      term - the commitment term (may be null; ignored by term-agnostic cards)
      Returns:
      the resolved egress rate, or Optional.empty() if this card cannot price it

    • multicloudLink

      public Optional<MulticloudLinkQuote> multicloudLink(MulticloudLinkRequest request)
      Resolves the two-sided price of a native provider-to-provider multicloud link (for example AWS Interconnect - multicloud paired with a Google Partner Cross-Cloud Interconnect transport). No Equinix resource is part of such a link. Each provider bills its own side, so the result is a MulticloudLinkQuote with one PriceQuote per side rather than a single figure.

      Beta: the products this models reached general availability in 2026 and their public price lists are incomplete.

      Implementation contract. The default returns Optional.empty(), so a card that does not model native links needs no change. An empty result means the card has no data for the provider pair. A present result may still have one or both sides unpriced: a side is priced only from a figure the card holds, and is otherwise left empty with a reason; callers must check MulticloudLinkQuote.isFullyPriced() before treating the quote as a link price. Cards convert hourly rates to monthly at MulticloudLinkQuote.HOURS_PER_MONTH hours and state the conversion in the side's note. The per-GB charge on the link is a separate lookup: egress(provider, region, EgressPath.MULTICLOUD_INTERCONNECT, term).

      Of the bundled cards: ReferenceRateCard prices only the figures published on the providers' pricing pages (each note carries the source URL and retrieval date) and applies the AWS free tier only when the request opts in; CustomRateCard prices the sides the caller declared; a RateCard.layered(...) chain resolves each side independently, the earliest card that prices a side winning; EquinixRateCard and the provider-API adapters return empty.

      Beta. Prices each side from the bundled 2026-09 multicloud data by exact match; see the class documentation for coverage and the no-rounding rule. Returns empty when neither provider appears in the bundle. A provider the bundle lists as unpriced (Oracle Cloud, Microsoft Azure) yields a present quote whose side is empty with the reason.

      Specified by:
      multicloudLink in interface RateCard
      Parameters:
      request - the link to price: both providers and regions, bandwidth in Mbps, the AWS path tier (1-5), the term, and the AWS free-tier opt-in
      Returns:
      the two-sided quote, or Optional.empty() if this card has no data for the provider pair (or request is null)

    • source

      public PriceSource source()
      Description copied from interface: RateCard
      The dominant provenance of prices this card produces. Aggregating cards report PriceSource.COMPOSITE.
      Specified by:
      source in interface RateCard
      Returns:
      the price source

    • asOf

      public String asOf()
      The vintage of the bundled figures, e.g. "2026-11". Reports should surface this next to any reference-derived number so its age is visible.
      Returns:
      the data set's as-of stamp, or null if the bundle omits it

    • disclaimer

      public String disclaimer()
      The bundled data set's own disclaimer text - what the figures are, what they exclude, and why they are estimates rather than quotes. Engines append it to their report output.
      Returns:
      the disclaimer, or null if the bundle omits it

    • multicloudAsOf

      public String multicloudAsOf()
      The vintage of the bundled native-multicloud-link figures, e.g. "2026-09". It is tracked separately from asOf() because the two bundles were compiled at different times.
      Returns:
      the multicloud data set's as-of stamp, or null if the bundle omits it

    • multicloudRetrieved

      public String multicloudRetrieved()
      The date (ISO 8601) the bundled native-multicloud-link figures were read from the providers' pricing pages.
      Returns:
      the retrieval date, e.g. "2026-09-21", or null if the bundle omits it

    • multicloudDisclaimer

      public String multicloudDisclaimer()
      The multicloud bundle's own disclaimer: what the figures are, that unpublished figures are reported unpriced, and the hourly-to-monthly conversion.
      Returns:
      the disclaimer, or null if the bundle omits it

    • multicloudPublishedSizes

      public BandwidthTier multicloudPublishedSizes(CloudProviderType provider)
      The link sizes, in Mbps, for which the multicloud bundle holds at least one published rate for the provider (across every path tier and transport location).
      Parameters:
      provider - the cloud provider
      Returns:
      the published sizes; an empty tier set when the provider's side is never priced

    • currencyCode

      public String currencyCode()
      The ISO 4217 code of the currency every bundled figure is expressed in ("USD" for the standard bundle). The engines compare it against their comparison currency before folding reference figures into a total - reference numbers are never mixed into a differently-denominated sum.
      Returns:
      the reference data's currency code

    • onPrem

      public Optional<BigDecimal> onPrem(String key)
      An indicative on-premises cost midpoint by key. The bundled keys are:
      • "transitPerMbpsMonth" - carrier IP transit, per Mbps per month;
      • "crossConnectMonthly" - a carrier-hotel cross-connect, per month;
      • "hardwareMonthly" - amortized network hardware, per month;
      • "powerPerKwMonth" - power/space, per kW per month.
      These feed the TCO model's on-prem archetype and are individually overridable via the TcoCalculator.Builder.onPrem* methods.
      Parameters:
      key - one of the keys above
      Returns:
      the midpoint in the reference currency, or empty for an unknown key or an entry missing from the bundle

    • equinixCrossConnectMonthly

      public Optional<BigDecimal> equinixCrossConnectMonthly()
      The indicative monthly fee for one Equinix cross-connect (per physical cross-connect, in the reference currency) - the fallback the TCO model uses when the caller supplies no ColocationItem.CROSS_CONNECT rate.
      Returns:
      the per-unit monthly fee, or empty if the bundle omits it

    • retrieved

      public String retrieved()
      The date (ISO 8601) the provider interconnect rows were read from the providers' pricing pages; each row also carries its own date in its quote note.
      Returns:
      the retrieval date, e.g. "2026-11-12", or null if the bundle omits it

    • providerConnection

      public PriceLookup<PriceQuote> providerConnection(CloudProviderType provider, ConnectionModel model, int bandwidthMbps)
      The cloud provider's own fee for one connection: exact tier, next tier up (the note says "rounded up from X to Y Mbps"), or unpriced with the reason. The quote is PriceSource.REFERENCE; its note states the product, the hourly rate and the 730 h conversion where the provider publishes hourly, the source URL and the retrieval date.
      Parameters:
      provider - the cloud provider
      model - dedicated port or hosted/partner connection (a Fabric cloud connection is ConnectionModel.HOSTED)
      bandwidthMbps - the connection bandwidth
      Returns:
      the monthly fee, or the reason it is unpriced

    • providerConnectionTiers

      public List<Integer> providerConnectionTiers(CloudProviderType provider, ConnectionModel model)
      The bandwidths, in Mbps, the card tabulates for a provider and model, ascending. The growth projection uses them to find when traffic forces the next tier.
      Parameters:
      provider - the cloud provider
      model - the connection model
      Returns:
      the tabulated tiers; empty when the card holds no row

    • cspInterconnectPortMonthlyQuote

      public Optional<PriceQuote> cspInterconnectPortMonthlyQuote(CloudProviderType provider, int bandwidthMbps)
      The provider-side fee of a Fabric cloud connection: shorthand for providerConnection(provider, ConnectionModel.HOSTED, bandwidthMbps).toOptional(). Exact tier or the next tier up (noted); empty above the largest hosted tier or for a provider with no hosted row.
      Parameters:
      provider - the cloud provider
      bandwidthMbps - the connection bandwidth
      Returns:
      the reference monthly fee as a noted quote, or empty

    • egressLookup

      public PriceLookup<EgressRate> egressLookup(CloudProviderType provider, String region, EgressPath path, Term term)
      Description copied from interface: RateCard
      RateCard.egress(CloudProviderType, String, EgressPath, Term) with the reason when it cannot be priced.
      Specified by:
      egressLookup in interface RateCard
      Parameters:
      provider - the provider; may be null
      region - the region; may be null
      path - the path; may be null
      term - the term; may be null
      Returns:
      the rate, or the reason there is none

    • colocationLookup

      public PriceLookup<PriceQuote> colocationLookup(ColocationItem item, MetroCode metro, Term term)
      Description copied from interface: RateCard
      RateCard.colocation(ColocationItem, MetroCode, Term) with the reason when it cannot be priced.
      Specified by:
      colocationLookup in interface RateCard
      Parameters:
      item - the colocation primitive
      metro - the metro; may be null
      term - the term; may be null
      Returns:
      the figure, or the reason there is none

    • connectionLookup

      public PriceLookup<PriceQuote> connectionLookup(ConnectionType type, int bandwidthMbps, MetroCode metro, Term term)
      Description copied from interface: RateCard
      RateCard.connection(ConnectionType, int, MetroCode, Term) with the reason when it cannot be priced. Cards override this to say exactly why (no metro, no live row, no declared rate); the default states that this card holds no figure.
      Specified by:
      connectionLookup in interface RateCard
      Parameters:
      type - the connection type; may be null
      bandwidthMbps - the bandwidth in Mbps
      metro - the metro; may be null
      term - the term; may be null
      Returns:
      the figure, or the reason there is none

    • cloudRouterLookup

      public PriceLookup<PriceQuote> cloudRouterLookup(String packageCode, MetroCode metro, Term term)
      Description copied from interface: RateCard
      RateCard.cloudRouter(String, MetroCode, Term) with the reason when it cannot be priced.
      Specified by:
      cloudRouterLookup in interface RateCard
      Parameters:
      packageCode - the router package; may be null
      metro - the metro; may be null
      term - the term; may be null
      Returns:
      the figure, or the reason there is none