New Relic free tier: free infrastructure monitoring in 2026

A handful of Linux servers needs proper monitoring, and the small teams, freelancers and founders who run them want it without a monthly bill. You get the exact limits of New Relic’s free tier, a working install of the infrastructure agent, application performance monitoring (APM), log forwarding, synthetic checks and alerts, and a set of settings that keep you under the free allowance.

I use both Prometheus and New Relic for observability at NoDowntime Technologies, where I run 24/7 monitoring and incident response for clients. Both are good. Near the end I explain when I would pick Prometheus and Grafana instead, and compare New Relic’s free tier with Grafana Cloud’s and Datadog’s.

What the New Relic free tier includes

New Relic prices by data ingested and by user type, not by host. The free tier is permanent, not a trial. Checked on 11 November 2026.

Item	Free tier
Data ingest	100 GB per month, across metrics, events, logs and traces
Full platform users	1
Basic users	Unlimited (query, dashboards, alerts)
Core users	None
Default retention	At least 8 days; logs 30 days; synthetic results 13 months
Synthetic checks	500 non-ping checks per month; ping monitors do not count
Logs	Credit card and US Social Security number patterns obfuscated by default
Over 100 GB	Ingest stops until you upgrade or the next month starts
Paid ingest	$0.40 per GB (original data), $0.60 per GB (Data Plus)

Three details matter more than the headline number.

The one full platform user is the only seat that can use the curated APM and infrastructure screens. Basic users can run NRQL queries, build dashboards and receive alerts, but they cannot use the curated experiences such as the APM UI. On the free tier, decide who that one person is.

Monthly ingest is rounded up to the next whole GB. 99.2 GB counts as 100.

Hitting the limit stops data; it does not bill you. New Relic’s pricing page says ingest ceases and you lose access to the platform when you exceed the free 100 GB, until you upgrade to a paid plan or the next month starts. For a monitoring tool, that is the worst failure: you go blind halfway through the month, often because something noisy happened. The alert in the “Stay inside the free 100 GB” section below exists to catch this early.

Before you install: keys and accounts

Sign up, then collect three values from the UI:

• Your account ID, which the install command and API calls need.
• A user key, which the New Relic CLI uses to look up your licence key.
• The ingest licence key, a 40-character key ending in NRAL. Agents use it to send data. In config files it appears as license_key.

If your account is in the EU data centre, use the EU guided install link from the UI. The command it generates already has the right region.

Install the infrastructure agent with guided install

The quickest path is guided install. It downloads the New Relic CLI, installs the agent, and can detect services on the host (Nginx, MySQL, PostgreSQL, Redis and others) and offer to install their integrations.

The documented form, with the infrastructure recipe named explicitly:

curl -Ls https://download.newrelic.com/install/newrelic-cli/scripts/install.sh | bash && \
  sudo NEW_RELIC_API_KEY=<YOUR_USER_KEY> \
       NEW_RELIC_ACCOUNT_ID=<YOUR_ACCOUNT_ID> \
       NEW_RELIC_REGION=<YOUR_REGION> \
       /usr/local/bin/newrelic install -n infrastructure-agent-installer

In practice, copy the command from the guided install page in the UI, which fills in your keys and region. A few options from the docs are useful:

• Run newrelic install without -n to let it discover what is on the host and recommend integrations.
• Add -y for unattended installs with default answers, for example from Ansible or cloud-init.
• Pin a version by appending it to the recipe, such as [email protected], so a fleet does not drift.
• Other recipe names include nginx-open-source-integration, mysql-open-source-integration, postgres-open-source-integration, redis-open-source-integration, node-agent-installer, java-agent-installer and php-agent-installer.

Piping a script into bash with sudo is a trust decision. If your policy does not allow it, use the package install instead: write the licence key to the config file, add New Relic’s GPG key and repository for your distribution (the commands per distribution are in the Linux install docs), then install the package.

echo "license_key: <YOUR_LICENSE_KEY>" | sudo tee -a /etc/newrelic-infra.yml
# add the New Relic repository for your distribution, then:
sudo apt-get update && sudo apt-get install newrelic-infra -y   # Debian, Ubuntu
sudo yum install newrelic-infra -y                              # RHEL, Rocky, AlmaLinux, Amazon Linux

The docs list Debian 11 to 13, Ubuntu 18.04 to 24.04, Amazon Linux 2 and 2023, RHEL-family 7 to 10 and SLES among supported systems. The agent runs as root by default; set NRIA_MODE to PRIVILEGED or UNPRIVILEGED at install time if your security baseline requires it.

Check it is running:

sudo systemctl status newrelic-infra

Once it reports, the host appears in the Infrastructure section of the UI.

Configure the agent for a small budget

The main config file is /etc/newrelic-infra.yml. Only license_key is required. The settings below give the host a stable name, tag it, and send less data than the defaults.

license_key: <YOUR_LICENSE_KEY>
display_name: web-01
custom_attributes:
  environment: production
  role: web

