Configure GCP Service Quota Overrides

The gcp:serviceusage/consumerQuotaOverride:ConsumerQuotaOverride resource, part of the Pulumi GCP provider, applies consumer-initiated quota limits to reduce a project’s own quota usage below service defaults. This guide focuses on three capabilities: project-wide quota reduction, regional scoping, and custom dimension targeting.

Consumer overrides reference existing GCP projects and enabled services. The metric and limit values must match the service’s quota structure, typically requiring URL encoding. The examples are intentionally small. Combine them with your own project configuration and quota monitoring.

Set a project-wide quota limit for API requests

Teams managing API usage often reduce quota limits below defaults to control costs or prevent runaway consumption.

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
import * as std from "@pulumi/std";

const myProject = new gcp.organizations.Project("my_project", {
    name: "tf-test-project",
    projectId: "quota",
    orgId: "123456789",
    deletionPolicy: "DELETE",
});
const override = new gcp.serviceusage.ConsumerQuotaOverride("override", {
    project: myProject.projectId,
    service: "servicemanagement.googleapis.com",
    metric: std.urlencode({
        input: "servicemanagement.googleapis.com/default_requests",
    }).then(invoke => invoke.result),
    limit: std.urlencode({
        input: "/min/project",
    }).then(invoke => invoke.result),
    overrideValue: "95",
    force: true,
});

import pulumi
import pulumi_gcp as gcp
import pulumi_std as std

my_project = gcp.organizations.Project("my_project",
    name="tf-test-project",
    project_id="quota",
    org_id="123456789",
    deletion_policy="DELETE")
