Cloud-to-cloud Beta

Status and scope#

All functions on this page are Beta. Two cloud providers can join their networks with a link that they build between themselves, with no Equinix resource on the path. AWS announced general availability of such links with Google Cloud on 2026-04-14 and with Oracle Cloud on 2026-07-29. The SDK models that link as a third path next to the internet and the Fabric path, prices all three on the same traffic, and reports the sustained rate at which the lowest-cost path changes.

The SDK plans and prices the native link. It does not create it: the SDK calls no cloud provider API.

The three paths#

The native link's fee is flat, so it costs more than the Fabric path at low utilization and less at high utilization. A Cloud Router can also connect further clouds, sites and providers. A native link connects two clouds.

Comparison with the TCO calculator#

With toCloud(...) the calculator prices traffic in both directions and adds the native archetype to the default set.

import com.eqixiac.equinix.core.enums.MetroCode;
import com.eqixiac.equinix.design.value.ratecard.ReferenceRateCard;
import com.eqixiac.equinix.design.value.ratecard.Term;
import com.eqixiac.equinix.design.value.savings.DataUnit;
import com.eqixiac.equinix.design.value.tco.CostBreakdown;
import com.eqixiac.equinix.design.value.tco.DeploymentArchetype;
import com.eqixiac.equinix.design.value.tco.TcoComparison;
import com.eqixiac.equinix.fabric.model.implementation.cloud.CloudProviderType;

TcoComparison tco = fabric.tcoComparison()
    .egress(100, DataUnit.TERABYTE)               // AWS to Google Cloud, per month
    .reverseEgress(40, DataUnit.TERABYTE)         // Google Cloud to AWS; defaults to the forward volume
    .fromCloud(CloudProviderType.AWS).inRegion("us-east-1")
    .toCloud(CloudProviderType.GOOGLE_CLOUD).toRegion("us-east4")
    .viaMetro(MetroCode.DC)
    .bandwidthMbps(10_000)                        // link size on every path
    .includeCloudRouter("STANDARD")
    .pathTier(1)                                  // AWS connectivity-scope tier, 1 to 5
    .term(Term.MONTH_12)
    .rateCard(ReferenceRateCard.standard())       // bundled figures only: reproducible offline
    .compare();

System.out.println(tco.getTrafficNote());
System.out.println(tco.getRecommended());

CostBreakdown nativeLink = tco.breakdown(DeploymentArchetype.NATIVE_MULTICLOUD_INTERCONNECT).orElseThrow();
if (!nativeLink.isPriced()) {
    System.out.println(nativeLink.getNote());     // names the unpriced side and the reason
}
nativeLink.getProvenance().forEach(System.out::println);

Result with the bundled reference figures, in USD. One-time charges are 0.00 on all three paths.

140 TB per month is a sustained 426 Mbps summed over both directions, which is below the break-even rate for these prices, so the Fabric path costs less.

Break-even rate#

The savings calculator reports the rate at which the Fabric path and the native link cost the same.

import com.eqixiac.equinix.design.value.savings.MulticloudPathComparison;
import com.eqixiac.equinix.design.value.savings.SavingsEstimate;

SavingsEstimate estimate = fabric.savingsCalculator()
    .egress(100, DataUnit.TERABYTE)
    .reverseEgress(40, DataUnit.TERABYTE)
    .fromCloud(CloudProviderType.AWS).inRegion("us-east-1")
    .toCloud(CloudProviderType.GOOGLE_CLOUD).toRegion("us-east4")
    .viaMetro(MetroCode.DC).bandwidthMbps(10_000)
    .includeCloudRouter("STANDARD")
    .rateCard(ReferenceRateCard.standard())
    .calculate();

estimate.breakEvenSustainedMbps()
    .ifPresent(mbps -> System.out.println(mbps + " Mbps sustained, both directions summed"));   // 2784.3

