What are GA4 event parameters?

## Why it matters

GA4 ships with built-in events like page_view and purchase. But those are bare: they don't tell you what page you viewed, or what you bought. That's where parameters come in.

Parameters are the extra details you attach to an event. "I had a page view, and here's the page type: product." "I completed a purchase, and here's the value: $49.99." Parameters make events meaningful.

GA4 has two kinds of parameters: event parameters and user properties. Event parameters describe this specific event. User properties describe the user (age group, loyalty status, subscription tier). Both ride on the request, but they're scoped differently in reporting.

## How it works

Every event can carry event parameters. You send them when you fire the event:

gtag('event', 'purchase', {
  value: 99.99,
  currency: 'USD',
  items: [{ item_name: 'Widget' }]
});
Copy

When that hits the wire, those parameters get encoded. Text parameters use the ep. prefix, numbers use epn.:

en=purchase&epn.value=99.99&ep.currency=USD
Copy

User properties work the same way but sit on every event and describe the user, not the purchase:

gtag('set', { 'user_segment': 'premium' });
Copy

That gets encoded as:

up.user_segment=premium
Copy

And every subsequent hit carries up.user_segment=premium automatically.

The prefixes:

• ep.<name>: event parameter, text value (e.g., ep.color=blue)
• epn.<name>: event parameter, numeric value (e.g., epn.price=29.99)
• up.<name>: user property, text value (e.g., up.segment=vip)
• upn.<name>: user property, numeric value (e.g., upn.visits=12)

GA4 sends both event and user parameters on the same request. The Measurement Protocol distinguishes them by prefix.

Reserved parameters. GA4 pre-defines certain parameters: value, currency, items, transaction_id. These have special meaning in GA4's interface and reports. You don't have to register them.

Custom parameters. If you want to send something unique to your business, like customer_segment or ab_test_group, you can. But first you should register it as a custom dimension or metric in GA4 so it shows up in reports with a proper name and type.

## What does not matter

You don't have to register built-in parameters like value and currency. GA4 knows them and reports them automatically.

You also don't need to include every parameter on every event. Send only what's relevant. A page_view event doesn't need an items array. A purchase event doesn't need a page_type parameter. GA4 ignores parameters it doesn't expect.

And parameters don't affect whether an event fires. If you misspell a parameter name or send the wrong type (text instead of number), the event still fires. The bad parameter just gets dropped or treated as a string.

## Code example

Here's a complete example sending both event and user parameters:

// Set a user property once
gtag('set', { 'user_plan': 'pro' });

// Send an event with parameters
gtag('event', 'add_to_cart', {
  value: 79.99,
  currency: 'USD',
  item_name: 'Blue Widget',
  item_category: 'widgets'
});
Copy

That creates a request like:

POST /g/collect
v=2&tid=G-XXXXXXXXXX&cid=12345&en=add_to_cart
&epn.value=79.99&ep.currency=USD&ep.item_name=Blue%20Widget&ep.item_category=widgets
&up.user_plan=pro
Copy

Notice the user property (up.user_plan) appears on the event, even though you set it earlier. GA4 includes all active user properties on every hit.

## How Scalpel Tags shows it

Scalpel Tags groups parameters into readable tables. In the DevTools panel, you'll see:

• Event parameters: all ep.* and epn.* values, listed with readable names
• User properties: all up.* and upn.* values, clearly separated as user-scoped data

This makes it easy to spot what custom data your page is sending and whether the values are correct.

## Related links

• GA4 Measurement Protocol
• GA4 Batched Hits