# Account and billing 

## Access to your projects 

Empower your account with seamless collaboration and enhanced productivity by creating teams within our platform, where each team allows members to securely access applications within Gadget. Only invite trusted members to your team.

### Creating a team 

Create a team, for your Gadget account:

1.  Navigate to the home page
2.  In the left-hand corner click on **Team**
3.  From the drop-down select **Create New Team**
4.  Enter a name of what you would like to call your **Team**

### Inviting members 

Teams on a paid plan can invite members to their Gadget projects. To invite members please [upgrade to a paid plan](https://app.gadget.dev/auth/team/billing#plans).

1.  Navigate to the main account page
2.  In the top nav, click **Members**
3.  Within the page, click on **Send invite codes**
4.  Enter the email address of the person you would like to invite to your team
5.  Click **Send invites**

### Removing members 

Within your team you can remove team members from your Gadget projects:

1.  Navigate to the main account page
2.  In the top nav, click **Members**
3.  Identify and navigate to the corresponding email address of the team member you would like to remove
4.  Click **Remove**

### Does the contributor need to be on a plan? 

You can externally invite people to your team they do not have to be on a plan. But keep in mind the number of seats available on your plan:

*   **Hobby**: 2 seats max
*   **Pro**: 10 seats max
*   **Premium**: 25 seats max

## Usage and billing 

This page covers general information about resource usage, billing, invoicing and payments. Everyone on Gadget starts on the free Hobby plan, for information on the other plans available see our [pricing page](https://gadget.dev/pricing).

### How is my usage determined? 

Your usage can be viewed on your [usage and billing page](https://app.gadget.dev/auth/team/billing). This page shows the usage of all of your applications within the current monthly billing period, but can also be filtered to show usage per application.

Gadget billing has two types of charges:

1.  directly billed **resource charges**
2.  shared **platform credits**.

### Resource charges 

Resource charges are metered and attributed directly to your app. These cover the core resources your app consumes—storage, compute time, and bandwidth. You pay for exactly what your app uses.

The directly billed resources are:

| Category | Resource | What it measures |
| --- | --- | --- |
| Database | Data storage | GB of database row storage in Postgres |
| Database | Search storage | GB of search index storage in Elasticsearch |
| Database | DB read compute | TB of data read from the Postgres database |
| Database | DB write compute | GB of data written to thePostgres database |
| Database | File storage | GB of GCP file storage |
| Backend | CPU time | Hours of code execution |
| Backend | Concurrency | Max number of requests allowed to run at once |
| Backend | Log ingest | GB of user-written logs that can be ingested |
| Frontend | Edge bandwidth | GB of bandwidth for assets served from edge |

Each plan includes a free tier of these resources. After the included amount is consumed, you pay the overage rate for additional usage. All storage fees are prorated down to the hour—if you store data for only part of the month, you only pay for that time.

For up-to-date included amounts and overage rates, see the [Pricing](https://gadget.dev/pricing) page.

#### How is database storage prorated? 

Rows added to your database occupy a certain amount of disk space in your database. Gadget charges a fixed fee per GB of database data stored per month, with proration down to the hour. Data storage is measured in units of gigabyte months (GB-mth) which is the amount of storage used by a gigabyte of data for a 745-hour month.

For example, if you add 5 GB of database rows right at the start of the month and store the data for the whole month, and your plan's Database Storage price is $1.50 / GB / month beyond the included 3 GB, Gadget will charge you $3.00 at the end of the month for storing that data.

Gadget pro-rates database storage fees. If you only store data for part of the month, or if you add data partway through the month, you'll only be charged for the amount of time you stored the data. For example, if you start the month with 0 GB of data in your file storage, and then add 10 GB of data halfway through the month, Gadget will only charge for having stored the data for half of that month, resulting in a charge for storing 5 GB of data that month.

Data deletion is also prorated. If you start the month with 10 GB in file storage, and delete it all halfway through the month, you'll end up being charged only half the price as if you'd kept the data in storage for the whole month, which amounts to 5 GB of data storage.

Proration is done down to the storage hour in Gadget.

For up-to-date prices of database storage for each plan, see the [Pricing](https://gadget.dev/pricing) page.

#### How is file storage prorated? 

Files added to your app's file fields occupy a certain amount of disk space in cloud storage. Gadget charges a fixed fee per GB of this stored file data per month, prorated down to the hour. File storage is measured in units of gigabyte months (GB-mth) which is the amount of storage used by a gigabyte file for a 745-hour month.

For example, if you add 10 GB of data right at the start of the month, and store the data for the whole month, and your plan's File storage price is $0.05 / GB / month for anything beyond 5 GB, Gadget will charge you $0.25 at the end of the month for storing that data.

Gadget pro-rates file storage fees. If you only store data for part of the month, or if you add data partway through the month, you'll only be charged for the amount of time you stored the data. For example, if you start the month with 0 GB of data in your file storage, and then add 10 GB of data halfway through the month, Gadget will only charge for having stored the data for half of that month, resulting in a charge for storing 5 GB of data that month.

Data deletion is also prorated. If you start the month with 10 GB in file storage, and delete it all halfway through the month, you'll end up being charged only half the price as if you'd kept the data in storage for the whole month, which amounts to 5 GB of data storage.

Proration is done down to the storage hour in Gadget.

For up-to-date prices for each plan, see the [Pricing](https://gadget.dev/pricing) page.

### Platform credits 

Platform credits cover shared Gadget infrastructure that powers your app behind the scenes. This includes services like the background job system, Shopify data sync engine, Shopify webhook filter and idempotency checks, the action scheduler, and Cloudflare's edge network, all of which have internal databases and/or services with associated costs.

Rather than billing dozens of line items for each of these services, Gadget bundles them into a single credit system. This gives you flexibility to use credits however your app needs them—whether that's heavy database operations, lots of background jobs, or frequent Shopify syncs.

Each plan includes a monthly platform credit allowance:

| Plan | Monthly credits |
| --- | --- |
| Hobby | 500K |
| Pro | 1M (+1M per additional production environment) |
| Premium | 5M (+1M per additional production environment) |

After the included credits are consumed, additional credits are charged at $1 per 100K credits. For the full list of operations and their credit costs, see the [Pricing](https://gadget.dev/pricing) page.

#### Platform operations 

Here are the platform operations that are included in your monthly platform credit allowance:

| Category | Operation | Description |
| --- | --- | --- |
| Database | DB read | Any read from the database |
| Database | DB write | Any write to the database |
| Database | Search read | Reads using the `search` API |
| Database | Search write | Writes to fields indexed in Elasticsearch |
| Database | Session request | Requests made by active user sessions |
| Backend | Backend request | Any request processed by your backend, including API calls, routes, syncs, and webhooks |
| Backend | Background enqueue request | `api.enqueue` is called to enqueue a background action |
| Backend | Background action run | When a background action is executed |
| Backend | Scheduler action run | When an action using the Schedule trigger is run |
| Backend | Webhook action run | When a webhook action is executed, including reconciliation dispatches |
| Backend | Filter and idempotency check | Checks incoming Shopify data with existing records and only processes changes |
| Backend | Shopify field fetch | Fetches Shopify fields not included in webhook payloads after a webhook runs |
| Backend | File upload | When a file is uploaded to storage |
| Backend | File download | When a file is downloaded from storage |
| Frontend | Frontend request | Requests made by users to load frontend pages and assets |
| Edge | Edge request | Handled by Cloudflare's global edge network, protecting against attacks and traffic spikes. Requests hit the edge first, respond from cache, or forward to your app |

Exact pricing for each operation can be found on the [Pricing](https://gadget.dev/pricing) page.

#### Why do some items appear in both? 

You may notice that database operations have both directly billed resource charges and platform credit costs for reads and writes. The resource charges cover the direct cost of moving data for your app. The platform credits cover the infrastructure headroom Gadget maintains for instant scaling. For example, when a flash sale hits and your app needs to handle a sudden spike in concurrent requests.

Concurrency demands this headroom more than large individual reads or writes, so platform credits make the cost per-request based rather than requiring you to pre-provision capacity.

### Observability 

Observability features show how your app behaves over time with ops data, logs, and background job history. For up to date retention periods, see the [Pricing](https://gadget.dev/pricing) page.

### App installations 

Your app installation count is the number of times your app is installed on a Shopify or BigCommerce store. Installs on both development and production environments are included in this count.

Users on the free Hobby tier get up to 5 app installations. If a user goes over the installation limit, Gadget will block additional installations until a new payment plan is selected.

Paid users on Pro and Premium plans are allowed unlimited app installations at no extra cost. Unlike the other metrics listed above, app installs are not tracked on the Usage page. For up-to-date limits on app installations, see the [Pricing](https://gadget.dev/pricing) page.

### Project add-ons 

Gadget sells additional products and services for an additional fee, per project that they are applied to:

*   **Remove cold starts**: Keeps API workers warm to eliminate cold starts and speed up requests. This helps with LCP.
*   **Smart CDN**: Deploys assets to global edge network ensuring that they are served from locations closest to your users.
*   **Custom domains** (free): Serves your app from a custom domain for a branded experience.

To add these to your project and for pricing information, visit your app's **Settings** > **Add-ons** page. See our docs for more information on adding a [custom domain](https://docs.gadget.dev/guides/environments/custom-domains).

### Production environment customizations 

You can modify some of the underlying infrastructure of your production environment to better suit your needs, and adjust the rates for the resources you use.

#### Surge compute 

Surge compute allows your production environment to temporarily exceed its included rate limits during traffic spikes. When surge compute is enabled, high-priority requests will be allowed to exceed the platform limits for short bursts of traffic.

When surge compute is disabled, any requests above your app's rate limit will return a `429 Rate Limit Exceeded` error.

Surge compute is enabled by default.

**Foreground and background requests**

Gadget distinguishes between foreground and background requests when applying rate limits and surge compute:

*   **Foreground requests** are synchronous API requests that run immediately when received, including requests from browsers and external services as well as `api.*` calls made inside your action code. You can see these broken down as **External** and **Internal** on the [operations dashboard](https://docs.gadget.dev/guides/development-tools/operations-dashboard#request-rate-limit-usage).
*   **Background requests** are asynchronous actions enqueued with `api.enqueue()`. Gadget automatically [throttles background action concurrency](https://docs.gadget.dev/guides/development-tools/rate-limits#background-action-throttling) to preserve rate limit capacity for foreground requests. With `high` priority, background actions are allowed to keep running even when the environment is surging, provided surge compute is enabled on the production environment.

All request types share the same rate limit pool and can cause surging if the base rate limit is exhausted. See the [rate limits guide](https://docs.gadget.dev/guides/development-tools/rate-limits) for details on how requests are counted and throttled.

**High-priority requests include:**

*   All foreground requests.
*   [Background actions](https://docs.gadget.dev/guides/actions/background#background-action-priority) enqueued with a `high` priority.
*   [Webhook-triggered actions](https://docs.gadget.dev/guides/plugins/shopify/shopify-webhooks#setting-webhook-processing-priority) configured with a `high` priority.
*   [Shopify syncs](https://docs.gadget.dev/guides/plugins/shopify/syncing-shopify-data#sync-priority) configured to run with a `high` priority. When a sync is run with a `high` priority, all requests to Shopify as part of that sync will also be treated as high-priority.

**When to use surge compute?**

Surge compute is designed for latency-sensitive and user-facing operations. You should use high-priority requests and surge compute when a delay or rate limit error would directly degrade user experience, correctness, or system behavior.

You could use surge compute for things like:

*   Payment processing webhooks that need to be handled immediately.
*   Inventory or availability updates that need to be processed immediately.
*   Real-time analytics or reporting that needs to be updated immediately.

You may want to avoid using high priority and surge compute for things like:

*   Analytics or reporting requests that can be delayed, including periodic tasks such as daily or weekly reports.
*   Background jobs that can be retried safely, or queued for later execution.
*   Bulk processing operations that can be paused and resumed, or delayed, including data imports and exports.
*   Full Shopify data syncs.

Note that even `high` priority background actions and webhooks are not guaranteed to be executed immediately, due to the limit of available workers. However, they will be executed before other background actions and webhooks.

Surge compute is billed at a higher rate during surges. See [Pricing](https://gadget.dev/pricing) for more information.

#### Database availability 

You can enable high availability database for your production environment. This allows your environment to continue serving requests even if the main database instance becomes unavailable.

When high availability database is enabled, reads and writes will run on a leader instance with an always-on standby in a different zone. If the leader fails, Gadget automatically fails over to the standby and continues serving traffic without interruption.

Standard availability only runs the database on a single instance. A failure makes the database unavailable while a new instance starts up.

By default, high availability is enabled.

Standard availability database is billed at a discount. See [Pricing](https://gadget.dev/pricing) for more information.

### What happens when I reach 100% usage 

Each Gadget plan includes a free amount of resources each monthly billing period. When your applications use 100% of the included amount of any resource metric you will be charged a fee for additional resources determined by your plan.

If you are on the Hobby plan and have not yet added a valid payment method to your account your applications will be paused for the remainder of the billing period. Your applications being paused means they will no longer respond to API requests, will not process webhooks and will not sync data from your connections. You will also not be able to access the editor for any paused applications.

### Setting spend limits 

Spend limits allow you to set up alerts and a maximum spend for your billing account.

If the alerts are reached, all team members will receive an email notification. If the spend limit is reached, all apps will be paused and won't serve new requests. You can change the spend limit at any time.

Spend limits can be set from your [usage and billing page](https://app.gadget.dev/auth/team/billing#spend-limits).

### How do I change my Gadget plan? 

Plan upgrades and downgrades can be done from your [usage and billing page](https://app.gadget.dev/auth/team/billing#plans). If you would like to discuss custom pricing [contact our sales team](https://calendly.com/mohashemi/gadget-entreprise-intro).

### How do I add company details to my invoices? 

If you need to add or update the company details shown on your invoices, email `billing@gadget.dev` and we will help you update them.