Profile Limits

Segment's profile data pipeline processes events, traits, and identity signals across millions of profiles simultaneously. Without guardrails, a small number of profiles with unusually high event throughput, thousands of identifiers, or deeply nested merge cycles can monopolize shared pipeline resources. This can cause delayed Audience evaluation, stale Computed Traits, slower Profile Sync propagation, and Journeys that fall behind real-time.

Profile limits protect Segment uptime by enforcing consistent, predictable resource consumption per profile and per workspace. This ensures every customer benefits from fast, reliable profile processing, regardless of the content of any one profile.

These limits apply on a per-profile basis.

EPS measures how many events a single profile or your entire workspace processes per second.

• Profile-level (25 EPS): Applies to a single, resolved user profile. Common per-profile ETS violations come from real-time clickstreams, Internet of Things (IoT) signals, and server-side automation loops.
• Account-level (100 EPS): Applies across all profiles in your workspace. Common account-level violations occur from batch imports or misconfigured automations.

To avoid hitting throughput limits, Segment recommends the following:

• Batch or debounce high-frequency events upstream before sending to Segment. Segment is optimized for behavioral and transactional events, not telemetry streams.
• Avoid server-side loops that emit an event for every state change on one profile.
• In latency-sensitive workflows, use server-side sources where you control emission rate rather than relying on client-side SDKs.

• Review the Errors & Violations Search for workspaces showing sustained account-level EPS violations. These often indicate a misconfigured batch import job or a source emitting at an unintended rate.

Traits are key-value attributes stored on a user profile: for example, plan_type, lifetime_value, or last_purchase_date. Each profile can have up to 1,000 traits.

Hitting trait limits can be a result of:

• Sources writing event properties directly as profile traits without a deliberate schema
• Computed Traits or enrichment pipelines generating high-cardinality derived attributes
• Multiple sources writing overlapping or redundant trait schemas to the same profile

• Design your trait schema intentionally. Create high-signal, stable traits (plan tier, lifecycle stage, aggregate scores) rather than raw event-level attributes.
• Use Computed Traits to derive aggregated values rather than writing every intermediate state as a separate trait.
• Namespace traits by source or domain if multiple teams write to the same profile: for example, crm_plan_type vs. app_plan_type, to make auditing easier.

• Use the Profile Insights Dashboard to identify profiles with high trait counts and review which sources are contributing the most traits.
• Deprecate and remove traits that are no longer used in Audiences, Journeys, or downstream destinations before they consume quota.

Traits stored on group/account profiles are subject to the same limit as user profile traits: 1,000 per profile.

It is common to hit account trait limits in business-to-business (B2B) workspaces where customer relationship management (CRM) enrichment, product usage data, and billing data are all written to the same account profile from separate sources.

Segment recommends taking the following steps to avoid hitting account-level limits:

• Consolidate redundant account-level traits across CRM, billing, and product sources before they accumulate on the same account profile.
• Create aggregate or computed account traits: for example, total_seats, arr, or health_score, rather than granular event-level attributes.

Audit account profiles in the Profile Insights Dashboard for trait count distribution. B2B workspaces with many data sources per account are most at risk for account-level trait limits.

Identifiers are the data points used to stitch events and records into a unified profile: user_id, email, anonymous_id, device_id, phone numbers, and any custom external IDs.

Each profile is limited to 1,000 identifiers.

Identifier accumulation is most often caused by:

• Anonymous IDs from sessions that are never resolved in Identity calls, causing a single resolved profile to accumulate hundreds of orphaned anonymous IDs.
• Identity resolution merge cycles where profiles merge, split, and re-merge, generating a growing chain of historical identifiers.
• Device ID proliferation in mobile apps with high uninstall and reinstall rates.

• Call Identify promptly after a user authenticates to associate the anonymous session with a known user_id. This prevents the resolved profile from accumulating unbounded anonymous IDs.
• Audit your identity graph configuration for merge rules that could trigger cyclic merges. Cyclic merges, where profile A merges into B and B merges back into A, rapidly inflate identifier counts.
• Avoid emitting anonymous events from contexts where resolution is unlikely: like internal tooling, bots, and test environments.

• Follow the best practices in the Handle anonymous profiles section to avoid orphaned anonymousIDs.
• Review identity resolution rules in your Unify space and eliminate merge conditions that cause cyclic merges.

