HubSpot Custom Objects vs Custom Properties for Product Data

Quick answer: Use custom objects when one contact uses multiple products and each product needs its own properties (subscription tier, usage metrics). Use custom properties when you're tracking simple product attributes on the contact or company record (current plan, last login date). Use timeline events for activity streams (feature usage, logins) that trigger workflows but don't need to be stored as filterable fields.

• Custom objects - Best for many-to-many relationships. Requires Enterprise tier, counts toward object limits.
• Custom properties - Simpler to report on, works on all tiers. Doesn't scale for multiple products per contact.
• Timeline events - Shows behavioral history, triggers workflows. Can't report on aggregates or store current state.
• Hybrid approach - Most PLG companies use all three together: objects for products, properties for aggregates, timeline for activity.

Understanding Your Options: Custom Objects, Properties, and Timeline Events

Product usage data lands in HubSpot in three distinct ways. Each solves a different modeling problem, and most RevOps teams need all three.

What Are Custom Objects in HubSpot?

Custom objects are structured database tables that extend HubSpot's data model beyond the standard contacts, companies, deals, and tickets. Each object type can have multiple records (like rows in a database), and each record can have its own properties.

For product data, a custom object might be "Product Usage" or "Subscription." Each row represents one instance - one product tied to one contact, with properties like subscription_tier, mrr_value, license_count, and renewal_date. You create associations to link these records to contacts or companies.

Custom objects require HubSpot Enterprise tier. You get 10 custom objects and 2 million records on Enterprise, 15 objects and 10 million records on Enterprise+.

What Are Custom Properties?

Custom properties are additional fields you add to existing HubSpot objects. They store single values on a contact, company, deal, or ticket record. You can create dropdown selects, text fields, date fields, number fields, and checkboxes.

For product data, a custom property might be current_plan (text field with "Free", "Pro", "Enterprise"), last_login_date (date field), or total_logins_last_30_days (number field). These fields enrich the contact or company record directly.

Custom properties are available on all HubSpot tiers. You get 1,000 contact properties on Professional, 1,500 on Enterprise.

What Are Timeline Events?

Timeline events are timestamped activities that appear on contact, company, deal, or ticket records. They show what happened and when, creating a chronological activity stream.

For product data, timeline events track behavior: "Feature X used", "User logged in", "API call made", "Upgrade completed." Each event has a timestamp, an event type, and optional properties that describe the activity (like feature_name or api_endpoint). Timeline events can trigger workflows but don't persist as filterable properties on the record.

Timeline events are available on Professional and above. You can create up to 750 event types.

When to Use Custom Objects for Product Data

Custom objects solve the many-to-many problem. If one contact can have multiple products, and each product has its own lifecycle, custom objects are the right model.

Ideal Use Cases for Custom Objects

Multi-product SaaS companies. If your contact uses three different products (each with its own subscription tier, usage metrics, and renewal date), you need three custom object records. A single contact record can't store three sets of subscription properties without field bloat.

Seat-based licensing. If one company has 50 users, and each user has a license with its own status, assigned date, and last activity, create a "License" custom object. Associate each license record to both the company and the individual contact (if applicable).

Product lifecycle tracking. If products move through stages (trial, active, churned, reactivated), and you want to run workflows or reports on product-level lifecycle, custom objects give you that granularity. You can filter reports by "all products in churn risk" across all contacts.

Hardware inventory or physical goods. If you sell equipment and need to track serial numbers, warranty dates, service history, and location per device, each device is a custom object record.

Example: A B2B SaaS company sells project management software, time tracking, and invoicing as separate products. One contact might use all three. They create a "Product Subscription" custom object with properties: product_name, subscription_tier, mrr, contract_start_date, contract_end_date, usage_last_30_days. Each product gets its own record, associated to the contact and company.

Custom Object Limitations to Consider

Enterprise tier only. If you're on Professional, custom objects aren't available. You'll need to use properties or timeline events instead.

Counts toward object limits. You get 10 custom objects on Enterprise. If you're already using custom objects for other data (courses, certifications, support tickets), adding product data might push you over the limit.

Association complexity. Syncing custom objects requires creating associations via API. If you're building this yourself, you'll need to handle association labels, many-to-many relationships, and orphaned records. Syncing product usage data to HubSpot compares the engineering effort across methods.

