Ship OpenJDK for two years without amending the order form and you keep paying on devices that never carried Oracle code
An embedded licence is a right to redistribute, not a right to use. It lets a named party ship a named runtime inside a named product, to a defined audience, counted on an agreed metric. Every argument that follows, about coverage, audits, royalties, and exit, is an argument about where one of those four lines sits.
Prepared by Redress Compliance · August 10, 2026 · Oracle advisory. Based on 15 to 25 embedded and OEM Java reviews, 2024 and 2025.
Executive summary
Confusion about which licence instrument applied drove more exposure than deployment scale ever did. Six instruments look identical on disk: a redistribution agreement, the current subscription, the free terms, the older network terms, a community build, and product restricted use rights.
The binary tells you nothing. Only the paperwork distinguishes them, which means the first task in any embedded review is establishing what you are actually standing on, before anyone counts a device.
Migrating the runtime does not reduce the invoice. Amending the contract does. This is the most expensive gap we find: the fleet had already moved to a community build on most devices, and the order form had never been amended, so the money kept moving on devices that no longer carried Oracle code.
The engineering work was done, the commercial work was not, and the two are entirely independent. Nothing about shipping a different runtime terminates a redistribution commitment.
The escalator and the true down clause outrank the rate, because embedded royalties are negotiated and confidential. Oracle does not publish embedded rates, so any public number you are quoted is a rumour rather than a benchmark, and there is no market price to argue toward.
What is arguable is structure: an uncapped escalator applied to a device count you no longer ship is the most common source of dead embedded spend in our file, and a true down right is what converts a forecast into something correctable.
Coverage is application scoped at both ends, which is where downstream exposure hides. A runtime distributed under an embedded licence may cover the end customer's use of that application only, never general purpose use of the same binary elsewhere on the machine.
It permits neither standalone distribution of the runtime nor automatic sublicensing to a partner who resells your product. Redistribution rights read as broader than the order form allows in our reviews, exposing shipments nobody had counted.
The four boundaries, and how each is breached
| Boundary | What the order form fixes | How it is usually breached |
|---|---|---|
| Product | The named product or family the runtime may ship inside | A second product reuses the same installer component after an acquisition |
| Version | The releases covered, often by major version | The product upgrades the bundled runtime and nobody reissues the paper |
| Territory and audience | Geography, and whether public sector or hosted use is included | The product is offered as a hosted service the form never contemplated |
| Metric and volume | The counting unit and the committed quantity | Actual shipments diverge from the forecast the metric was priced against |
Read the order form for the lines before you read it for the price, because three of the four boundaries are breached by ordinary product decisions nobody flags as licensing events.
An acquisition that reuses an installer component, a routine runtime upgrade inside a product release, a move from shipped software to a hosted offering: each of those is a normal roadmap decision taken by people who have never seen the redistribution agreement.
And each moves a line the agreement drew.
That is why embedded exposure tends to be discovered rather than accumulated deliberately, and why the review has to start with what the paper actually permits rather than with what the fleet currently runs. The metric side sits in the employee metric guide.
What an embedded licence never permits
- General purpose use by the end customer. The runtime may run the vendor's product. It may not run the customer's own code, scripts, or a second application on the same machine.
- Standalone distribution of the runtime. The binary cannot be handed over on its own, published in a repository, or shipped as a base image component.
- Automatic sublicensing to a partner. A reseller of your product does not inherit your redistribution right by virtue of reselling it.
- Silent version drift. Coverage is usually fixed by major version, so a runtime upgrade inside a product release moves outside the paper unless the paper moves with it.
- Counting against forecast rather than shipment. Device metrics were declared against the original forecast rather than what actually shipped, in both directions, across our reviews.
The Oracle Java SE employee licensing brief
The metric decoded, the version schedule, the supplier population qualifier, and the buyer side moves before renewal.
Get the white paper →Why the migration and the invoice come apart
The single most costly pattern in this category is also the least dramatic. An engineering team decides, correctly, that the product no longer needs the commercial runtime, and over a release cycle or two the fleet moves onto a community build.
The technical work completes, the risk the migration was meant to address disappears, and everybody involved regards the matter as closed.
Nothing happens to the order form, because amending it was nobody's task on the migration plan and the commercial owner was not in the room when the decision was taken.
So the royalty continues to accrue against a device count that includes units which never carried the vendor's code, sometimes for years.
That gap exists because redistribution commitments are contractual rather than technical: they attach to what you agreed to ship and to the quantity you agreed to declare, not to what is physically on the disk.
Nothing about changing the runtime terminates them, and no vendor is obliged to notice on your behalf. The remedy has two halves and both are administrative.
First, put the contract amendment on the migration plan as a named deliverable with an owner, alongside the engineering milestones, so the commercial change lands in the same programme as the technical one.
Second, negotiate a true down right before you need it, because a declaration that can only move upward converts every forecast into a floor.
Combined with an escalator cap, those two clauses matter more than the royalty rate you are quoted, particularly in a category where no published rate exists to benchmark against and structure is the only genuinely arguable ground.
The wider migration route sits in the alternative Java options guide.
- Percentile standing for your exact deal size and industry, from real closed transactions
- Scenario simulation before the call: test alternative terms and see the financial impact of each
- A negotiation playbook, talking points, and a two page executive brief on day one
What we saw across embedded and OEM reviews, 2024 and 2025
Across roughly 15 to 25 embedded and OEM Java reviews worked in 2024 and 2025, confusion about which licence instrument applied drove more exposure than deployment scale ever did:
Product, version, audience, and metric. Every later argument about coverage, audit, royalty, or exit is an argument about one of these lines.
Device counts were declared against the original forecast rather than actual shipments, in both directions, which cuts against the buyer as often as for them.
Four patterns recurred: redistribution rights read as broader than the order form allowed, exposing downstream shipments nobody had counted; the free terms and the subscription terms treated as interchangeable, masking a real and growing liability.
Device metrics declared against forecast rather than actual shipments; and the runtime already moved to a community build on most of the fleet while the order form had never been amended, so the money kept moving.
The buyer side move is to establish which instrument applies before counting anything, read the order form for its four boundaries before its price, and put the contract amendment on the migration plan as a named deliverable. The wider library sits in the Java practice.
Your first five moves
- Establish which of the six instruments you are standing on, because they look identical on disk and the entire analysis depends on the answer rather than on what is deployed.
- Read the order form for its four boundaries before its price: product, version, territory and audience, and metric and volume, since every later dispute is about where one of those lines sits.
- Reconcile declared device counts against actual shipments, which drifted in both directions across our reviews and is as likely to be understated as inflated.
- Put the contract amendment on the migration plan as a named deliverable, because changing the runtime does nothing to the invoice and nobody else will raise it.
- Negotiate the escalator cap and a true down right rather than the royalty rate, since no published rate exists to benchmark against and structure is the only arguable ground. The Java practice runs the review with you.
Frequently asked questions
What does an embedded Java licence permit?
It permits one party to redistribute a specified runtime inside a specified product, to a specified audience, counted on a specified metric.
Those four boundaries are the whole instrument, and everything argued about later, coverage, audits, royalties, and exit, is an argument about where one of those four lines sits.
Does it cover the end customer's use?
Only of that application.
Coverage is application scoped at both ends: a runtime distributed under an embedded licence may cover the end customer's use of the vendor's product, and never general purpose use of the same binary elsewhere on the machine, nor the customer's own code or a second application.
How do you tell which licence you actually hold?
From the paperwork, because six instruments look identical on disk: a redistribution agreement, the current subscription, the free terms, the older network terms, a community build, and product restricted use rights.
Establishing which one applies is the first task in any review, before anybody counts a device.
Does migrating to a community runtime reduce the bill?
No. Migrating the runtime does not reduce the invoice; amending the contract does. Redistribution commitments attach to what you agreed to ship and the quantity you agreed to declare, not to what is on the disk.
We routinely find fleets that moved years ago while the order form was never amended and the royalty kept accruing.
What are the published embedded royalty rates?
There are none. Per device and per end customer numbers are negotiated and confidential, so any public rate you are quoted should be treated as a rumour rather than a benchmark.
That is precisely why the structural terms matter more here than in categories where a market price exists to argue toward.
Which clauses matter most in an embedded agreement?
The escalator and the true down right. An uncapped escalator applied to a device count you no longer ship is the most common source of dead embedded spend we find, and a true down converts a declaration that can only rise into one that can be corrected. Both outrank the royalty rate.
Can a reseller ship our product under our embedded licence?
Not automatically. Sublicensing to another vendor is not implied by a redistribution right, so a partner reselling your product does not inherit your permission to ship the runtime inside it.
That has to be addressed explicitly in the paper, and it is one of the audience boundary breaches we see most often.
What makes embedded exposure so easy to accumulate?
That three of the four boundaries are moved by ordinary product decisions nobody flags as licensing events: an acquisition reusing an installer component, a routine runtime upgrade in a release, or a shift from shipped software to a hosted offering.
Each is a normal roadmap decision taken by people who have never read the agreement.
How to Negotiate the Oracle Java Employee Agreement: Honest Leverage in a Captive Deal
Priced per employee, every employee, from $15 down to $5.25. At renewal your leverage is thin and OpenJDK threats rarely land. The one-year runway, trading through the wider Oracle relationship, and containing what you sign.
