Price plans
A price plan is the core component for defining prices. It holds a set of rules, and each rule says what to charge for a resource under given conditions.
OSIE bills pay-as-you-grow: the billing engine runs periodically, walks the price plans that apply to each customer, evaluates their rules against the customer's live resources, and adds the result to the open bill. An hourly rule runs every hour and adds that hour's charge — nothing is estimated up front and nothing is charged in advance.
Create a price plan
From the Settings navigate to Price plans and create one. A plan has:
- Name — an arbitrary name for the plan.
- Enabled — a disabled plan is skipped by the billing job entirely, along with all of its rules.
- Access mode
- Public — applies to every billing profile.
- Scoped (Manual assignment) — applies only to the billing profiles it is assigned to. Use scoped plans to give individual customers their own prices.

Once the plan exists, its General tab adds one more control:
- Applied to Cloud Providers — restricts the plan to specific cloud providers. Left empty, the plan applies to all of them. This is how one deployment charges different prices per cloud while keeping a single set of customers.

A scoped plan does not replace the public ones. You assign it — and decide whether the customer also keeps the public plans — on the billing profile's Price Plans tab. When they keep both, the rules of both are evaluated and both contribute to the bill, so give a scoped plan rules only for the resources you want to reprice rather than a full copy of the catalog.
Price plan rules
A price plan contains a list of rules. When the billing job runs it iterates through the rules, skipping any whose resource type or filters do not match the resource at hand. The list shows each rule's frequency and resource type, and how many prices, filters and modifiers it carries.

Create a price plan rule
The example below charges 0.1 per hour for every m1.small instance. The amount is expressed in the
currency configured in the billing settings.

The billing job interprets that rule as:
Every hour, for each instance whose
instance_typeism1.small, add0.1to the bill. Then come back an hour later and do the same.
Four fields identify a rule:
Name
An internal label, visible only in the admin dashboard. Make it recognisable — it is what you will scan in the rules list.
Charge description
The customer-facing label for the charge on the bill. Leave it empty and the bill falls back to the resource's own name, which is rarely what a customer wants to read.
Frequency (time unit)
- minute — runs every minute, at most
43200times a month. To cap a resource at $10 per month, divide 10/43200 and enter0.0002314814815as the amount. - hour — runs every hour, at most
720times a month. For $10 per month, enter 10/720 =0.01388888889. - month — runs within an hour of the resource being created, and the amount is pro-rated over the days remaining in the month. A resource created on the 20th of a 31-day month is charged roughly 11/31 of the monthly amount; from the next month on it is charged in full.
Resource type
The type of resource the rule applies to. Each type exposes its own attributes, which are what prices, filters and modifiers are written against — see Resource types.
A rule applies to exactly one resource type. Charging for both instances and volumes takes two rules.
Prices
A price is an attribute × amount. Pick a resource attribute, enter an amount, and each job run multiplies the two.

Only numeric attributes appear in the list, because a price multiplies the amount by the attribute's
value. Offered alongside them on every resource type is existence, which is always 1 while the
resource is in the customer's account — the way to charge for a resource simply being there, and the
way to charge for any condition you can express as a filter.
A few examples for an hourly rule:
- existence —
0.1 × 1per hour. Projected over a month:0.1 × 1 × 720 = 72.00 - vcpus —
0.1 × vcpusper hour. A 2-vCPU instance:0.1 × 2 = 0.2per hour, or144.00a month
Several prices in one rule are summed. Defining both of the above charges
existence × 0.1 + vcpus × 0.1 = 0.3 per hour for a 2-vCPU instance.
The amount is per unit of the attribute, and the unit is the attribute's own. size on a volume is
GB, but size on a bucket is bytes — the same amount that prices a volume sensibly would price a
gigabyte of object storage a hundred million times over. Check the unit in
Resource types before entering an amount, and prefer size_gb where the type
offers it.
Gauges and counters
Attributes come in two shapes, and OSIE picks how to write the result to the bill from the one you choose:
- A gauge describes the resource right now —
existence,vcpus,size. Each run adds its result to the bill line, which is what accumulates an hourly charge over the month. - A counter is a total the cloud already accumulates for you —
total_traffic_mb,gib_hours. Each run overwrites the bill line, because the number reported already includes everything metered so far this cycle.
You do not set this; it follows from the attribute. It does mean one rule cannot mix the two — the dashboard refuses with Invalid price type. Price traffic in its own rule, separate from the rule that charges for the instance existing.
Tiered prices
Tiered turns a single amount into a scale. Each tier has a From, a To and an amount, and tiers are graduated: every tier prices only the part of the attribute's value that falls inside its own range, and the results are added together. Leave To empty on the last tier for "no limit".