override = gcp.serviceusage.ConsumerQuotaOverride("override",
    project=my_project.project_id,
    service="servicemanagement.googleapis.com",
    metric=std.urlencode(input="servicemanagement.googleapis.com/default_requests").result,
    limit=std.urlencode(input="/min/project").result,
    override_value="95",
    force=True)

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/organizations"
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/serviceusage"
	"github.com/pulumi/pulumi-std/sdk/go/std"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		myProject, err := organizations.NewProject(ctx, "my_project", &organizations.ProjectArgs{
			Name:           pulumi.String("tf-test-project"),
			ProjectId:      pulumi.String("quota"),
			OrgId:          pulumi.String("123456789"),
			DeletionPolicy: pulumi.String("DELETE"),
		})
		if err != nil {
			return err
		}
		invokeUrlencode, err := std.Urlencode(ctx, &std.UrlencodeArgs{
			Input: "servicemanagement.googleapis.com/default_requests",
		}, nil)
		if err != nil {
			return err
		}
		invokeUrlencode1, err := std.Urlencode(ctx, &std.UrlencodeArgs{
			Input: "/min/project",
		}, nil)
		if err != nil {
			return err
		}
		_, err = serviceusage.NewConsumerQuotaOverride(ctx, "override", &serviceusage.ConsumerQuotaOverrideArgs{
			Project:       myProject.ProjectId,
			Service:       pulumi.String("servicemanagement.googleapis.com"),
			Metric:        pulumi.String(invokeUrlencode.Result),
			Limit:         pulumi.String(invokeUrlencode1.Result),
			OverrideValue: pulumi.String("95"),
			Force:         pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
using Std = Pulumi.Std;

return await Deployment.RunAsync(() => 
{
    var myProject = new Gcp.Organizations.Project("my_project", new()
    {
        Name = "tf-test-project",
        ProjectId = "quota",
        OrgId = "123456789",
        DeletionPolicy = "DELETE",
    });

    var @override = new Gcp.ServiceUsage.ConsumerQuotaOverride("override", new()
    {
        Project = myProject.ProjectId,
        Service = "servicemanagement.googleapis.com",
        Metric = Std.Urlencode.Invoke(new()
        {
            Input = "servicemanagement.googleapis.com/default_requests",
        }).Apply(invoke => invoke.Result),
        Limit = Std.Urlencode.Invoke(new()
        {
            Input = "/min/project",
        }).Apply(invoke => invoke.Result),
        OverrideValue = "95",
        Force = true,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.organizations.Project;
import com.pulumi.gcp.organizations.ProjectArgs;
import com.pulumi.gcp.serviceusage.ConsumerQuotaOverride;
import com.pulumi.gcp.serviceusage.ConsumerQuotaOverrideArgs;
import com.pulumi.std.StdFunctions;
import com.pulumi.std.inputs.UrlencodeArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var myProject = new Project("myProject", ProjectArgs.builder()
            .name("tf-test-project")
            .projectId("quota")
            .orgId("123456789")
            .deletionPolicy("DELETE")
            .build());

        var override = new ConsumerQuotaOverride("override", ConsumerQuotaOverrideArgs.builder()
            .project(myProject.projectId())
            .service("servicemanagement.googleapis.com")
            .metric(StdFunctions.urlencode(UrlencodeArgs.builder()
                .input("servicemanagement.googleapis.com/default_requests")
                .build()).result())
            .limit(StdFunctions.urlencode(UrlencodeArgs.builder()
                .input("/min/project")
                .build()).result())
            .overrideValue("95")
            .force(true)
            .build());

    }
}

resources:
  myProject:
    type: gcp:organizations:Project
    name: my_project
    properties:
      name: tf-test-project
      projectId: quota
      orgId: '123456789'
      deletionPolicy: DELETE
  override:
    type: gcp:serviceusage:ConsumerQuotaOverride
    properties:
      project: ${myProject.projectId}
      service: servicemanagement.googleapis.com
      metric:
        fn::invoke:
          function: std:urlencode
          arguments:
            input: servicemanagement.googleapis.com/default_requests
          return: result
      limit:
        fn::invoke:
          function: std:urlencode
          arguments:
            input: /min/project
          return: result
      overrideValue: '95'
      force: true

The service property identifies which API’s quotas you’re overriding. The metric specifies the exact quota counter (e.g., default_requests), and the limit defines the scope (e.g., /min/project for per-minute, per-project limits). The overrideValue sets the new limit; the force flag bypasses the 10% reduction safety check.

Limit regional compute resources with dimensions

Compute quotas often apply per region, requiring you to specify which region’s limit you’re overriding.

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
import * as std from "@pulumi/std";

const myProject = new gcp.organizations.Project("my_project", {
    name: "tf-test-project",
    projectId: "quota",
    orgId: "123456789",
    deletionPolicy: "DELETE",
});
const override = new gcp.serviceusage.ConsumerQuotaOverride("override", {
    dimensions: {
        region: "us-central1",
    },
    project: myProject.projectId,
    service: "compute.googleapis.com",
    metric: std.urlencode({
        input: "compute.googleapis.com/n2_cpus",
    }).then(invoke => invoke.result),
    limit: std.urlencode({
        input: "/project/region",
    }).then(invoke => invoke.result),
    overrideValue: "8",
    force: true,
});

import pulumi
import pulumi_gcp as gcp
import pulumi_std as std

my_project = gcp.organizations.Project("my_project",
    name="tf-test-project",
    project_id="quota",
    org_id="123456789",
    deletion_policy="DELETE")
override = gcp.serviceusage.ConsumerQuotaOverride("override",
    dimensions={
        "region": "us-central1",
    },
    project=my_project.project_id,
    service="compute.googleapis.com",
    metric=std.urlencode(input="compute.googleapis.com/n2_cpus").result,
    limit=std.urlencode(input="/project/region").result,
    override_value="8",
    force=True)

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/organizations"
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/serviceusage"
	"github.com/pulumi/pulumi-std/sdk/go/std"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		myProject, err := organizations.NewProject(ctx, "my_project", &organizations.ProjectArgs{
			Name:           pulumi.String("tf-test-project"),
			ProjectId:      pulumi.String("quota"),
			OrgId:          pulumi.String("123456789"),
			DeletionPolicy: pulumi.String("DELETE"),
		})
		if err != nil {
			return err
		}
		invokeUrlencode, err := std.Urlencode(ctx, &std.UrlencodeArgs{
			Input: "compute.googleapis.com/n2_cpus",
		}, nil)
		if err != nil {
			return err
		}
		invokeUrlencode1, err := std.Urlencode(ctx, &std.UrlencodeArgs{
			Input: "/project/region",
		}, nil)
		if err != nil {
			return err
		}
		_, err = serviceusage.NewConsumerQuotaOverride(ctx, "override", &serviceusage.ConsumerQuotaOverrideArgs{
			Dimensions: pulumi.StringMap{
				"region": pulumi.String("us-central1"),
			},
			Project:       myProject.ProjectId,
			Service:       pulumi.String("compute.googleapis.com"),
			Metric:        pulumi.String(invokeUrlencode.Result),
			Limit:         pulumi.String(invokeUrlencode1.Result),
			OverrideValue: pulumi.String("8"),
			Force:         pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
using Std = Pulumi.Std;

return await Deployment.RunAsync(() => 
{
    var myProject = new Gcp.Organizations.Project("my_project", new()
    {
        Name = "tf-test-project",
        ProjectId = "quota",
        OrgId = "123456789",
        DeletionPolicy = "DELETE",
    });

    var @override = new Gcp.ServiceUsage.ConsumerQuotaOverride("override", new()
    {
        Dimensions = 
        {
            { "region", "us-central1" },
        },
        Project = myProject.ProjectId,
        Service = "compute.googleapis.com",
        Metric = Std.Urlencode.Invoke(new()
        {
            Input = "compute.googleapis.com/n2_cpus",
        }).Apply(invoke => invoke.Result),
        Limit = Std.Urlencode.Invoke(new()
        {
            Input = "/project/region",
        }).Apply(invoke => invoke.Result),
        OverrideValue = "8",
        Force = true,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.organizations.Project;
import com.pulumi.gcp.organizations.ProjectArgs;
import com.pulumi.gcp.serviceusage.ConsumerQuotaOverride;
import com.pulumi.gcp.serviceusage.ConsumerQuotaOverrideArgs;
import com.pulumi.std.StdFunctions;
import com.pulumi.std.inputs.UrlencodeArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var myProject = new Project("myProject", ProjectArgs.builder()
            .name("tf-test-project")
            .projectId("quota")
            .orgId("123456789")
            .deletionPolicy("DELETE")
            .build());

        var override = new ConsumerQuotaOverride("override", ConsumerQuotaOverrideArgs.builder()
            .dimensions(Map.of("region", "us-central1"))
            .project(myProject.projectId())
            .service("compute.googleapis.com")
            .metric(StdFunctions.urlencode(UrlencodeArgs.builder()
                .input("compute.googleapis.com/n2_cpus")
                .build()).result())
            .limit(StdFunctions.urlencode(UrlencodeArgs.builder()
                .input("/project/region")
                .build()).result())
            .overrideValue("8")
            .force(true)
            .build());

    }
}

resources:
  myProject:
    type: gcp:organizations:Project
    name: my_project
    properties:
      name: tf-test-project
      projectId: quota
      orgId: '123456789'
      deletionPolicy: DELETE
  override:
    type: gcp:serviceusage:ConsumerQuotaOverride
    properties:
      dimensions:
        region: us-central1
      project: ${myProject.projectId}
      service: compute.googleapis.com
      metric:
        fn::invoke:
          function: std:urlencode
          arguments:
            input: compute.googleapis.com/n2_cpus
          return: result
      limit:
        fn::invoke:
          function: std:urlencode
          arguments:
            input: /project/region
          return: result
      overrideValue: '8'
      force: true

The dimensions property targets specific quota scopes. Here, region: “us-central1” limits N2 CPUs in that region only. The metric and limit follow the same URL-encoded format, but the limit path includes /region to indicate regional scoping.

Apply overrides to custom quota dimensions

Some services define custom dimensions beyond region or zone, like per-author limits in the Library Agent API.

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
import * as std from "@pulumi/std";

const myProject = new gcp.organizations.Project("my_project", {
    name: "tf-test-project",
    projectId: "quota",
    orgId: "123456789",
    deletionPolicy: "DELETE",
});
const override = new gcp.serviceusage.ConsumerQuotaOverride("override", {
    project: myProject.projectId,
    service: "libraryagent.googleapis.com",
    metric: std.urlencode({
        input: "libraryagent.googleapis.com/borrows",
    }).then(invoke => invoke.result),
    limit: std.urlencode({
        input: "/author/project",
    }).then(invoke => invoke.result),
    overrideValue: "1",
    force: true,
    dimensions: {
        author: "larry",
    },
});

import pulumi
import pulumi_gcp as gcp
import pulumi_std as std

my_project = gcp.organizations.Project("my_project",
    name="tf-test-project",
    project_id="quota",
    org_id="123456789",
    deletion_policy="DELETE")
override = gcp.serviceusage.ConsumerQuotaOverride("override",
    project=my_project.project_id,
    service="libraryagent.googleapis.com",
    metric=std.urlencode(input="libraryagent.googleapis.com/borrows").result,
    limit=std.urlencode(input="/author/project").result,
    override_value="1",
    force=True,
    dimensions={
        "author": "larry",
    })

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/organizations"
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/serviceusage"
	"github.com/pulumi/pulumi-std/sdk/go/std"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		myProject, err := organizations.NewProject(ctx, "my_project", &organizations.ProjectArgs{
			Name:           pulumi.String("tf-test-project"),
			ProjectId:      pulumi.String("quota"),
			OrgId:          pulumi.String("123456789"),
			DeletionPolicy: pulumi.String("DELETE"),
		})
		if err != nil {
			return err
		}
		invokeUrlencode, err := std.Urlencode(ctx, &std.UrlencodeArgs{
			Input: "libraryagent.googleapis.com/borrows",
		}, nil)
		if err != nil {
			return err
		}
		invokeUrlencode1, err := std.Urlencode(ctx, &std.UrlencodeArgs{
			Input: "/author/project",
		}, nil)
		if err != nil {
			return err
		}
		_, err = serviceusage.NewConsumerQuotaOverride(ctx, "override", &serviceusage.ConsumerQuotaOverrideArgs{
			Project:       myProject.ProjectId,
			Service:       pulumi.String("libraryagent.googleapis.com"),
			Metric:        pulumi.String(invokeUrlencode.Result),
			Limit:         pulumi.String(invokeUrlencode1.Result),
			OverrideValue: pulumi.String("1"),
			Force:         pulumi.Bool(true),
			Dimensions: pulumi.StringMap{
				"author": pulumi.String("larry"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
using Std = Pulumi.Std;

return await Deployment.RunAsync(() => 
{
    var myProject = new Gcp.Organizations.Project("my_project", new()
    {
        Name = "tf-test-project",
        ProjectId = "quota",
        OrgId = "123456789",
        DeletionPolicy = "DELETE",
    });

    var @override = new Gcp.ServiceUsage.ConsumerQuotaOverride("override", new()
    {
        Project = myProject.ProjectId,
        Service = "libraryagent.googleapis.com",
        Metric = Std.Urlencode.Invoke(new()
        {
            Input = "libraryagent.googleapis.com/borrows",
        }).Apply(invoke => invoke.Result),
        Limit = Std.Urlencode.Invoke(new()
        {
            Input = "/author/project",
        }).Apply(invoke => invoke.Result),
        OverrideValue = "1",
        Force = true,
        Dimensions = 
        {
            { "author", "larry" },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.organizations.Project;
import com.pulumi.gcp.organizations.ProjectArgs;
import com.pulumi.gcp.serviceusage.ConsumerQuotaOverride;
import com.pulumi.gcp.serviceusage.ConsumerQuotaOverrideArgs;
import com.pulumi.std.StdFunctions;
import com.pulumi.std.inputs.UrlencodeArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var myProject = new Project("myProject", ProjectArgs.builder()
            .name("tf-test-project")
            .projectId("quota")
            .orgId("123456789")
            .deletionPolicy("DELETE")
            .build());

        var override = new ConsumerQuotaOverride("override", ConsumerQuotaOverrideArgs.builder()
            .project(myProject.projectId())
            .service("libraryagent.googleapis.com")
            .metric(StdFunctions.urlencode(UrlencodeArgs.builder()
                .input("libraryagent.googleapis.com/borrows")
                .build()).result())
            .limit(StdFunctions.urlencode(UrlencodeArgs.builder()
                .input("/author/project")
                .build()).result())
            .overrideValue("1")
            .force(true)
            .dimensions(Map.of("author", "larry"))
            .build());

    }
}

resources:
  myProject:
    type: gcp:organizations:Project
    name: my_project
    properties:
      name: tf-test-project
      projectId: quota
      orgId: '123456789'
      deletionPolicy: DELETE
  override:
    type: gcp:serviceusage:ConsumerQuotaOverride
    properties:
      project: ${myProject.projectId}
      service: libraryagent.googleapis.com
      metric:
        fn::invoke:
          function: std:urlencode
          arguments:
            input: libraryagent.googleapis.com/borrows
          return: result
      limit:
        fn::invoke:
          function: std:urlencode
          arguments:
            input: /author/project
          return: result
      overrideValue: '1'
      force: true
      dimensions:
        author: larry

Custom dimensions let you target service-specific quota scopes. The dimensions property accepts any key-value pairs the service defines. Here, author: “larry” sets a per-author limit. The metric and limit must match the service’s quota structure for custom dimensions.

Beyond these examples

These snippets focus on specific consumer override features: project-wide and regional quota limits, dimensional scoping, and the force flag for large reductions. They’re intentionally minimal rather than full quota management solutions.

The examples reference pre-existing infrastructure such as GCP projects with enabled services, and assume understanding of service-specific quota metrics and limits. They focus on configuring the override rather than provisioning projects or enabling services.

To keep things focused, common quota management patterns are omitted, including:

  • Quota increase requests (consumer overrides only reduce quotas)
  • Admin or producer overrides (require organization-level permissions)
  • Monitoring quota usage before setting overrides
  • Handling override conflicts or validation errors

These omissions are intentional: the goal is to illustrate how each override feature is wired, not provide drop-in quota management modules. See the ConsumerQuotaOverride resource reference for all available configuration options.

Let's configure GCP Service Quota Overrides

Get started with Pulumi Cloud, then follow our quick setup guide to deploy this infrastructure.

Try Pulumi Cloud for FREE

Frequently Asked Questions

Quota Limits & Constraints
Can I use consumer overrides to increase my quota?
No. Consumer overrides are self-imposed limits that can only reduce quota usage. They cannot grant more quota than allowed by admin overrides, producer overrides, or the service’s default limits.
What does setting overrideValue to -1 do?
Setting overrideValue to -1 means unlimited quota (within the constraints of admin/producer overrides and service defaults).
Configuration & Formatting
What format should I use for the limit property?
The limit must not start with 1/ or contain curly braces. For example, use /project/user instead of 1/{project}/{user}.
Why do I need to use urlencode for metric and limit?
Both metric and limit values contain special characters like slashes and dots that need URL encoding. All examples in the schema use std.urlencode for these properties.
Dimensions & Scoping
How do I apply a quota override to a specific region?
Use the dimensions property with a region key, like dimensions: { region: "us-central1" }.
Can I use custom dimension keys besides region?
Yes. You can define custom dimensions like author or other keys specific to your service’s quota dimensions.
Safety & Immutability
What happens if I try to decrease quota by more than 10%?
The request is rejected as a safety check. Set force to true to bypass this protection.
What properties can't I change after creating the override?
The following properties are immutable and require resource recreation if changed: limit, metric, project, service, and dimensions.
What's the difference between metric and limit?
metric identifies what to limit (e.g., compute.googleapis.com/cpus), while limit specifies the scope (e.g., /project/region). Both are required and immutable.

Using a different cloud?

Explore integration guides for other cloud providers:

AWS Guides Azure Guides