What you will be able to do
- Choose between a usage-based and a subscription-based pricing plan for a Native App listing, knowing a listing carries only one
- Explain which compute pool costs a consumer pays Snowflake directly and which a provider can add as a surcharge
- Configure compute pool surcharges for an app with containers within their combination rules
- Emit billable events from app code with SYSTEM$CREATE_BILLING_EVENT and SYSTEM$CREATE_BILLING_EVENTS
- Configure matching billable events on a listing and test them in a consumer account before publishing
Key concept
Pricing plan — The single set of charges a provider attaches to a paid listing. It is either usage-based, billed monthly in arrears from what the consumer actually did, or subscription-based, charged upfront for a fixed term. Surcharges and billable events are parts of a usage-based plan.
1.One pricing plan per listing: usage-based or subscription-based
A paid listing earns money through exactly one pricing plan, and that plan is either usage-based or subscription-based. There is no menu of plans for the consumer to pick from at install time, and you cannot keep both types on one listing. The choice also lasts. A provider cannot remove a pricing plan from a listing, and any change to the plan on a public Marketplace listing has to be approved. Some changes are not allowed at all. Turning a non-recurring subscription into a recurring one, or adding installments to an existing plan, means making a new listing.
| Plan type | What is charged | When the consumer pays |
|---|---|---|
| Usage-based | Any combination of billable events, a per-query charge, and a monthly fee | Billed in arrears, in months where usage occurs |
| Subscription-based | A price for a specified term, with optional recurring billing | Billed upfront |
Usage-based plans charge for what happened in a month, so a consumer who does nothing pays nothing. Three components can be combined. Billable events (Custom Event Billing) are open only to listings that share an application, which is why a data-only listing can pick only per-query and monthly-fee options. A per-query charge is a fixed price for each query against the paid content. The first query of every calendar month is always charged, and you can let a number of further queries run free before charging starts again. A monthly fee is a fixed, unprorated price for each calendar month in which at least one query references the app. For an app with Snowpark Container Services, the monthly fee is charged once when the compute pool runs.
Dynamic charges need a ceiling. A plan with per-query charges or billable events has to set a Maximum Monthly Charge in US dollars. It covers every usage-based charge in the plan, and once a consumer reaches it, further usage that month is free.
Subscription-based plans charge upfront for a term of 1–36 months, whether or not the consumer uses the product. Under Billing and access, Recurring charges at the start of each term and auto-renews. One time (non-recurring) charges once for a fixed access period, and the consumer can neither renew nor repurchase the listing. If you want a fixed monthly price that applies even in months with no usage, choose a recurring subscription. A usage-based monthly fee is charged only in months with activity.
Checkpoint 1 of 9· Check yourself
A provider wants a paid Native App listing to charge consumers a fixed price every month, including months when the consumer never queries the app. The billing should continue month after month until the consumer stops. Which pricing setup meets this requirement?
A usage-based monthly fee is charged only in months when at least one query references the app. A recurring subscription charges upfront at the start of each term, whether or not the app is used, and renews automatically. A one-time subscription never renews. A listing can carry only one pricing plan, so the consumer cannot choose between two.
“If you want to charge a monthly fee whether or not consumers use your data product, add a subscription-based plan instead.”Source: docs.snowflake.com
Checkpoint 2 of 9· Exam question
A provider wants to attach a pricing plan to a paid Marketplace listing for a Snowflake Native App. Which statement about pricing plan attachment is correct?
Correct answer: A — A provider can attach a single pricing plan to a listing, choosing either usage-based or subscription-based
- A. This is correct: Snowflake documentation states a provider attaches a single pricing plan to a listing, and that plan is either usage-based or subscription-based, not both simultaneously.
- B. Incorrect. Providers choose one pricing model per listing rather than being required to combine subscription and usage-based charges.
- C. Incorrect. Consumers do not select from multiple competing pricing plans on a single listing; the provider defines one plan for that listing.
- D. Incorrect. Pricing plans are configured in Provider Studio before publishing, not gated behind having an existing installed consumer.
Checkpoint 3 of 9· Exam question
A provider is deciding between subscription-based and usage-based pricing for a new Native App listing. Which characteristic correctly distinguishes non-recurring subscription pricing from usage-based pricing?
Correct answer: A — Non-recurring subscription pricing charges a one-time fee with no automatic repurchase, while usage-based pricing charges based on consumption such as queries or billable events
- A. This is correct: non-recurring subscription pricing is a one-time upfront payment with no automatic repurchase, whereas usage-based pricing meters actual consumption like per-query charges, monthly fees, or custom billing events.
- B. Incorrect; auto-renewal describes recurring subscription pricing, not the non-recurring variant, and usage-based pricing is metered continuously rather than framed around renewal.
- C. Incorrect. Subscription pricing is not restricted to container-based apps; it applies broadly to paid listings regardless of the underlying compute model.
- D. Incorrect, this reverses the definitions — per-query charging is a usage-based charge type, while subscriptions charge a fixed term price rather than metering queries.
Sources1
2.What a container app costs the consumer before any pricing plan
Your pricing plan is only part of what a consumer pays for an app with containers. The other part is the Snowflake infrastructure the app runs on. Compute pools, warehouse compute, storage and data transfer are billed to the consumer's account as separate charges, whichever plan you chose. Pool cost follows from what the app creates: the services run on compute pools (see Snowpark Container Services in Native Apps (compute pools, services, endpoints)), and the instance family and node count you pick in CREATE COMPUTE POOL set how many credits the pool burns. A large GPU pool in your setup script ends up on the consumer's bill even if your listing is a flat subscription.
Compute pools are billed by state, not by workload. IDLE means the pool holds its desired number of nodes with no services scheduled, and it still costs credits, because the nodes exist. ACTIVE, STOPPING (releasing nodes after a suspend) and RESIZING (provisioning up to the minimum node count, or autoscaling) are billed too. STARTING, before the first node is provisioned, is free, and so is SUSPENDED, when the pool has no running nodes. The consumer stays in control here: they can see every pool with SHOW COMPUTE POOLS IN ACCOUNT, suspend a pool, or drop the application at any time.
| State | What is happening | Charged |
|---|---|---|
| STARTING | Created or resumed; no node provisioned yet | No |
| RESIZING | Provisioning to the minimum nodes, or autoscaling | Yes |
| ACTIVE | At least one service running or scheduled | Yes |
| IDLE | Desired nodes present, no services scheduled | Yes |
| STOPPING | Releasing all nodes after a suspend | Yes |
| SUSPENDED | No running virtual machine nodes | No |
These state-based charges go to the consumer whether the listing is usage-based, subscription-based or free. A subscription listing does not exempt the consumer from compute pool credits. What it rules out is a provider surcharge on top of them.
Checkpoint 4 of 9· Check yourself
Your app's setup script creates a large GPU compute pool, and you publish the app on a listing with a recurring subscription plan. Once a consumer installs the app and it runs, who pays for the compute pool credits?
Infrastructure costs, including compute pools, are billed to the consumer's account whatever pricing plan the listing uses. A subscription doesn't cover those credits. It only means the provider can't add a surcharge on top of them, and the credits are charged whether or not there is a surcharge.
“All infrastructure costs, including those related to compute pools, warehouse compute, storage, and data transfer are the responsibility of the consumer”Source: docs.snowflake.com
Checkpoint 5 of 9· Exam question
A provider publishes a Snowflake Native App with Snowpark Container Services to the Marketplace as a subscription-based listing. According to Snowflake's compute pool billing rules, when does SPCS compute usage generate a charge on the consumer's account?
Correct answer: A — Compute pool charges accrue whenever the pool is in the IDLE, ACTIVE, STOPPING, or RESIZING state, but not while STARTING or SUSPENDED
- A. Correct. Compute pools are billed per-second in the IDLE, ACTIVE, STOPPING, or RESIZING states, but incur no charge while STARTING or SUSPENDED.
- B. Incorrect, because Snowflake still bills for the IDLE state even when no container workload is actively executing, not solely during active processing.
- C. Incorrect. Billing is metered per-second based on state and instance configuration, not a flat monthly charge regardless of state.
- D. Incorrect. Compute pool usage is billed to the consumer's account as Snowflake infrastructure cost independent of whether the listing itself is subscription-based or usage-based.
3.Adding a surcharge on the compute pools an app creates
A compute pool surcharge lets the provider charge, per credit, for the pools their app with containers uses. The consumer then pays Snowflake for the credits and pays you a markup on the same credits. The model has strict preconditions, and each one closes a loophole:
- The app uses at least one SPCS container with compute pools, and it is attached to a paid Marketplace listing before you configure surcharges.
- The app creates its own compute pools during installation, with
CREATE COMPUTE POOLin the setup script and the CREATE COMPUTE POOL privilege requested in the manifest. - The app requests its privileges automatically during installation.
- Every pool name is unique and describes the pool's purpose, usage, owner role or app, because the listing identifies pools by name.
The reason for app-created pools shows up when a consumer tries to get around them. If a compute pool is added after setup, for example by the consumer, the listing stops the app from running. Consumer-created pools cannot run an app with containers from a listing, so a consumer cannot dodge the surcharge by bringing their own pool.
Surcharges live in the usage-based plan. In Provider Studio, open the listing, choose Pricing & Trial » Add, select Usage-based, and click + Compute Pool Surcharge once for each pool. Enter the pool name exactly as the app creates it and an amount in USD per credit. A pool you want consumers to see but not pay a markup on gets $0. A Maximum Monthly Charge under Charging Limit is optional here. Preview shows the pricing on the listing page, and Buy on that page shows it as a consumer sees it.
The combination rules are narrow. A surcharge can sit next to a fixed monthly fee, which the surcharge rules call a base charge. It cannot be combined with per-query charges, with Custom Event Billing, or with subscription pricing. Usage is metered every 5 minutes, but the surcharge is calculated per day, only in US dollars. Time-based trials work; usage-based and limited-functionality trials do not. If a listing has both a monthly fee and surcharges, both appear on the invoice, but the monthly fee is missing from the MONETIZED_USAGE_DAILY and MARKETPLACE_DISBURSEMENT_REPORT views.
| CHARGE_TYPE | Meaning |
|---|---|
| SPCS_COMPUTE_POOL_SURCHARGE | The amount of the compute pool surcharge |
| MAX_SPCS_COMPUTE_POOL_SURCHARGE_REACHED | No further charge; the consumer had already reached the maximum surcharge for the listing |
Checkpoint 6 of 9· Check yourself
To avoid paying a provider's compute pool surcharge, a consumer creates their own compute pool after installing a container app from a paid Marketplace listing and tries to run the app's services on it. What happens?
Surcharges require the app to create its own compute pools during installation. If a pool is added after setup, for example by the consumer, the listing blocks the app from running, so bringing your own pool doesn't get around the surcharge.
“If any compute pools are added after setup (for example, by the consumer), the listing prevents the app from running.”Source: docs.snowflake.com
Sources5
4.Emitting billable events with SYSTEM$CREATE_BILLING_EVENT
Custom Event Billing charges for actions your app defines: a procedure call, a row consumed, a row changed, a monthly active row. It takes two halves. The application package emits billable events, and the listing's usage-based plan declares which of those events cost money. The emitting half is code: a stored procedure in JavaScript, Python or Java calls SYSTEM$CREATE_BILLING_EVENT, and you add that procedure to the setup script.
| Parameter | Required | Type and rules |
|---|---|---|
| class | Yes | STRING; starts with a letter or underscore, max 64 characters, must not start with SNOWFLAKE_, resolved as uppercase |
| subclass | No | STRING; same naming rules; used only by the provider |
| start_timestamp | No | INTEGER; UTC Unix milliseconds; set equal to timestamp unless billing a time range |
| timestamp | Yes | Integer; UTC Unix milliseconds when the event was created |
| base_charge | Yes | DOUBLE; USD for this event, greater than zero, less than 99,999.99, at most two decimal places |
| objects | No | STRING; JSON array of fully qualified object names, max 4 KB |
| additional_info | No | STRING; JSON key-value pairs, max 4 KB |
The usual pattern is a helper, createBillingEvent, that wraps the system function and passes arguments of the types it expects, and a procedure that calls the helper at the billable moment. To charge $1.00 per call of a procedure, emit a PROCEDURE_CALL event whose base_charge is the billing quantity:
//
// Send a billable event when a stored procedure is called.
//
var event_ts = Date.now();
var billing_quantity = 1.0;
var base_charge = billing_quantity;
var objects = "[ \"db_1.public.procedure_1\" ]";
var retVal = createBillingEvent("PROCEDURE_CALL", "", event_ts, event_ts, base_charge, objects, "");Volume-based events work the same way, with base_charge computed. A ROWS_CONSUMED event multiplies the row count of a query result by a billing_quantity of 2.5. A monthly-active-rows event first counts the rows not yet updated this calendar month, then multiplies by 0.02. Either way the procedure works out the charge itself and passes it to the function.
Two limits shape the code. SYSTEM$CREATE_BILLING_EVENT is limited to one event per minute. To go faster, batch several events into a JSON array and pass it to SYSTEM$CREATE_BILLING_EVENTS, which also lowers the chance of hitting call limits. And the only supported way to bill is to call the system function from a stored procedure in the app. Working out the charge from a table or UDF that reports consumer activity, or from telemetry in an event table, is not supported.
Checkpoint 7 of 9· Fill the gap
This snippet from your setup script emits a billable event each time a consumer calls a procedure. Which class value fills the blank and is accepted by SYSTEM$CREATE_BILLING_EVENT?
//
// Send a billable event when a stored procedure is called.
//
var event_ts = Date.now();
var billing_quantity = 1.0;
var base_charge = billing_quantity;
var objects = "[ \"db_1.public.procedure_1\" ]";
var retVal = createBillingEvent( ? , "", event_ts, event_ts, base_charge, objects, "");A class must start with a letter or an underscore and must not start with the reserved SNOWFLAKE_ prefix. That rules out the other two options. PROCEDURE_CALL is valid, and it is the class name the listing's billable event must match exactly.
Source: docs.snowflake.com5.Declaring billable events on the listing
Events emitted by the app are only a signal until the listing gives them a price. After the app emits events, open the draft listing in Provider Studio, choose Pricing & Trial » Add, pick Usage-based, and add each event with + Billable Event. If there is no Pricing & Trial section, the application package has not been added to the listing yet. Before you start, you need each class and its billing_quantity from the code.
For each billable event you enter four fields:
- Class must exactly match the class passed to the system function, for example
ROWS_CHANGED. - Event Display Name is what consumers see, such as Row Modified.
- Billing Quantity is the price per event and must match the
billing_quantityused to calculatebase_chargein the code, for example 0.01 to charge $1.00 per 100 modified rows. - Unit Name names the unit being charged, such as row.
A listing can declare up to eight billable events. You are paid only for the events you declare, so an event the app emits but the listing leaves out is never billed. Around the events you write a Description of how the app bills, optionally add a monthly fee and a per-query charge with included free queries, set the required Maximum Monthly Charge, and choose a trial if the listing will be public.
Checkpoint 8 of 9· Match them up
Your app emits a ROWS_CHANGED event that charges $0.01 per modified row. When you add it with + Billable Event on the listing, what goes in each field?
Tap a term, then the definition that fits it.
Class and Billing Quantity have to match the values in the app code. If they don't, the emitted events don't line up with what the listing pays for. Event Display Name and Unit Name only describe the charge to consumers.
“Enter a Class that exactly matches the class defined in the system function for your application.”Source: docs.snowflake.com
Sources1
6.Testing Custom Event Billing before publishing
Billing mistakes cost real money, so test with a real install inside your own organization. Usage inside your organization is not billed by default, so the test is free. You still have to set up a payment method. The loop runs like this:
- Add the billing procedures to the setup script, update the application package, and update the version and release directive.
- Create a private listing, add Custom Event Billing as its pricing plan, and share it with a consumer account in your organization.
- Sign in to that consumer account in Snowsight, install the app, and call the procedures. A
CALL merge_procedure()that returns Success means the code works. - At least two days later, because the view lags, query the paid usage view in the consumer account.
Run the test from the consumer account. The same commands in the provider account that built the application package return an error, because the system function runs only in an installed app. The final check filters on MONETIZABLE_BILLING_EVENTS for your provider account and organization:
SELECT listing_global_name,
listing_display_name,
charge_type,
charge
FROM SNOWFLAKE.DATA_SHARING_USAGE.MARKETPLACE_PAID_USAGE_DAILY
WHERE charge_type='MONETIZABLE_BILLING_EVENTS'
AND PROVIDER_ACCOUNT_NAME = <account_name>
AND PROVIDER_ORGANIZATION_NAME= <organization_name>;A row with a non-zero CHARGE means both halves line up. If the procedure returned Success but no charge appears after two days, look at the listing: a class name or billing quantity that differs from the code is the usual cause. Once the app goes live, in-organization accounts stay unbilled unless you ask Snowflake Support to charge them.
Checkpoint 9 of 9· Put it in order
Before publishing a listing with Custom Event Billing, you test it with a real install inside your own organization. Put the testing steps in the correct order.
- 1.Sign in to that consumer account in Snowsight and install the app from the listing
- 2.Create a private listing, add Custom Event Billing as its pricing plan, and share it with a consumer account in your organization
- 3.Add the billing stored procedures to the setup script, update the application package, and update the version and release directive
- 4.At least two days later, query MARKETPLACE_PAID_USAGE_DAILY in the consumer account for MONETIZABLE_BILLING_EVENTS charges
- 5.From the consumer account, call the billing procedures and confirm they return Success
The system function runs only in an app installed in a consumer account. That means the package has to be updated and shared through a listing before anything can be installed and called. The paid usage view lags, so you check it last, at least two days after you first use the app.
“Due to latency in the view, run these queries at least two days after first using the Snowflake Native App.”Source: docs.snowflake.com
Practise it for real
Prove that a Custom Event Billing setup charges as intended, using a private listing inside your own organization
1.Add a stored procedure that calls createBillingEvent with class PROCEDURE_CALL to the setup script, then update the application package, version and release directive.
Why: The system function only works inside an installed app, so the code has to ship in a release.
You should see: A new version or patch with the billing procedure in the setup script.
2.Create a private listing, add a usage-based Custom Event Billing plan with Class PROCEDURE_CALL and a Billing Quantity matching the code, set a Maximum Monthly Charge, and share it with a consumer account in your organization.
Why: Events are paid only when the listing declares a class and quantity that match the code.
You should see: A saved pricing plan on the private listing; a payment method is required but in-org usage is not charged.
3.Sign in to the consumer account in Snowsight, install the app, and call the billing procedure.
Why: Calls from the provider account return an error.
You should see: The procedure returns Success.
4.After at least two days, query SNOWFLAKE.DATA_SHARING_USAGE.MARKETPLACE_PAID_USAGE_DAILY for charge_type='MONETIZABLE_BILLING_EVENTS' in the consumer account.
Why: The view lags, and it confirms that app and listing agree.
You should see: A row for your listing with a non-zero CHARGE.
Stuck? Get a nudge
If the procedure succeeds but no charge appears, compare the listing's Class and Billing Quantity with the code character by character.
Sources
(7)
Every claim above is drawn from one of these pages, quoted as it was written on the date shown.
- 1.
“As a provider, you cannot remove a pricing plan from a listing.”
↩︎ One pricing plan per listing: usage-based or subscription-based“Only listings that share an application can use Custom Event Billing, which charges based on billable events.”
↩︎ One pricing plan per listing: usage-based or subscription-based“For Snowflake Native App with Snowpark Container Services, a one-time monthly fee is charged when the compute pool runs.”
↩︎ One pricing plan per listing: usage-based or subscription-based“When this maximum monthly charge is reached, subsequent usage, such as queries, is free.”
↩︎ One pricing plan per listing: usage-based or subscription-based“You can choose to offer the listing with recurring billing for a subscription that auto-renews, or non-recurring billing for access for a fixed term.”
↩︎ One pricing plan per listing: usage-based or subscription-based“Listings with this plan cannot be repurchased by consumers.”
↩︎ One pricing plan per listing: usage-based or subscription-based“If you want to charge a monthly fee whether or not consumers use your data product, add a subscription-based plan instead.”
↩︎ One pricing plan per listing: usage-based or subscription-based“Trials are required for listings offered publicly on the Snowflake Marketplace.”
↩︎ One pricing plan per listing: usage-based or subscription-based“The billable event details that you specify in the listing must exactly match the billable events emitted by your application.”
↩︎ Declaring billable events on the listing“You can charge for up to eight (8) billable events.”
↩︎ Declaring billable events on the listing“You are paid only for billable events that you add to your listing”
↩︎ Declaring billable events on the listing“By default, usage within your organization is not billed to allow for testing.”
↩︎ Testing Custom Event Billing before publishing“A provider can attach a single pricing plan to a listing.”
↩︎ Key concept“You are paid only for billable events that you add to your listing”
↩︎ Exam trap 3“Enter a Class that exactly matches the class defined in the system function for your application.”
↩︎ Checkpoint - 2.
“All infrastructure costs, including those related to compute pools, warehouse compute, storage, and data transfer are the responsibility of the consumer”
↩︎ What a container app costs the consumer before any pricing plan - 3.https://docs.snowflake.com/en/developer-guide/snowpark-container-services/accounts-orgs-usage-viewsOfficial docs
“The number and type (instance family) of the nodes in the compute pool (see CREATE COMPUTE POOL) determine the credits it consumes”
↩︎ What a container app costs the consumer before any pricing plan“in the IDLE, ACTIVE, STOPPING, or RESIZING state, but not when it is in a STARTING or SUSPENDED state”
↩︎ What a container app costs the consumer before any pricing plan“in the IDLE, ACTIVE, STOPPING, or RESIZING state, but not when it is in a STARTING or SUSPENDED state”
↩︎ Exam trap 2 - 4.https://docs.snowflake.com/en/developer-guide/snowpark-container-services/working-with-compute-poolOfficial docs
“IDLE: The compute pool has the desired number of virtual machine (VM) nodes, but no services are scheduled.”
↩︎ What a container app costs the consumer before any pricing plan - 5.https://docs.snowflake.com/en/developer-guide/snowpark-container-services/provider-pricing-surchargesOfficial docs
“The app must automatically create its compute pools during installation.”
↩︎ Adding a surcharge on the compute pools an app creates“Consumer-created compute pools cannot run an app with containers from a listing.”
↩︎ Adding a surcharge on the compute pools an app creates“For compute pools that should be displayed but have no surcharge, set this amount to $0.”
↩︎ Adding a surcharge on the compute pools an app creates“Compute pool surcharges are calculated per day, not per hour.”
↩︎ Adding a surcharge on the compute pools an app creates“Usage is metered every 5 minutes.”
↩︎ Adding a surcharge on the compute pools an app creates“You can combine compute pool surcharges with a base charge, but not with any other usage-based pricing model.”
↩︎ Exam trap 1“You can combine compute pool surcharges with a base charge, but not with any other usage-based pricing model.”
↩︎ Prediction“If any compute pools are added after setup (for example, by the consumer), the listing prevents the app from running.”
↩︎ Checkpoint - 6.
“You can call this system function in a stored procedure written in JavaScript, Python, or Java.”
↩︎ Emitting billable events with SYSTEM$CREATE_BILLING_EVENT“Snowflake does not support other methods of calculating the base charge for billable events”
↩︎ Emitting billable events with SYSTEM$CREATE_BILLING_EVENT“When you test Custom Event Billing, you must set up a payment method but you will not be charged for usage within your organization.”
↩︎ Testing Custom Event Billing before publishing“Due to latency in the view, run these queries at least two days after first using the Snowflake Native App.”
↩︎ Testing Custom Event Billing before publishing“Snowflake does not support other methods of calculating the base charge for billable events”
↩︎ Exam trap 4“If you run these SQL commands in the provider account that you used to create the application package, you see an error.”
↩︎ Exam trap 5 - 7.
“If you need to exceed the one event per minute frequency limitation of this system function, use SYSTEM$CREATE_BILLING_EVENTS.”
↩︎ Emitting billable events with SYSTEM$CREATE_BILLING_EVENT“The value must be greater than zero, less than 99,999.99, and must not exceed two decimal places of precision.”
↩︎ Emitting billable events with SYSTEM$CREATE_BILLING_EVENT“This system function can only be called from an application installed in a consumer account.”
↩︎ Emitting billable events with SYSTEM$CREATE_BILLING_EVENT