Organization budgets¶

Organization budgets let you define and track spend across multiple Snowflake accounts within one organization from a single object. Instead of maintaining separate account-level custom budgets for each account, you configure one organization budget and monitor aggregated spend from your org admin account.

Organization budgets support three configurable scope dimensions:

• Accounts: which accounts in the organization are measured.
• Service types: organization usage filtered by service type (for example, AI services).
• Tagged resources: spend on non-shared resources matched by organization tags.

Before you begin¶

Before creating an organization budget, confirm the following:

• Your organization has an organization account set up.
• You have the GLOBALORGADMIN role in the org admin account. In Private Preview, only GLOBALORGADMIN can create and manage organization budgets.
• The ORGANIZATION$DB database is accessible from the org admin account.
• Premium views in the organization account are enabled. Organization budgets depend on organization usage data from these views.
• Organization tags are created and applied to resources before setting resource-tag scope. Each tag used in scope requires the APPLYBUDGET privilege.

Currency¶

Each organization budget measures spend in the organization’s billing currency, derived from the organization’s current billing contract (for example, USD, EUR, GBP). You can’t change the currency of an existing organization budget. If your organization later changes its billing contract and thus its currency, create a new organization budget to track spend in the new currency.

Create an organization budget¶

Organization budget instances must be created in ORGANIZATION$DB under the BUDGETS schema. Custom schemas are currently not allowed.

USE ROLE GLOBALORGADMIN;
USE SCHEMA ORGANIZATION$DB.BUDGETS;

CREATE SNOWFLAKE.CORE.ORG_BUDGET my_org_budget();

After you create the organization budget:

• No spend is tracked until you configure scope for accounts and services (or tags).
• No notifications or custom actions fire until you set a spending limit and configure thresholds.
• Spend data appears after the next refresh. For timing details, see Latency.

Configure scope¶

Scope defines what the organization budget measures. Three procedures let you manage scope:

• ADD_SCOPE: incrementally adds entries to existing scope.
• REMOVE_SCOPE: removes specific entries from existing scope.
• SET_SCOPE: atomically replaces all scope for one or more dimensions.

You can update multiple dimensions in one call by including more than one key in the JSON object argument.

Scope dimensions:

Note that service_types and resource_tags are mutually exclusive. Setting one while the other exists returns an error. To switch between them, clear the existing dimension first using SET_SCOPE.

Account scope¶

Account scope allows you to select which accounts the budget should track. Use ADD_SCOPE and REMOVE_SCOPE to update the list incrementally, or SET_SCOPE to replace the account configuration in one single SQL statement.

Add specific accounts to scope:

Use ADD_SCOPE to incrementally append accounts to the existing inclusion list. This doesn’t replace any accounts already in scope.

CALL my_org_budget!ADD_SCOPE(PARSE_JSON('{"accounts": ["PROD_ACCT_1", "PROD_ACCT_2"]}'));

Remove specific accounts from scope:

Use REMOVE_SCOPE to drop individual accounts from the inclusion list. Accounts not in the list are unaffected.

CALL my_org_budget!REMOVE_SCOPE(PARSE_JSON('{"accounts": ["SANDBOX_1"]}'));

Track all accounts (including future accounts):

Use SET_SCOPE with "all": true to replace the account configuration so that every account in the organization is measured. Accounts added to the organization in the future are automatically included.

CALL my_org_budget!SET_SCOPE(PARSE_JSON('{"accounts": {"all": true}}'));

Track all accounts except specific ones:

Use SET_SCOPE with "all": true and an excluded list to cover the entire organization while carving out specific accounts. New accounts are auto-included unless they appear on the exclusion list.

CALL my_org_budget!SET_SCOPE(PARSE_JSON('{"accounts": {"all": true, "excluded": ["SANDBOX_1", "SANDBOX_2"]}}'));

Replace the account list entirely with a specific set:

Use SET_SCOPE with "all": false and an included list to replace whatever account scope currently exists with an explicit, fixed list. Only the listed accounts are measured.

CALL my_org_budget!SET_SCOPE(PARSE_JSON('{"accounts": {"all": false, "included": ["PROD_ACCT_1", "PROD_ACCT_2"]}}'));