MulticloudPathComparison paths = estimate.getMulticloudComparison();      // null without toCloud(...)
System.out.println(paths.getLowestCostPath());
paths.getNotes().forEach(System.out::println);

For symmetric traffic of g GB per month in each direction:

g*     = (nativeFixedMonthly - equinixFixedMonthly) / (equinixPerGbSum - nativePerGbSum)
result = 2 x g* x 8000 / (730 x 3600)

g* is the break-even volume in GB each way per month. nativeFixedMonthly and equinixFixedMonthly are the fixed monthly costs of the two paths in one currency. equinixPerGbSum is the sum of the two clouds' private egress rates per GB, and nativePerGbSum is the per-GB charge on the native link, which is 0 for AWS and Google Cloud. The result is in Mbps, both directions summed: 8000 converts GB to megabits and 730 x 3600 is the seconds in a 730-hour month.

With the figures above, the result is 2 x ((22,870.90 - 5,218.50) / 0.0386) x 8000 / 2,628,000 = 2,784.3 Mbps. On a 10 Gbps link, the native path is cheaper when the sustained two-way rate stays above about 2.8 Gbps.

The break-even is empty when a side is unpriced, when the currencies differ, or when the two cost lines do not cross. When they do not cross, one path costs the same or less at every volume, and dominatesAtEveryVolume(...) names it.

Bundled native-link prices#

The prices are in USD and were read from the providers' pricing pages on 2026-09-21.

Lookup rules of the reference card:

• The requested size must equal a published size, because the card does not round, interpolate or extrapolate a native-link rate.
• AWS publishes 10,000 Mbps at path tiers 1 and 4 only. Any other AWS size or tier, and the Oracle Cloud and Azure sides, are unpriced. An archetype with an unpriced side is partially priced, and the comparison does not recommend a partially priced archetype.
• The AWS path tier is an input, default 1. AWS assigns the tier from the regions the link serves and publishes no table for it.
• The AWS free tier is applied only with useAwsFreeTier(true).
• An hourly rate is converted to a monthly figure at 730 hours. A 31-day month has 744 hours.

A custom card in front of the reference card supplies a rate that the reference card lacks.

import com.eqixiac.equinix.design.value.ratecard.CustomRateCard;
import com.eqixiac.equinix.design.value.ratecard.RateCard;

RateCard rates = RateCard.layered(
    CustomRateCard.builder()
        .currency("USD")
        // provider, Mbps, path tier, USD per hour. Use the rate on your own AWS quote.
        .multicloudLinkHourlyRate(CloudProviderType.AWS, 1_000, 1, new BigDecimal("2.00"))
        .build(),
    ReferenceRateCard.standard());

Native links on a plan#

The Deployment Wizard adds native links to a plan according to CloudToCloudStrategy.

import com.eqixiac.equinix.design.optimizer.wizard.enums.CloudToCloudStrategy;
import com.eqixiac.equinix.design.optimizer.wizard.model.DeploymentPlan;
import com.eqixiac.equinix.design.optimizer.wizard.model.MulticloudLinkPricing;
import com.eqixiac.equinix.design.optimizer.wizard.model.PlannedMulticloudInterconnect;

DeploymentPlan plan = fabric.deploymentWizard(result)
    .cloudToCloudStrategy(CloudToCloudStrategy.COMPARE)
    .multicloudPathTier(1)
    .notifications("noc@example.com")
    .plan();

for (PlannedMulticloudInterconnect link : plan.multicloudLinksOrEmpty()) {
    System.out.println(link.getName() + ": " + link.describe() + ", role " + link.getRole());
    System.out.println(link.getRecommendation());

    MulticloudLinkPricing price = link.getPricing();          // null for an UNAVAILABLE entry
    if (price != null) {
        price.breakEvenSustainedMbps().ifPresent(mbps -> System.out.println("break-even " + mbps + " Mbps"));
    }
    link.getCreateThenAcceptRecipe().forEach(step -> System.out.println("  " + step));
}