For the tiers above — 0–100 at 0.00003, 101–1000 at 0.000025, 1000+ at 0.00002 per GB per
hour — a 1,500 GB bucket is charged for one hour as:
| Tier | GB priced in this tier | Amount |
|---|---|---|
| 0–100 | 100 | 0.003 |
| 101–1000 | 900 | 0.0225 |
| 1000+ | 500 | 0.010 |
| Total | 1,500 | 0.0355 |
Growing past a threshold therefore lowers the price of the next gigabyte, never of the ones already priced below it. This is the opposite of how adjustment rule tiers behave, so keep the two apart when you plan a discount structure.
The open-ended last tier measures from its own From value, while a bounded tier starts one above its
predecessor's To. Set the last tier's From equal to the previous tier's To — 1000 above,
not 1001 — otherwise one unit falls between the two and goes unpriced.
Filters
Filters restrict a rule to resources matching some criteria — a specific flavor, a status, a region. Filtering is done on the resource's attributes, and all filters on a rule must match for its prices to apply.

| Operator | Applies to | Matches when the attribute |
|---|---|---|
equals / not equals | any | is (or is not) the value |
greater than / greater than or equal to | numeric | is above the value |
less than / less than or equal to | numeric | is below the value |
exists in | any | is one of several values you list |
contains / does not contain | text | contains (or does not contain) the value |
starts with / does not start with | text | begins (or does not begin) with the value |
Text is compared without regard to case, except by exists in. Where an attribute has a known set of
values — flavors, images, volume types — the value field becomes a dropdown instead of a free-text box.
An attribute the resource does not report matches only the negations: not equals, does not contain and
does not start with. A filter on the wrong attribute therefore prices nothing, while a not equals filter
on a metadata key excludes only the resources carrying that value and keeps
pricing every resource without the key. Filtering on service_id or region is how one plan charges
different prices per cloud or per region.
Leave resources out by name
does not start with and does not contain leave out resources whose names follow a pattern, such as the
volumes a backup product creates in the customer's project. Storware, for example, names its snapshot volumes
vProtect-snap-<id>, and a volume rule filtered on display_name does not start with vProtect-snap-
does not charge them. A filter belongs to its rule, so add it to every rule that should leave those volumes
out, in every price plan. Price adjustments and savings plans need no filter of their own: a volume that no
rule charges adds nothing to them.
Modifiers
A modifier adjusts the price the rule has just calculated, when the resource meets a condition. Discounts for a state you want to encourage, surcharges for one you do not.

Each modifier is a condition plus an adjustment:
| Field | Meaning |
|---|---|
| Attribute Name + Operator + Attribute Value | The condition, using the same operators as filters |
| Modifier Operator | Add charges more, Subtract charges less |
| As Percentage | When on, Value is a percentage of the calculated price; when off, a flat amount |
| Value | The size of the adjustment |
The modifier above reads: when an instance's status is SHUTOFF, subtract 50% of the price. With the
0.1 hourly price, a stopped instance costs 0.05 an hour, and starting it returns it to 0.1 — the
condition is re-evaluated on every run.
Where filters and modifiers differ: a filter decides whether the rule applies at all, a modifier changes how much it charges.
Two details worth knowing before you stack them:
- Modifiers apply to each price of the rule separately, not to the rule's total. On a rule pricing
both
existenceandvcpus, a 50% subtraction halves both. - Several modifiers apply in turn, each working on the price left by the one before, so two 10% subtractions take off 19%, not 20%.
A modifier whose attribute the resource does not report leaves the price untouched.
Prices shown to customers
On the bill, each charge is labelled with the rule's Charge description.
Before creating a resource, the portal also shows a projected monthly cost per flavor, so a customer can compare sizes before committing:

The figure is the matching rule's prices extended over a full month — 0.1 per hour becomes 72.00 over
720 hours. It deliberately leaves out counter attributes such as traffic, which cannot be predicted
from the resource's size, so a customer's actual bill for a metered resource can exceed the projection.
Monthly rules are shown at their full amount here even though a resource created mid-month is charged
pro-rata. Billing itself still happens at the rule's frequency.
Change a rule that is already in use
A rule that the billing job has already applied shows how many open bills it feeds and how much it has charged so far.

Editing a price changes what is charged from the next job run onwards. Amounts already rated stay on the bill as they were — the engine never goes back and re-prices hours it has already billed. That makes a price change safe to apply mid-cycle, and it means a mistake is not undone by fixing the rule: correct the rule to stop further mispricing, then adjust the bills that were already rated.
Deleting a rule likewise leaves the charges it has already written in place. Disabling the whole price plan stops all of its rules at once.
Clone a plan or its rules
Clone on a price plan copies it with its rules, which is the quickest way to build a scoped plan for one customer from the public catalog. Clone Rules on the Pricing Rules tab copies selected rules into another plan, for when only part of the catalog differs.
Adjustment rules
A modifier adjusts the price of one resource. To adjust what a customer has accumulated on the bill as a whole — volume discounts, surcharges, flat fees — a price plan also carries adjustment rules.