Clear all account scope:

Pass an empty included list to remove all account scope. The budget stops tracking any accounts until scope is reconfigured.

CALL my_org_budget!SET_SCOPE(PARSE_JSON('{"accounts": {"all": false, "included": []}}'));

Service-type scope¶

Service-type scope tracks spend for one or more service types across in-scope accounts.

Add specific service types:

Use ADD_SCOPE to incrementally add service types to the existing list. Service types already in scope are unaffected.

CALL my_org_budget!ADD_SCOPE(PARSE_JSON('{"service_types": ["AI_SERVICES", "WAREHOUSE_METERING"]}'));

Remove specific service types:

Use REMOVE_SCOPE to drop individual service types from the list. Other service types in scope remain.

CALL my_org_budget!REMOVE_SCOPE(PARSE_JSON('{"service_types": ["AI_SERVICES"]}'));

Track all service types:

Use SET_SCOPE with "all": true to replace the service-type configuration so that all service types are measured, including any new service types introduced in the future.

CALL my_org_budget!SET_SCOPE(PARSE_JSON('{"service_types": {"all": true}}'));

Track all service types except specific ones:

Use SET_SCOPE with "all": true and an excluded list to cover all service types while excluding specific ones from spend measurement.

CALL my_org_budget!SET_SCOPE(PARSE_JSON('{"service_types": {"all": true, "excluded": ["AI_SERVICES"]}}'));

Replace the service-type list entirely with a specific set:

Use SET_SCOPE with "all": false and an included list to replace whatever service-type scope currently exists with a fixed list. Only the listed service types contribute to spend measurement.

CALL my_org_budget!SET_SCOPE(PARSE_JSON('{"service_types": {"all": false, "included": ["STORAGE"]}}'));

Resource-tag scope¶

Resource-tag scope tracks spend on non-shared resources matched by organization tags. You can combine multiple tag/value pairs using UNION (match any) or INTERSECTION (match all).

Because the argument includes SYSTEM$REFERENCE calls, use OBJECT_CONSTRUCT and ARRAY_CONSTRUCT to build it rather than PARSE_JSON.

Add one tag/value pair:

Use ADD_SCOPE to incrementally add a tag/value pair to the existing tag scope. Existing pairs are not affected. Pass a reference to the tag using SYSTEM$REFERENCE and specify the tag value you want to match.

CALL my_org_budget!ADD_SCOPE(OBJECT_CONSTRUCT(
  'resource_tags', ARRAY_CONSTRUCT(
    ARRAY_CONSTRUCT(
      (SELECT SYSTEM$REFERENCE('TAG', 'ORG$DB.TAGS.COST_CENTER', 'SESSION', 'APPLYBUDGET')),
      'FINANCE'
    )
  )
));

Remove a specific tag/value pair:

Use REMOVE_SCOPE to drop one tag/value pair from the scope. The pair must match exactly (both tag reference and value). Other pairs in scope remain.

CALL my_org_budget!REMOVE_SCOPE(OBJECT_CONSTRUCT(
  'resource_tags', ARRAY_CONSTRUCT(
    ARRAY_CONSTRUCT(
      (SELECT SYSTEM$REFERENCE('TAG', 'ORG$DB.TAGS.COST_CENTER', 'SESSION', 'APPLYBUDGET')),
      'FINANCE'
    )
  )
));

Replace tag scope with a UNION of tag/value pairs (match any):

Use SET_SCOPE with operator: UNION to track resources that match at least one of the listed tag/value pairs. This atomically replaces all existing tag scope.

CALL my_org_budget!SET_SCOPE(OBJECT_CONSTRUCT(
  'resource_tags', OBJECT_CONSTRUCT(
    'operator', 'UNION',
    'tags', ARRAY_CONSTRUCT(
      ARRAY_CONSTRUCT(
        (SELECT SYSTEM$REFERENCE('TAG', 'ORG$DB.TAGS.COST_CENTER', 'SESSION', 'APPLYBUDGET')),
        'FINANCE'
      ),
      ARRAY_CONSTRUCT(
        (SELECT SYSTEM$REFERENCE('TAG', 'ORG$DB.TAGS.ENV', 'SESSION', 'APPLYBUDGET')),
        'PROD'
      )
    )
  )
));