Links connect a user profile to group or account profiles using Group calls. Each user profile is limited to 500 links.

Link count violations are most common in B2B use cases where:

• A single user is a member of many organizations. For example, a consultant with accounts at many client companies.
• You call Group on every event rather than once when establishing a relationship.
• Your Group call logic does not check whether the user-to-group relationship already exists before emitting a Group call.

• Emit Group calls only when a user-to-group relationship is first established or materially changes. Do not include Group calls in event-level tracking.
• Implement a client-side or server-side check to suppress redundant Group calls when relationships are already established.
• In B2B workspaces with high link counts: for example, platform users who belong to many accounts, review your identity model to determine whether groups should be modeled differently.

• Audit Group call volume for each source in Sources > Debugger. Eliminate repeated Group calls, as the same user/group combination indicates an instrumentation issue.
• Review whether link accumulation reflects real business relationships or is an artifact of Group calls being used as a general-purpose event attribute.

Segment recommends taking the following steps to handle anonymous profiles:

• Resolve sessions promptly: Call Identify immediately after authentication. Segment's identity graph merges the anonymous session into the resolved profile, associating the anonymous_id with the user_id so future events route to the correct profile.
• Limit anonymous event emission from non-converting contexts: Suppress anonymous tracking from bots, internal tooling, test environments, and crawlers. These sessions will never resolve and consume profile quota without providing business value.
• Review unresolved anonymous profiles: Use the Profile Insights Dashboard to identify anonymous profiles with high identifier counts. These often represent sessions from shared devices, kiosks, or test suites rather than real users.
• Check identity resolution rules: If anonymous profiles are not merging into resolved profiles after you call Identify, review your identity graph merge rules. A misconfigured rule can leave anonymous and resolved profiles permanently separated, causing identifier divergence.

Segment provides two complementary UIs for monitoring profile limit health: the Profile Insights Dashboard for aggregate and profile-level analysis, and the Errors & Violations Search for event-level investigation.

The Profile Insights dashboard provides both workspace-level aggregate views and granular per-profile drill-downs for all profile limit dimensions.

To access the Profile Insights dashboard, go to Unify > Profile Insights.

The aggregate view of the Profile Insights dashboard gives workspace administrators a high-level picture of profile limit health across all profiles.

Use the aggregate view to:

• Identify whether limit violations are growing, stable, or declining over time
• Prioritize which limit dimension needs the most attention
• Report on overall identity graph health to engineering and data teams

Select any limit dimension in the aggregate view to see a ranked list of profiles ordered by their current count or violation frequency. Select any individual profile to open the per-profile detail view.

Per-profile counts available:

In the granular view, you can take the following actions:

• View the full profile
• API endpoints for deletion

The Errors & Violations Search UI provides event-level visibility into individual limit violations. Use it to debug specific profiles, sources, or time windows and to identify the root cause of dropped data.

To access the Errors and Violations search, go to Unify > Errors & Violations.

Each violation event includes:

Filter violations by:

• Violation type: narrow to a specific limit dimension
• Time range: last 1 hour, 24 hours, 7 days, or custom range
• Profile ID: investigate a specific profile

When a profile limit is reached, Segment recommends that you take the following steps to resolve the profile limit:

For any profile limit reached:

1. Open Profile Insights and identify which profiles are at or above 100% of any limit.
2. Open Errors & Violations Search and filter by the relevant violation type. Note which sources are contributing violations and whether data is being dropped.

• For EPS violations: Identify the source emitting high-frequency events. Reduce emission rate upstream or implement batching.
• For trait violations: Identify which sources are writing traits. Remove low-value traits or consolidate redundant traits across sources.
• For identifier violations: Review identity resolution configuration. Check for cyclic merge conditions or unresolved anonymous IDs.
• For link violations: Audit Group call frequency in the offending source. Suppress redundant calls for already-established relationships.

If limit violations are impacting production Audiences, Journeys, or Profile Sync and cannot be resolved through configuration changes, contact your Customer Success Manager (CSM). Your CSM can:

• Perform a profile audit against your workspace's specific data model
• Provide a remediation plan for profiles already at their limit
• Coordinate with Segment engineering for a limit review

• Unify Product Limits
• Engage Product Limits
• Identity Resolution Overview
• Computed Traits
• Group Spec
• Contact Support