# Sample intervals in seconds.
# Minimums: system 5, storage 5, network 10. -1 disables a sampler.
metrics_system_sample_rate: 15
metrics_storage_sample_rate: 60
metrics_network_sample_rate: 30

# Process samples are often the largest infrastructure data source.
enable_process_metrics: false

Restart after changes:

sudo systemctl restart newrelic-infra

New Relic’s own optimisation guide calls process samples “often the single most high volume source of data from the infrastructure agent”. They are off by default, but agents installed with guided install have them switched on. If you want process data for a few services only, keep it on and filter it:

enable_process_metrics: true
include_matching_metrics:
  process.name:
    - regex "^nginx"
    - regex "^node"

Add APM to an application

APM shows transactions, slow endpoints, errors and external calls. Guided install has recipes for Java, Node.js, PHP and .NET. For Node.js, the manual install is short:

npm install newrelic

Configure with environment variables and load the agent before your code:

export NEW_RELIC_APP_NAME="shop-api"
export NEW_RELIC_LICENSE_KEY="<YOUR_LICENSE_KEY>"

node -r newrelic ./dist/server.js
# ES modules:
node --import newrelic/esm-loader.mjs -r newrelic ./dist/server.js

Keep the licence key out of the repository. Put it in your process manager’s environment, a systemd EnvironmentFile, or your container platform’s secrets store.

One thing to know before you deploy: the Node.js agent forwards application logs from supported logging libraries to New Relic by default (since agent 8.16.0). If you also tail the same log file with the infrastructure agent, you pay for those lines twice. Pick one route. To switch off agent forwarding:

export NEW_RELIC_APPLICATION_LOGGING_FORWARDING_ENABLED=false

Forward logs from the server

The infrastructure agent ships logs using files in /etc/newrelic-infra/logging.d/. It picks up new files without a restart. name and one source (file, systemd, syslog, tcp) are required; attributes and pattern are optional.