Replace tag scope with an INTERSECTION of tag/value pairs (match all):

Use SET_SCOPE with operator: INTERSECTION to track only resources that match every listed tag/value pair simultaneously. This atomically replaces all existing tag scope.

CALL my_org_budget!SET_SCOPE(OBJECT_CONSTRUCT(
  'resource_tags', OBJECT_CONSTRUCT(
    'operator', 'INTERSECTION',
    'tags', ARRAY_CONSTRUCT(
      ARRAY_CONSTRUCT(
        (SELECT SYSTEM$REFERENCE('TAG', 'ORG$DB.TAGS.COST_CENTER', 'SESSION', 'APPLYBUDGET')),
        'FINANCE'
      ),
      ARRAY_CONSTRUCT(
        (SELECT SYSTEM$REFERENCE('TAG', 'ORG$DB.TAGS.ENV', 'SESSION', 'APPLYBUDGET')),
        'PROD'
      )
    )
  )
));

Clear all tag scope:

Pass an empty tags array to remove all tag scope from the budget. Use this before switching to service-type scope, since the two dimensions are mutually exclusive.

CALL my_org_budget!SET_SCOPE(OBJECT_CONSTRUCT(
  'resource_tags', OBJECT_CONSTRUCT(
    'operator', 'UNION',
    'tags', ARRAY_CONSTRUCT()
  )
));

Combine dimensions in a single call¶

ADD_SCOPE, REMOVE_SCOPE, and SET_SCOPE all accept multiple dimension keys in one JSON argument, letting you update accounts and service types atomically.

Add accounts and service types in one call:

Include both keys in the same JSON argument to update multiple dimensions at once. Both additions are applied atomically: no intermediate state is visible.