A connection is replaced only when all of these hold: the matched environment is generally available and lists a size that covers the requested bandwidth; the design declares no user site; the cloud is not a design-level requirement; every workload on the connection depends on well-known clouds only; and the bandwidth was not set by a custom map. The wizard either omits a connection or keeps it unchanged, and it plans the metro's Cloud Router in both cases.

PlanPricing reports native-link charges in separate fields that are not part of monthlyTotal. Execution sends no request for a native link and lists each link once in DeploymentOutcome.getInformational().

Environment catalog#

The bundled catalog is a copy of provider documentation taken on 2026-09-21. A region pair that is absent from the catalog may have been added by the providers since.

MulticloudEnvironmentCatalog.standard().with(MulticloudEnvironment.of(...)) adds a newer entry, and multicloudEnvironments(catalog) passes it to the wizard or the optimizer.

Activation keys#

A customer sets up a native link in three steps. At provider A the customer selects the environment, the size and the account at provider B, and receives an activation key. The customer carries the key to provider B and enters it there. The providers then set up the link between themselves.

ActivationKey decodes the key format of the specification: base64-encoded JSON, discriminated on an integer version.

import com.eqixiac.equinix.core.model.multicloud.ActivationKey;

ActivationKey key = ActivationKey.decode(keyFromProvider);      // throws only for a null or blank argument

String summary = switch (key) {
    case ActivationKey.V1 v1 -> v1.connectionSizeMbps() + " Mbps to " + v1.destinationEnvironmentUri();
    case ActivationKey.V2Encrypted v2 -> "encrypted; the envelope names " + v2.destinationEnvironmentUri();
    case ActivationKey.Opaque opaque -> "format not recognized, " + opaque.raw().length() + " characters";
};

String toEnterAtTheOtherProvider = key.encode();                // the issued string, not re-serialized

A version 1 key is cleartext and its fields are enough to rebuild it, so the type treats it as a credential. toString() on every variant omits the shared connection identifier, the destination account, the ciphertext and the encoded form. Jackson serializes a key as {}. Only encode(), V1.sharedConnectionUuid(), V1.destinationAccountId() and Opaque.raw() return key material. The SDK cannot decrypt a version 2 key.

The specification publishes no example key, so the SDK's test fixtures are built from the schema. The format changed between two commits of the specification.

Fabric Beta operations#

The Fabric v4 catalog defines two Beta operations on an IC_PROFILE service profile.

import com.eqixiac.equinix.fabric.model.EnvironmentActionResponse;
import com.eqixiac.equinix.fabric.model.implementation.ProviderEnvironment;

List<ProviderEnvironment> environments = fabric.serviceProfiles().getEnvironments(icProfileUuid);
for (ProviderEnvironment environment : environments) {
    System.out.println(environment.getUuid() + " " + environment.getRegion() + " " + environment.getSupportedBandwidths());
}

EnvironmentActionResponse response = fabric.serviceProfiles()
    .validateActivationKey(icProfileUuid, environments.get(0).getUuid(), keyFromProvider);
if (response.isKeyUnused()) {                                   // true only for state INACTIVE
    System.out.println("key not yet used");
}

The catalog publishes a request example for the validation and no response example. Which response properties the service populates is unverified, and every getter can return null.

Limits#

• The SDK covers the customer's side of a native link and does not implement the provider-to-provider specification. A separate artifact for the specification is planned and not published.
• Prices and the region-pair catalog are dated copies of provider pages.
• The break-even assumes symmetric traffic and list prices. Discounts, commitments and the AWS free tier change it.
• The live provider price adapters return nothing for a native link.
• The comparison covers cost. It does not account for the endpoints each path can reach, the routing control of a Cloud Router, or the operating effort of two more provider-side resources.

MCP tools: design_compare_cloud_to_cloud and design_list_multicloud_environments (MCP server). Worked example: cloud-to-cloud walkthrough.