Reporting limitations. Custom object reports in HubSpot are less flexible than contact reports. You can't use custom objects in lists (only in custom reports), and cross-object reporting requires careful association setup.

When to Use Custom Properties for Product Data

Custom properties work when product data enriches the contact or company record with a single value or a small set of values that don't change often.

Ideal Use Cases for Custom Properties

Current product state. If you need to know "what plan is this contact on right now?", a custom property like current_plan (dropdown with "Free", "Pro", "Enterprise") is the simplest model. You can filter lists, build workflows, and report on it immediately.

Aggregated usage metrics. If you want to track "total logins last 30 days" or "features used this month" as a single number, store it as a number property on the contact. Update it daily or weekly via API or calculation property.

Account-level attributes. Company properties like primary_product, total_licenses, or account_tier make sense as custom properties. Most companies use one primary product, so you don't need a custom object for one-to-one relationships.

Calculated fields. HubSpot calculation properties let you derive new fields from existing ones. You can calculate days_since_last_login (today minus last_login_date) or product_qualified_score (a formula combining multiple usage properties) without engineering work.

Example: A PLG company tracks trial_start_date, activation_completed (yes/no), features_adopted (number), and last_active_date as custom properties on the contact. They use a calculation property to derive days_to_activation and engagement_score. Sales reps see all product context directly on the contact record without clicking into custom objects.

When Properties Don't Scale

Multiple products per contact. If one contact uses three products, you can't store three sets of properties without creating product_1_name, product_2_name, product_3_name fields. That's unmaintainable and breaks reporting.

Historical tracking. Properties only store the current value. If you overwrite current_plan from "Pro" to "Enterprise", you lose the history. Timeline events or custom objects with dated records solve this.

Field bloat. Adding too many custom properties makes contact records hard to navigate and slows down HubSpot's UI. If you're tracking 50 product metrics per contact, consider custom objects or timeline events instead.

When to Use Timeline Events for Product Data

Timeline events track behavior over time without storing relational data. They answer "what did this contact do?" rather than "what state is this contact in?"

Ideal Use Cases for Timeline Events

Feature usage events. Track when a contact uses specific features: "Exported report", "Created project", "Invited team member." These events show adoption patterns and can trigger workflows (like sending a congratulations email after first use).

Login activity. Store login timestamps as timeline events. You can see the full login history and trigger workflows based on login frequency, but you'd calculate "days since last login" as a custom property for filtering.

Milestone events. Track activation milestones ("Completed onboarding", "Hit 10 projects", "Invited 5 users") as timeline events. These create a clear narrative of product engagement and can advance lifecycle stages.

API or integration activity. If your product has an API, track API calls, webhook deliveries, or integration usage as timeline events. This helps support and sales understand technical engagement.

Example: A B2B SaaS company sends timeline events for "Feature used", "Report generated", and "User invited." Each event includes properties like feature_name and timestamp. They run a workflow that checks if "Feature used" has happened in the last 7 days; if not, it triggers a re-engagement email. The contact record shows the full activity stream, but the company also maintains a custom property last_activity_date (updated by the same sync) for list filtering.

Timeline Event Limitations

No aggregate reporting. You can't easily answer "how many contacts used Feature X more than 10 times last month?" Timeline events are chronological, not aggregated. You'd need to count events in your product database and sync the count as a custom property.

Can't edit after creation. Once a timeline event is created via API, you can't change it. If you sent the wrong feature_name, you have to delete and recreate the event.

No current state. Timeline events don't store "what plan is this contact on right now?" They only store "this contact upgraded on 2026-05-12." You need a custom property to hold current state.

Workflow triggers are event-based. Workflows can react when a timeline event is created, but they can't filter by "events that happened X days ago" or "total event count." You need custom properties for those conditions.

Syncing Product Data: Methods and Mechanics

Getting product data into HubSpot in the right format requires understanding how each data type syncs.

Syncing Custom Objects

Custom objects sync via the HubSpot CRM API v3 Objects endpoint. You create a new record with a POST request to /crm/v3/objects/{objectType}, passing properties in the request body. Then you create associations to link the object to contacts or companies using the Associations API.

POST /crm/v3/objects/product_subscriptions
{
 "properties": {
 "product_name": "Project Manager Pro",
 "subscription_tier": "Enterprise",
 "mrr": 299,
 "contract_start_date": "2026-06-01"
 }
}