# /etc/newrelic-infra/logging.d/web.yml
logs:
  - name: nginx-error
    file: /var/log/nginx/error.log
    attributes:
      logtype: nginx-error

  - name: shop-api
    file: /var/log/shop-api/*.log
    pattern: ERROR|WARN

  - name: ssh
    systemd: ssh

pattern is a regular expression; only matching lines are sent. On the free tier this is your main lever for logs, because nothing can be dropped after it arrives (more on that below). Reading from systemd requires the agent to run in root mode.

I would not forward Nginx access logs on a busy site at all. Request rates and error rates are cheaper as metrics from APM or an integration, and one access log line per request adds up fast.

Add synthetic checks

Synthetic monitors test your site from New Relic’s locations, so you learn about an outage even when the server and its agent are down.

The free tier includes 500 checks a month, and that limit applies to every monitor type except the simple ping monitor. The arithmetic gets tight quickly. New Relic’s own example: one monitor running hourly from five locations makes 120 checks a day. A scripted browser test every hour from one location is about 720 checks in a month, already over.

A layout that fits:

• Ping monitors for the home page, the login page and the API health endpoint, at a short interval from several locations. They do not count against the 500.
• One scripted or API test for the critical journey (log in, add to basket), every six hours from two locations: about 240 checks a month.

Set up alerts and notifications

New Relic’s alerting has four parts:

1. Alert conditions: a continuously running query compared against a threshold. NRQL conditions are the recommended type.
2. Policies: group conditions and decide how alert events become issues.
3. Workflows: decide when to notify and where, based on filters such as the policy name.
4. Destinations: where notifications go, such as email, Slack, a webhook, Jira or ServiceNow.

Start with a small set you will actually act on.

CPU saturation, per host, critical above 90% for 10 minutes:

SELECT average(cpuPercent) FROM SystemSample FACET hostname

Disk filling up, critical above 85%:

SELECT max(diskUsedPercent) FROM SystemSample FACET hostname

Host stopped reporting: on the CPU condition, set the lost signal threshold (for example, 10 minutes) and choose to open a new alert event when the signal is lost. That covers a dead server, a stopped agent and a network partition with one setting.

Then create one destination (email to the on-call address, or a Slack channel), one workflow that filters on your policy, and send a test notification. Basic users can receive and work with alerts, so the rest of the team does not need paid seats to be on call.

Stay inside the free 100 GB

Drop rules are no longer an option on free accounts

Older guides tell you to fix ingest with NRQL drop rules. That no longer works on the free tier. The Drop Filter Rules API reached end of life on 31 August 2026 (extended from 30 June). New Relic’s notice says that for free-tier accounts, drop rules were disabled unless the account was on Advanced Compute, and free users must upgrade to a paid plan to keep using them.

The replacement, Pipeline Control cloud rules, is sold as part of the Advanced Compute add-on and is metered on data dropped and events scanned. Data it drops does not count as ingest, but dropping it is no longer free.

So on the free tier, every saving has to happen before the data leaves your server.

Measure first

Run this in the query builder to see where your ingest comes from:

FROM NrConsumption SELECT sum(GigabytesIngested)
WHERE productLine = 'DataPlatform'
SINCE 30 days ago FACET usageMetric TIMESERIES 1 day

And this for the month to date:

FROM NrMTDConsumption SELECT latest(GigabytesIngested)
WHERE productLine = 'DataPlatform'

Let the agents run for a day or two, then multiply. Do not guess from someone else’s per-host figure; a quiet VPS and a busy database server differ by a large factor.

Cut at the source

Source	Setting	Effect
Process samples	enable_process_metrics: false or include_matching_metrics	Usually the biggest infrastructure saving
Host metrics	metrics_*_sample_rate	Fewer samples per minute
Logs	pattern: in logging.d files	Only matching lines are sent
Duplicate logs	NEW_RELIC_APPLICATION_LOGGING_FORWARDING_ENABLED=false	Stops APM forwarding the same lines
APM events (Node.js)	NEW_RELIC_SPAN_EVENTS_MAX_SAMPLES_STORED, NEW_RELIC_TRANSACTION_EVENTS_MAX_SAMPLES_STORED	Lower per-minute caps; the agent samples above them
On-host integrations	interval (default 15s)	Raise to 30 or 60 seconds
Synthetics	Monitor frequency and locations	Fewer non-ping checks

Alert before the cliff

Add an alert condition on hourly ingest. 100 GB spread over a 30-day month is roughly 0.14 GB an hour, so a threshold around 0.12 GB an hour warns you while there is still room to react. New Relic’s docs use this query and recommend the Event Timer aggregation method, because usage data arrives infrequently:

FROM NrConsumption SELECT sum(GigabytesIngested)
WHERE productLine = 'DataPlatform'

When to choose Prometheus and Grafana instead

New Relic’s free tier is very good for a small estate where one person wants APM, logs, synthetics and alerts in one place without running anything. It becomes the wrong tool when the shape of your data changes. I would choose Prometheus and Grafana when:

• You have many hosts or containers. New Relic charges by the GB once you pass 100 GB. Prometheus costs you a server and its disk, whatever the volume.
• You need long metric retention for capacity planning. Free-tier retention starts at 8 days. Prometheus keeps what your disk holds.
• You run Kubernetes. Most cluster components and operators already expose Prometheus metrics, and the community dashboards and alert rules assume Prometheus.
• Data has to stay in your network for compliance or because the environment is air-gapped.

The cost is your time: you run the monitoring system, back it up, upgrade it and monitor it. Starting is simple. Run node_exporter on each host (it listens on port 9100) and scrape it:

scrape_configs:
  - job_name: node
    static_configs:
      - targets: ['10.0.0.11:9100', '10.0.0.12:9100']

You can also mix the two: Prometheus for infrastructure metrics, New Relic for APM on the services where traces matter.

New Relic, Grafana Cloud and Datadog free plans compared

Checked on 11 November 2026. Each vendor meters different things, so compare against your own data.

	New Relic free	Grafana Cloud free	Datadog free
What is metered	100 GB ingest per month, all telemetry	10k active metric series; 50 GB each of logs, traces and profiles per month	Up to 5 Basic hosts
Retention	At least 8 days (logs 30 days)	14 days	1 day of metrics
Users	1 full platform, unlimited basic	3 active users	Not stated for the free plan
Synthetics	500 non-ping checks per month; ping not counted	100k API and 10k browser test executions per month	Not part of the free plan’s stated scope
APM	Included, viewed by the full platform user	Application Observability: 2,232 host hours per month	Not part of the free plan’s stated scope
Beyond free	$0.40 per GB (original data)	Paid usage tiers	Infrastructure Pro from $15 per host per month billed annually, $18 on demand

Datadog’s free plan is infrastructure monitoring for five hosts with one day of metric history: fine for a demo, thin for operations. Grafana Cloud’s free tier is generous for metrics and logs and is the natural fit if you already know PromQL. New Relic’s single 100 GB pool is the easiest to reason about when one person wants APM, logs and synthetics without splitting allowances.

If you are choosing a CI/CD system to deploy the services you are monitoring, see CI/CD tools compared for small teams. For free hosting of a static site, see hosting a website for free on Cloudflare Workers.

Setup steps in order

• Sign up and note the account ID, a user key and the ingest licence key.
• Install the infrastructure agent with guided install, or the package if piping to bash is not allowed.
• Set display_name, custom_attributes and longer sample rates in /etc/newrelic-infra.yml.
• Turn process metrics off, or filter them with include_matching_metrics.
• Add APM, and choose one log route: APM forwarding or logging.d, not both.
• Use pattern: on every log source you forward.
• Use ping monitors freely; budget the 500 non-ping checks.
• Create CPU, disk and lost-signal conditions, one workflow, one destination.
• Alert on hourly ingest so you never hit the 100 GB cut-off blind.
• Revisit Prometheus and Grafana when hosts, retention or data residency outgrow the free tier.