CALL my_org_budget!ADD_SCOPE(PARSE_JSON('{
    "accounts":      ["PROD_ACCT_1", "PROD_ACCT_2"],
    "service_types": ["WAREHOUSE_METERING", "AI_SERVICES"]
}'));

Replace both dimensions atomically:

Use SET_SCOPE with multiple keys to replace both account and service-type scope in a single call. The entire scope configuration is swapped at once, so there’s no window where only one dimension is updated.

CALL my_org_budget!SET_SCOPE(PARSE_JSON('{
    "accounts":      {"all": true, "excluded": ["SANDBOX_ACCT"]},
    "service_types": {"all": false, "included": ["STORAGE"]}
}'));

Read current scope:

Use GET_ORG_BUDGET_SCOPE at any time to inspect the full scope configuration across all active dimensions. The output reflects the current state regardless of which scope mode the budget is in.

CALL my_org_budget!GET_ORG_BUDGET_SCOPE();

Set a spending limit¶

Set the organization-level spending limit in the organization’s billing currency. The limit must be a positive number. The limit is required before notifications or custom actions can fire.

CALL my_org_budget!SET_SPENDING_LIMIT(10000);

Check the current limit:

Use GET_SPENDING_LIMIT to retrieve the currently configured spending limit. This is also available in GET_CONFIG alongside other budget settings.

CALL my_org_budget!GET_SPENDING_LIMIT();

View configuration¶

GET_CONFIG returns the current configuration of an organization budget instance in a single row.

CALL my_org_budget!GET_CONFIG();

Output columns:

Example output:

Configure notifications¶

Organization budgets send email alerts when actual or projected spend crosses a configured threshold.

Add notification thresholds¶

Each threshold policy combines a percentage of the spending limit with a spend strategy (ACTUAL or PROJECTED).

-- Notify when actual spend reaches 80% of the limit
CALL my_org_budget!ADD_NOTIFICATION_THRESHOLD(80, 'ACTUAL');

-- Notify when projected spend is expected to reach 100% of the limit
CALL my_org_budget!ADD_NOTIFICATION_THRESHOLD(100, 'PROJECTED');

-- View configured thresholds
CALL my_org_budget!GET_NOTIFICATION_THRESHOLDS();

-- Remove a threshold
CALL my_org_budget!REMOVE_NOTIFICATION_THRESHOLD(80, 'ACTUAL');

Set up email notifications¶

Email notifications are deduplicated: at most one email fires per 24 hours.

CALL my_org_budget!SET_EMAIL_NOTIFICATIONS('admin@example.com, finops@example.com');
CALL my_org_budget!GET_NOTIFICATION_EMAIL();

Mute notifications¶

Use SET_NOTIFICATION_MUTE_FLAG to suppress all email alerts without removing your threshold configuration. This is useful during planned maintenance windows or testing. Set the flag back to FALSE to re-enable notifications.

-- Mute all notifications
CALL my_org_budget!SET_NOTIFICATION_MUTE_FLAG(TRUE);

-- Re-enable notifications
CALL my_org_budget!SET_NOTIFICATION_MUTE_FLAG(FALSE);

Configure custom actions¶

Custom actions are stored procedures that run when organization spend crosses a threshold. Up to 10 custom actions per organization budget instance are supported. Custom actions run only in the org admin account; a trigger can’t run a procedure in a non-organization account. Remote account execution isn’t supported in Private Preview.

CALL my_org_budget!ADD_CUSTOM_ACTION(
  '<stored_procedure_ref>',
  <sp_args_array>,
  'PROJECTED',
  90
);

-- View configured actions
CALL my_org_budget!GET_CUSTOM_ACTIONS();

-- Remove an action at a given threshold
CALL my_org_budget!REMOVE_CUSTOM_ACTION(90);

Configure a cycle-start action¶

A cycle-start action runs once at the start of each UTC calendar month, independent of threshold evaluation. Use it to reset state between billing cycles (for example, re-enable suspended resources or send a summary notification).

The procedure must be created in a database that the SNOWFLAKE application can access, and you must grant the SNOWFLAKE application USAGE on the database, schema, and procedure before calling SET_CYCLE_START_ACTION.

Step 1: Create the stored procedure.

Create a stored procedure with EXECUTE AS OWNER so it runs with the owner’s privileges when triggered by the organization budget:

CREATE OR REPLACE PROCEDURE my_db.public.my_reset_proc()
  RETURNS VARCHAR
  LANGUAGE SQL
  EXECUTE AS OWNER
AS
BEGIN
  RETURN 'Cycle start action executed at ' || CURRENT_TIMESTAMP()::VARCHAR;
END;

Step 2: Grant the SNOWFLAKE application access to the procedure.

The organization budget runs as the SNOWFLAKE application. Grant it USAGE on the database, schema, and procedure so it can invoke the stored procedure at cycle start:

GRANT USAGE ON DATABASE my_db TO APPLICATION SNOWFLAKE;
GRANT USAGE ON SCHEMA my_db.public TO APPLICATION SNOWFLAKE;
GRANT USAGE ON PROCEDURE my_db.public.my_reset_proc() TO APPLICATION SNOWFLAKE;

Step 3: Set the cycle-start action.

Pass a SYSTEM$REFERENCE to the procedure and an ARRAY_CONSTRUCT() for the arguments. An empty array is correct when the procedure takes no parameters:

CALL my_org_budget!SET_CYCLE_START_ACTION(
  SYSTEM$REFERENCE('PROCEDURE', 'my_db.public.my_reset_proc()'),
  ARRAY_CONSTRUCT()
);

Check the configured action:

CALL my_org_budget!GET_CYCLE_START_ACTION();

Remove the cycle-start action:

CALL my_org_budget!REMOVE_CYCLE_START_ACTION();

View spending history¶

Use GET_SPENDING_HISTORY to view organization-level spend over time. The shape of the output depends on how your budget is scoped.

-- All history for the current cycle
CALL my_org_budget!GET_SPENDING_HISTORY();

-- History for a specific date range
CALL my_org_budget!GET_SPENDING_HISTORY('2026-07-01', '2026-07-31');

Output columns common to all scope modes:

Service-type mode only:

Resource-tag mode only:

In resource-tag mode, results show daily totals per usage date with no per-service-type breakdown. To inspect which resources are being tracked, use GET_ORG_BUDGET_SCOPE.

Usage refresh¶

Organization budget spend is evaluated by an internal measurement task. By default, the refresh interval is up to 6 hours (TIER_6H). You can set a low latency refresh tier (TIER_1H) when you create or edit the budget.

-- Set a refresh tier (for example, TIER_1H for low latency mode)
CALL my_org_budget!SET_REFRESH_TIER('<tier>');

-- Trigger an on-demand refresh
CALL my_org_budget!REFRESH_USAGE();

For details on when spend first appears and when account-level changes show up in the organization budget, see Latency.

Latency¶

Organization budget spend data isn’t available immediately after you create a budget or change scope. Timing depends on the active refresh interval (TIER_6H by default, or TIER_1H if you set low latency refresh mode).

• First spend data after create: After you create a budget and configure scope, spend data appears after the next successful refresh (within the active refresh interval).
• Account-level changes: Usage and configuration changes in member accounts are reflected in the organization budget after the next refresh.
• Account-to-organization sync delay: Data from the account level can take up to 10 minutes to be reflected at the organization level, so organization and account budget figures may not match exactly at the same point in time.

Cost¶

Organization budgets run as cloud services compute. The cost is expected to be minimal for most organizations. The active refresh tier affects compute cost: switching from the default 6-hour tier to the 1-hour low latency tier increases compute cost by a factor of approximately 12.

To see the compute credits consumed by each organization budget instance in the current month, query SERVERLESS_TASK_HISTORY joined to CLASS_INSTANCES in SNOWFLAKE.ACCOUNT_USAGE:

WITH costs AS (
  SELECT instance_id, credits_used, start_time
    FROM snowflake.account_usage.serverless_task_history
    WHERE start_time >= DATE_TRUNC('month', CURRENT_TIMESTAMP())
      AND instance_id IS NOT NULL)
SELECT ci.name, ci.schema_name, ci.database_name,
       SUM(costs.credits_used)                                            AS total_credits,
       AVG(costs.credits_used)                                            AS avg_credits,
       PERCENTILE_CONT(0.50) WITHIN GROUP (ORDER BY costs.credits_used)  AS p50_credits,
       PERCENTILE_CONT(0.95) WITHIN GROUP (ORDER BY costs.credits_used)  AS p95_credits,
       COUNT(*)                                                           AS task_runs
FROM snowflake.account_usage.class_instances ci
  JOIN costs ON costs.instance_id = ci.id
WHERE class_name = 'ORG_BUDGET' AND class_database_name = 'SNOWFLAKE' AND deleted IS NULL
GROUP BY ci.name, ci.schema_name, ci.database_name
ORDER BY avg_credits DESC;

List organization budgets¶

You can list organization budgets with either of the following:

SHOW SNOWFLAKE.CORE.ORG_BUDGET IN ACCOUNT; -- returns a tabular view
SELECT SYSTEM$SHOW_ORG_BUDGETS_IN_ACCOUNT(); -- returns a JSON list

The result is filtered based on the calling role’s privileges:

• GLOBALORGADMIN: sees all organization budgets in the organization.
• Custom role with a VIEWER or ADMIN instance role: sees only the specific budgets for which that role has been granted an instance role. Grants on one budget don’t expose other budgets, and the filter applies even through inherited role hierarchies.
• Role with no organization budget instance role: returns an empty result.

SHOW SNOWFLAKE.CORE.ORG_BUDGET IN ACCOUNT returns one row per organization budget instance visible to the current role. Example output:

SYSTEM$SHOW_ORG_BUDGETS_IN_ACCOUNT returns a JSON array of the same organization budget instances visible to the current role from the org admin account.

-- All org budgets in this account, flattened into a readable table
WITH raw AS (
    SELECT PARSE_JSON(SYSTEM$SHOW_ORG_BUDGETS_IN_ACCOUNT()) AS payload
)
SELECT
    b.value:NAME::string            AS name,
    b.value:DATABASE::string        AS database,
    b.value:SCHEMA::string          AS schema,
    b.value:CURRENT_VERSION::string AS current_version,
    b.value:SCOPE:accounts:all::boolean      AS accounts_all,
    ARRAY_TO_STRING(COALESCE(b.value:SCOPE:accounts:included,
                             b.value:SCOPE:accounts:excluded), ', ')      AS accounts_list,
    b.value:SCOPE:service_types:all::boolean AS service_types_all,
    ARRAY_TO_STRING(COALESCE(b.value:SCOPE:service_types:included,
                             b.value:SCOPE:service_types:excluded), ', ') AS service_types_list,
    b.value:SCOPE:resource_tags:operator::string AS tags_operator,
    b.value:SCOPE:resource_tags:tags             AS resource_tags,
    b.value:ORG_BUDGET_PROPERTIES                AS properties
FROM raw, LATERAL FLATTEN(input => raw.payload) b
ORDER BY name;

Roles and privileges¶

GLOBALORGADMIN has full access to create, configure, view, and drop organization budgets. You can also delegate read-only or read-write access to custom roles using instance-level roles.

Delegating access to custom roles¶

You can grant read-only or read-write access to specific organization budget instances by granting an instance-level role to a custom role. The custom role also needs USAGE on ORGANIZATION$DB and the BUDGETS schema.

-- Read-only access (all GET_* methods)
GRANT SNOWFLAKE.CORE.ORG_BUDGET ROLE <db>.<schema>.<budget_name>!VIEWER
    TO ROLE <custom_role>;

-- Read-write access (all GET_* and SET_*/ADD_*/REMOVE_* methods)
GRANT SNOWFLAKE.CORE.ORG_BUDGET ROLE <db>.<schema>.<budget_name>!ADMIN
    TO ROLE <custom_role>;

-- Required database and schema access
GRANT USAGE ON DATABASE ORGANIZATION$DB TO ROLE <custom_role>;
GRANT USAGE ON SCHEMA ORGANIZATION$DB.BUDGETS TO ROLE <custom_role>;

The following table summarizes what each instance role can do:

Instance roles are per-budget: a grant on one budget doesn’t give access to any other budget. Role hierarchy is respected, so a parent role inherits instance roles granted to any of its child roles.

Delegating budget creation to custom roles¶

To let a custom role create organization budgets (without granting GLOBALORGADMIN), grant both of the following:

-- Database role that enables budget creation
GRANT DATABASE ROLE SNOWFLAKE.ORG_BUDGET_CREATOR TO ROLE <custom_role>;

-- Privilege on the schema where the budget will be created
GRANT CREATE SNOWFLAKE.CORE.ORG_BUDGET ON SCHEMA ORGANIZATION$DB.BUDGETS
    TO ROLE <custom_role>;

-- Required database and schema access
GRANT USAGE ON DATABASE ORGANIZATION$DB TO ROLE <custom_role>;
GRANT USAGE ON SCHEMA ORGANIZATION$DB.BUDGETS TO ROLE <custom_role>;

A custom role with these grants can create and drop only the budgets it owns. It can’t drop budgets owned by other roles.

Required roles and privileges reference¶

The following table lists all the privileges and roles relevant to organization budgets, with the operations each one enables.

Limitations¶

The following features aren’t supported in Private Preview:

• Shared-resource tracking (SET_USER_TAGS, ADD_SHARED_RESOURCE).
• Credit-based spending limits. Limits use the organization’s billing currency only.
• Custom actions in remote (non-org-admin) accounts.
• Multi-currency rollup across multiple billing contracts.
• Resource-tag scope combined with service-type scope on the same instance.

Usage notes¶

• Organization budgets operate on a monthly cycle aligned to the UTC calendar month, matching account custom budgets.
• No spend is tracked until scope is configured. Notifications and actions require a spending limit and threshold to be set first.
• The spending limit must be a positive number.
• Setting service-type scope while resource-tag scope exists, or vice versa, returns an error. Clear the existing dimension with SET_SCOPE before switching.
• In resource-tag mode, inspecting which resources are tracked requires GET_ORG_BUDGET_SCOPE or GET_LINKED_RESOURCES_BY_TAG. Spending history doesn’t include a per-service-type breakdown in this mode.
• Explicit account and service-type lists are capped at 1,000 entries. Use {"all": true} or {"all": true, "excluded": [...]} for larger organizations.
• If your organization’s billing currency changes, create a new organization budget. An existing instance keeps its original currency and can’t be updated.
• In resource-tag mode, tagged storage spend is tracked at the account level, not at the database level. Tags applied to individual databases aren’t used to attribute storage costs.