Optimize Sentry costs and event volume. Use when managing Sentry billing, reducing event volume, or optimizing quota usage. Trigger with phrases like "reduce sentry costs", "sentry billing", "sentry quota", "optimize sentry spend".
npxskills add jeremylongshore/claude-code-plugins-plus-skills--skill sentry-cost-tuningLoading…
Reduce Sentry spend by 60-95% through SDK-level sampling, server-side inbound filters, beforeSend event dropping, and quota management — without losing visibility into production errors that matter.
org:read and project:read scopes on an auth tokenSentry.init() configuration (typically sentry.client.config.ts or instrument.ts)SENTRY_AUTH_TOKEN and SENTRY_ORG environment variables set for API calls@sentry/node >= 8.0 or @sentry/browser >= 8.0 installedQuery the Sentry Usage Stats API to understand where volume comes from before making changes. This endpoint returns event counts grouped by category over any time period.
# Pull 30-day usage breakdown by category
curl -s -H "Authorization: Bearer $SENTRY_AUTH_TOKEN" \
"https://sentry.io/api/0/organizations/$SENTRY_ORG/stats/usage/?statsPeriod=30d&groupBy=category&field=sum(quantity)&interval=1d" \
| python3 -c "
import json, sys
data = json.load(sys.stdin)
print('=== 30-Day Usage by Category ===')
for group in data.get('groups', []):
cat = group['by']['category']
total = sum(interval[1] for interval in group.get('series', {}).get('sum(quantity)', []))
print(f' {cat}: {total:,} events')
"
# Identify top error-producing projects
curl -s -H "Authorization: Bearer $SENTRY_AUTH_TOKEN" \
"https://sentry.io/api/0/organizations/$SENTRY_ORG/stats/usage/?statsPeriod=30d&groupBy=project&category=error&field=sum(quantity)" \
| python3 -c "
import json, sys
data = json.load(sys.stdin)
projects = []
for group in data.get('groups', []):
proj = group['by']['project']
total = sum(interval[1] for interval in group.get('series', {}).get('sum(quantity)', []))
projects.append((proj, total))
projects.sort(key=lambda x: -x[1])
print('=== Top Error-Producing Projects ===')
for name, count in projects[:10]:
print(f' {name}: {count:,}')
"
Record the baseline numbers. You need these to measure savings after optimization.
sampleRateThe sampleRate option in Sentry.init() controls the percentage of error events sent to Sentry. Setting it to 0.1 means only 10% of errors are sent, yielding a 90% cost reduction on the error category.
import * as Sentry from '@sentry/node';
Sentry.init({
dsn: process.env.SENTRY_DSN,
// 10% of errors sent = 90% cost reduction
// Sentry extrapolates counts in the Issues dashboard
sampleRate: 0.1,
});
Trade-off: Low-frequency errors (< 10 occurrences/day) may be missed entirely. Mitigate this by using beforeSend to always send errors with specific severity or tags rather than relying on blanket sampling.
tracesSampleRate and tracesSamplerPerformance monitoring (transactions/spans) is typically the largest cost driver. A tracesSampleRate of 0.05 sends only 5% of traces, cutting performance costs by 95%.
import * as Sentry from '@sentry/node';
Sentry.init({
dsn: process.env.SENTRY_DSN,
// Static: 5% of all traces (95% cost reduction)
tracesSampleRate: 0.05,
// Dynamic: per-endpoint sampling for fine-grained control
// When tracesSampler is defined, it overrides tracesSampleRate
tracesSampler: (samplingContext) => {
const { name, attributes } = samplingContext;
// Never trace health checks, readiness probes, static assets
if (name?.match(/\/(health|healthz|ready|livez|ping|robots\.txt|favicon)/)) {
return 0;
}
if (name?.match(/\.(js|css|png|jpg|svg|woff2?|ico)$/)) {
return 0;
}
// High-value: payment and auth flows get 50% sampling
if (name?.includes('/checkout') || name?.includes('/payment')) {
return 0.5;
}
if (name?.includes('/auth') || name?.includes('/login')) {
return 0.25;
}
// API routes: 5%
if (name?.includes('/api/')) {
return 0.05;
}
// Everything else: 1%
return 0.01;
},
});
The tracesSampler function receives a samplingContext with the transaction name (usually the route) and attributes. Return a number between 0 (drop) and 1 (always send), or true/false.
beforeSendThe beforeSend hook fires for every error event before it is sent to Sentry. Returning null drops the event entirely — it never counts against quota.
import * as Sentry from '@sentry/node';
Sentry.init({
dsn: process.env.SENTRY_DSN,
beforeSend(event, hint) {
const error = hint?.originalException;
const message = typeof error === 'string' ? error : error?.message || '';
// Drop ResizeObserver noise (Chrome fires this constantly, never actionable)
if (message.includes('ResizeObserver loop')) return null;
// Drop network errors from flaky client connections
if (/^(Failed to fetch|NetworkError|Load failed|AbortError)$/i.test(message)) {
return null;
}
// Drop cancelled navigation (user clicked away)
if (message.includes('cancelled') || message.includes('AbortError')) {
return null;
}
// Drop browser extension errors by checking stack frames
const frames = event.exception?.values?.[0]?.stacktrace?.frames || [];
if (frames.some(f => f.filename?.match(/extensions?\//i) || f.filename?.match(/^(chrome|moz)-extension:\/\//))) {
return null;
}
// Always send critical errors regardless of sampleRate
// Re-enable any that were sampled out
if (event.level === 'fatal' || event.tags?.critical === 'true') {
return event;
}
return event;
},
// Complementary: block errors from known noisy patterns
ignoreErrors: [
'ResizeObserver loop completed with undelivered notifications',
'ResizeObserver loop limit exceeded',
'Non-Error promise rejection captured',
/Loading chunk \d+ failed/,
/Unexpected token '<'/, // HTML returned instead of JS (CDN issue)
/^Script error\.?$/, // Cross-origin script with no details
],
// Block events from third-party scripts
denyUrls: [
/extensions\//i,
/^chrome:\/\//i,
/^chrome-extension:\/\//i,
/^moz-extension:\/\//i,
/hotjar\.com/,
/intercom\.io/,
/google-analytics\.com/,
/googletagmanager\.com/,
/cdn\.segment\.com/,
],
});
Inbound data filters drop events at Sentry's edge before they are ingested and counted against quota. They cost nothing to enable.
Navigate to Project Settings > Inbound Filters (or use the API) and enable:
| Filter | What it drops | Impact |
|---|---|---|
| Browser Extensions | Errors from Chrome/Firefox extensions | 5-15% of frontend errors |
| Legacy Browsers | IE 11, old Safari/Chrome versions | 2-10% depending on audience |
| Localhost Events | Errors from localhost and 127.0.0.1 | Dev noise (variable) |
| Web Crawlers | Bot-triggered errors (Googlebot, Bingbot) | 1-5% of frontend errors |
| Filtered Transactions | Health checks, static asset requests | 10-40% of transactions |
# Enable inbound filters via API
for filter in browser-extensions legacy-browsers localhost-events web-crawlers; do
curl -s -X PUT \
-H "Authorization: Bearer $SENTRY_AUTH_TOKEN" \
-H "Content-Type: application/json" \
-d '{"active": true}' \
"https://sentry.io/api/0/projects/$SENTRY_ORG/$SENTRY_PROJECT/filters/$filter/"
echo " -> Enabled: $filter"
done
Add custom error message filters for project-specific noise:
# Add custom inbound filter for error messages
curl -s -X PUT \
-H "Authorization: Bearer $SENTRY_AUTH_TOKEN" \
-H "Content-Type: application/json" \
-d '{"active": true, "subfilters": ["ResizeObserver", "ChunkLoadError", "Script error"]}' \
"https://sentry.io/api/0/projects/$SENTRY_ORG/$SENTRY_PROJECT/filters/custom-error-messages/"
Spike protection is auto-enabled on all Sentry plans and caps burst events during sudden spikes (deploy bugs, infinite loops). Verify it is active under Organization Settings > Spike Protection.
Per-key rate limits restrict events per DSN key per time window. Set these in Project Settings > Client Keys (DSN) > Rate Limiting or via the API:
# Set rate limit: 1000 errors per hour per DSN key
curl -s -X PUT \
-H "Authorization: Bearer $SENTRY_AUTH_TOKEN" \
-H "Content-Type: application/json" \
-d '{"rateLimit": {"window": 3600, "count": 1000}}' \
"https://sentry.io/api/0/projects/$SENTRY_ORG/$SENTRY_PROJECT/keys/$KEY_ID/"
Spend allocations (Team and Business plans): Set per-category budgets under Settings > Subscription > Spend Allocations to cap on-demand spending per billing period.
Sentry offers two pricing models for volume above the plan's included quota:
| Model | Rate (errors) | Best for |
|---|---|---|
| Reserved volume | ~$0.000180/event (pre-paid blocks) | Predictable workloads |
| On-demand volume | ~$0.000290/event (pay-as-you-go) | Spiky/seasonal traffic |
Reserved volume is approximately 38% cheaper per event than on-demand. If your 30-day audit shows consistent volume, purchase reserved blocks to match the P90 usage. Let spikes overflow into on-demand.
Example calculation:
Average monthly errors: 120,000
Plan included: 50,000 (Team plan)
Overage: 70,000
On-demand cost: 70,000 x $0.000290 = $20.30/month
Reserved cost: 70,000 x $0.000180 = $12.60/month
Monthly savings: $7.70 ($92.40/year)
Smaller payloads mean lower bandwidth costs and faster event processing. These settings do not reduce event count but lower overall resource consumption.
import * as Sentry from '@sentry/node';
Sentry.init({
dsn: process.env.SENTRY_DSN,
// Reduce breadcrumbs from default 100 to 20
maxBreadcrumbs: 20,
// Truncate long string values (default 250)
maxValueLength: 500,
// Disable features you are not actively using
replaysSessionSampleRate: 0, // Session replays off
replaysOnErrorSampleRate: 0, // Error replays off
profilesSampleRate: 0, // Profiling off
beforeSend(event) {
// Truncate large request bodies
if (event.request?.data && typeof event.request.data === 'string') {
if (event.request.data.length > 2000) {
event.request.data = event.request.data.substring(0, 2000) + '...[truncated]';
}
}
// Strip unnecessary headers
if (event.request?.headers) {
const keep = ['content-type', 'user-agent', 'referer', 'accept-language'];
event.request.headers = Object.fromEntries(
Object.entries(event.request.headers)
.filter(([k]) => keep.includes(k.toLowerCase()))
);
}
return event;
},
});
After deploying changes, wait 48-72 hours and re-run the usage audit from Step 1 to measure actual savings.
# Compare current period vs previous period
curl -s -H "Authorization: Bearer $SENTRY_AUTH_TOKEN" \
"https://sentry.io/api/0/organizations/$SENTRY_ORG/stats/usage/?statsPeriod=7d&groupBy=category&field=sum(quantity)&interval=1d" \
| python3 -c "
import json, sys
data = json.load(sys.stdin)
print('=== Post-Optimization 7-Day Usage ===')
for group in data.get('groups', []):
cat = group['by']['category']
total = sum(interval[1] for interval in group.get('series', {}).get('sum(quantity)', []))
print(f' {cat}: {total:,} events')
print()
print('Compare against your Step 1 baseline to calculate % reduction.')
"
After completing this skill:
sampleRate for errors, tracesSampler for performance tracesbeforeSend hook dropping non-actionable errors (ResizeObserver, network failures, browser extensions)ignoreErrors and denyUrls blocking known noisy patterns| Problem | Cause | Fix |
|---|---|---|
| Critical errors missing from Sentry | sampleRate too low | Add beforeSend logic that always sends level: 'fatal' events regardless of sampling |
| Zero performance data | tracesSampleRate: 0 or tracesSampler returning 0 for all routes | Set minimum 0.01 baseline in the tracesSampler default return |
| Unexpected overage charges | No rate limits or spend allocations | Set per-key rate limits (Step 6) and spend allocations in billing settings |
| Spike consuming entire monthly quota | Spike protection disabled or infinite error loop | Verify spike protection is active; add circuit breaker in beforeSend |
| Usage API returns 403 | Auth token missing org:read scope | Generate new token at sentry.io/settings/auth-tokens with org:read + project:read |
beforeSend drops too aggressively | Overly broad regex patterns | Test patterns against recent events in Sentry's Discover tab before deploying |
| Inbound filters not reducing volume | Filters enabled after events ingested | Filters are prospective only; wait for new events to see impact |
Before: 45K errors + 800K transactions
Included: 50K errors + 100K transactions
Overage: 700K transactions x $0.000025 = $17.50/month
After optimization:
tracesSampler → 800K reduced to 40K (95% drop)
ignoreErrors + beforeSend → 45K reduced to 28K (38% drop)
Inbound filters → additional 5% reduction
New monthly overage: $0
Annual savings: $210
Before: 450K errors + 200K transactions + 5K replays
Included: 100K errors + 500K transactions + 5K replays
Overage: 350K errors x $0.000290 = $101.50/month
After optimization:
sampleRate 0.25 → 450K reduced to 112K
beforeSend filtering → 112K reduced to 85K
Inbound filters → 85K reduced to 72K
New monthly overage: $0 (72K < 100K included)
Annual savings: $1,218
Sentry.init({
dsn: process.env.SENTRY_DSN,
tracesSampler: (samplingContext) => {
const { name } = samplingContext;
// Internal services: minimal sampling
if (name?.startsWith('internal.')) return 0.001;
// Customer-facing API: moderate sampling
if (name?.startsWith('api.')) return 0.05;
// Background jobs: low sampling
if (name?.includes('worker') || name?.includes('cron')) return 0.01;
return 0.01;
},
});
beforeSend, ignoreErrors, denyUrlstracesSampler referenceGET /api/0/organizations/{org}/stats/usage/sampleRate, tracesSampler, beforeSend) to a staging environment firstbeforeSend filters against new error patterns in Discover
Create or update AgentSkills. Use when designing, structuring, or packaging skills with scripts, references, and assets.
Create or update AgentSkills. Use when designing, structuring, or packaging skills with scripts, references, and assets.
Set up and use 1Password CLI (op). Use when installing the CLI, enabling desktop app integration, signing in (single or multi-account), or reading/injecting/running secrets via op.
CLI to manage emails via IMAP/SMTP. Use `himalaya` to list, read, write, reply, forward, search, and organize emails from the terminal. Supports multiple accounts and message composition with MML (MIME Meta Language).
Create or update AgentSkills. Use when designing, structuring, or packaging skills with scripts, references, and assets.
Create or update AgentSkills. Use when designing, structuring, or packaging skills with scripts, references, and assets.
Set up and use 1Password CLI (op). Use when installing the CLI, enabling desktop app integration, signing in (single or multi-account), or reading/injecting/running secrets via op.
CLI to manage emails via IMAP/SMTP. Use `himalaya` to list, read, write, reply, forward, search, and organize emails from the terminal. Supports multiple accounts and message composition with MML (MIME Meta Language).