After creating the object record, you associate it to a contact:

PUT /crm/v3/objects/product_subscriptions/{objectId}/associations/contact/{contactId}/{associationTypeId}

Real-time syncing of custom objects is possible but requires handling API rate limits carefully. HubSpot allows 100 API calls per 10 seconds on Professional, 150 per 10 seconds on Enterprise. If you're syncing hundreds of product records, you'll need batching or queuing. How to prevent HubSpot API rate limit timeouts covers strategies for high-volume syncs.

Syncing Custom Properties

Custom properties sync via the same CRM API, but you update the contact or company record directly. No association step needed.

PATCH /crm/v3/objects/contacts/{contactId}
{
 "properties": {
 "current_plan": "Pro",
 "last_login_date": "2026-06-22",
 "total_logins_last_30_days": 47
 }
}

Property syncing is simpler and faster than custom object syncing. Most no-code tools handle this automatically. Tracking product usage in HubSpot without engineering compares no-code options like Zoody, Zapier, and native integrations.

Syncing Timeline Events

Timeline events sync via the Timeline Events API. You define event types in HubSpot (like "Feature Used"), then send events with a timestamp and optional properties.

POST /crm/v3/timeline/events
{
 "eventTypeId": "12345",
 "objectId": "contact-id-here",
 "timestamp": "2026-06-22T14:30:00Z",
 "extraData": {
 "feature_name": "Export Report"
 }
}

Timeline events are append-only and can't be edited after creation. They're fast to sync and don't count toward object record limits, but you can't query or filter them like properties.

Zoody syncs product events as both timeline events (for the activity stream) and custom properties (for filtering and reporting). This hybrid approach gives you the chronological history and the aggregate metrics you need for segmentation.

Decision Framework: Choosing Your Approach

Here's how to decide which method fits your use case.

If one contact uses multiple products, and each product has its own properties (tier, MRR, renewal date): Use custom objects. Example: Multi-product SaaS, seat-based licensing, hardware inventory.

If you're tracking simple product attributes on the contact or company (current plan, last login, total usage): Use custom properties. Example: PLG companies scoring free trial users, account-level metrics.

If you're tracking behavioral events that trigger workflows but don't need to be stored as filterable fields (logins, feature usage, milestone events): Use timeline events. Example: Activity streams, engagement tracking, onboarding milestones.

If you need all three: Most PLG companies use a hybrid approach. Custom objects for multi-product relationships, custom properties for aggregated scoring metrics, timeline events for activity history. Zoody handles this automatically by syncing events as both timeline entries and properties.

Can I convert custom properties into a custom object later? Yes, but it requires engineering work. You'll need to export your existing property data, create the custom object schema, write a script to create object records from the property values, and associate them to the correct contacts. If you think you'll need custom objects eventually, start with them. If you're unsure, start with properties and migrate later.

What if I'm on Professional tier and can't use custom objects? Use custom properties for current state and timeline events for activity. Store aggregated metrics (like "total logins last 30 days") as number properties, and use timeline events to show the full login history. You won't have per-product granularity, but you can still score and segment users effectively.

FAQ

What is the difference between standard object and custom object?

Standard objects are HubSpot's built-in data types: contacts, companies, deals, tickets, quotes, and products. They come with predefined properties and native integrations. Custom objects are tables you create to store data that doesn't fit the standard objects, like subscriptions, licenses, or courses. Custom objects require Enterprise tier and have separate record limits.

How many custom objects can be created in HubSpot?

HubSpot Enterprise allows 10 custom objects with 2 million total records. Enterprise+ allows 15 custom objects with 10 million records. Each custom object can have up to 500 properties. Professional and Starter tiers do not support custom objects.

Which HubSpot tools do custom objects work with?

Custom objects work with HubSpot's CRM API, custom reports, workflows (Enterprise tier), and associations. They do not work with lists (you must use custom reports instead). Custom objects can trigger workflows when created or updated, but workflow conditions on custom object properties are limited compared to contact properties.

Can I convert custom properties into a custom object later?

Yes, but it requires manual migration. You'll export the property data from contacts or companies, create the custom object schema with matching properties, write a script to create object records from the exported data, and associate the new records to the original contacts. HubSpot does not have a built-in conversion tool. If you expect to need custom objects, start with them rather than migrating later.