> ## Documentation Index
> Fetch the complete documentation index at: https://docs.introw.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Partner attribution in HubSpot

> Every way to attribute HubSpot deals to partners - custom properties, association labels, and custom objects - with mechanics, trade-offs, and setup.

export const object_3 = "deal"

export const crm_2 = "HubSpot"

export const object_2 = "deal"

export const crm_1 = "HubSpot"

export const object_1 = "deal"

export const crm_0 = "HubSpot"

export const object_0 = "deal"

Attribution is the link between a HubSpot record and the partner who sourced or influenced it. It is what makes partner-attached pipeline, reporting, and commissions trustworthy - so it deserves to match how your CRM is actually modelled, not the other way around.

HubSpot lets you model that link in three fundamentally different ways. **Introw supports all three out of the box.**

There is no RevOps project, no schema rebuild, no code, and no {crm_0} consultant. You keep your existing model; you simply tell Introw *how a record is linked to a partner*, and from there Introw does the rest:

<CardGroup cols={3}>
  <Card title="Reads it in" icon="arrow-right-to-bracket">
    Introw pulls every matching {object_0}, even old ones, and attributes each correctly.
  </Card>

  <Card title="Embeds it" icon="table-cells">
    Attributed records appear in portals, dashboards, commissions, and reporting under your name.
  </Card>

  <Card title="Writes it back" icon="arrow-right-from-bracket">
    A form submission is attached with the *exact method* you configured, so the record is born compliant.
  </Card>
</CardGroup>

<Note>
  The whole point: **you match your system to Introw once, and Introw matches every record to your system forever.** Historic {object_0}s become attributable, and new partner-created records are born correctly attributed. That is the backwards-compatibility and data-hygiene win - and it holds for whichever method below you already use.
</Note>

## The three methods at a glance

<CardGroup cols={3}>
  <Card title="Custom property" icon="tag">
    A property on the deal holds the partner. Simplest; works on **every HubSpot plan**.
  </Card>

  <Card title="Association label" icon="building">
    A labelled deal-to-company association marks the partner. Native and scalable; needs **Professional or Enterprise**.
  </Card>

  <Card title="Custom object" icon="cubes">
    A dedicated Partner object is associated to deals. Richest partner data; needs **Enterprise**.
  </Card>
</CardGroup>

```mermaid theme={"theme":{"light":"github-light","dark":"github-dark"}}
flowchart TB
  subgraph HS["How the link is stored in HubSpot"]
    direction LR
    p["Custom property<br/>dropdown or text"]
    a["Association label<br/>Deal to Company"]
    o["Custom object<br/>Partner to Deal"]
  end
  p --> introw["Introw Object Linking<br/>name it, set eligibility"]
  a --> introw
  o --> introw
  introw --> out["Attributed pipeline, reporting, commissions, portals"]
```

<Note>
  Configure **Deal** attribution at minimum - it is what reporting and commissions run on. You can attribute contacts, companies, tickets, and custom objects to partners the same way.
</Note>

***

## Method 1 - Custom property

**Best for:** simpler programs where a deal has one partner (or a small fixed set), and teams that want attribution live on the HubSpot plan they already pay for.

A custom deal property holds the partner. Most commonly a **dropdown (enumeration) property** - one option per partner - but a text or multiple-checkbox property works too.

```mermaid theme={"theme":{"light":"github-light","dark":"github-dark"}}
erDiagram
  DEAL {
    string dealname
    number amount
    enum partner_dropdown "the partner"
  }
  PARTNER_OPTION {
    string label "one option per partner"
  }
  DEAL }o--|| PARTNER_OPTION : "value identifies partner"
```

<AccordionGroup>
  <Accordion title="How it works in HubSpot" icon="gear">
    A HubSpot **dropdown select** property stores a defined set of options; each deal carries one value. Reps pick the partner from the dropdown on the deal record. Because the value lives directly on the deal, it is trivial to filter, list, and report on with native HubSpot tools.
  </Accordion>

  <Accordion title="How Introw configures it" icon="sliders">
    On **Object Linking → How do you attribute partners to Deal objects?**, choose **Custom properties** and select the property. If the property stores coded values (IDs or abbreviations rather than partner names), use **Match property values to Introw partners** to line each value up with the right partner record, so deals resolve correctly.
  </Accordion>

  <Accordion title="Introw-managed dropdown - options stay in sync" icon="arrows-rotate">
    Introw can **own the dropdown's options** and keep them synced to your live partner list - one option per active partner. Add a partner in Introw, the option appears; the picklist never drifts into stale names or typo'd free text. That is the difference between a property that decays and one that stays clean.

    If you have no link yet, pick **No attribution yet** and Introw creates a managed partner dropdown on the Deal object in one click.
  </Accordion>
</AccordionGroup>

| Pros                                                 | Cons                                                                 |
| ---------------------------------------------------- | -------------------------------------------------------------------- |
| Works on **every HubSpot plan** - no upgrade         | One partner per property - add a property per role for multi-partner |
| Simplest to set up and explain                       | Free-text variants drift without an owner                            |
| Native HubSpot filtering, lists, and reports         | No place to store per-partner relationship context                   |
| Introw can manage the options so they never go stale | Coded values need a one-time value-to-partner map                    |

***

## Method 2 - Association label

**Best for:** scalable programs that already associate the partner company to the deal natively, and teams that want to distinguish *how* a partner was involved (sourced vs. influenced).

A **custom association label** between the Deal and the partner **Company** marks which associated company is the partner - for example "Partner sourced" or "Partner influenced".

```mermaid theme={"theme":{"light":"github-light","dark":"github-dark"}}
erDiagram
  DEAL ||--o{ COMPANY : "Partner sourced"
  DEAL ||--o{ COMPANY : "Partner influenced"
  COMPANY {
    string name
    string domain
  }
  DEAL {
    string dealname
    number amount
  }
```

<AccordionGroup>
  <Accordion title="How it works in HubSpot" icon="gear">
    HubSpot associations connect records; an **association label** describes *how* they're related. Labels come in two forms: a **single** label that reads the same from both sides ("Partner"), or a **paired** label with a different word per side ("Referrer" / "Referred by"). You can create up to **50 labels per object pair**, so one deal can carry several partner relationships at once - each under its own label.
  </Accordion>

  <Accordion title="How Introw configures it" icon="sliders">
    Choose **Associations** and pick the association label that represents the partner relationship. Introw reads the labelled association to attribute the deal to the associated partner company. No value mapping is needed - the association *is* the partner record.
  </Accordion>

  <Accordion title="Plan requirement" icon="lock">
    Custom association labels require **Marketing, Sales, Service, Content, or Data Hub Professional or Enterprise**, and a Super Admin creates them. On a Starter plan, use a custom property (Method 1) instead - Introw supports both identically.
  </Accordion>
</AccordionGroup>

| Pros                                          | Cons                                                  |
| --------------------------------------------- | ----------------------------------------------------- |
| Native, scalable HubSpot pattern              | Requires **Professional or Enterprise**               |
| Points at the real partner Company record     | Reps must associate the company, not just type a name |
| Distinguish sourced vs. influenced via labels | Super Admin needed to create the labels               |
| Multiple partners per deal, each labelled     | Up to 50 labels per object pair (rarely a real limit) |

<Tip>
  Association labels are the sweet spot for most growing programs: native to HubSpot, no data drift, and they carry the *relationship type* natively - which powers the multi-tier attribution described below.
</Tip>

***

## Method 3 - Custom object

**Best for:** large programs that model partners as a first-class entity, with tier, region, focus, and program data living on a dedicated record rather than on a Company.

A HubSpot **custom object** (e.g. "Partner") is associated to deals - optionally with association labels to distinguish sourced vs. influenced - and Introw treats that object as the partner.

```mermaid theme={"theme":{"light":"github-light","dark":"github-dark"}}
erDiagram
  PARTNER_OBJECT ||--o{ DEAL : "Sourcing partner"
  PARTNER_OBJECT ||--o{ CONTACT : "partner people"
  PARTNER_OBJECT {
    string partner_name
    enum   tier
    string region
  }
  DEAL {
    string dealname
    number amount
  }
```

<AccordionGroup>
  <Accordion title="How it works in HubSpot" icon="gear">
    A custom object is your own CRM object with its own properties and associations. You model partners on it, associate it to deals (and contacts, companies, tickets, custom objects), and use association labels on those links just as you would with a Company.
  </Accordion>

  <Accordion title="How Introw configures it" icon="sliders">
    Set the **partner object** to your custom object during connect (the "How do you store partners in your CRM?" step). Then attribute deals via **Associations**, selecting the label that links a deal to that partner object. Introw reads the partner object's properties for tier, region, and more - so your rich model flows straight into segments, portals, and reporting.
  </Accordion>

  <Accordion title="Plan requirement" icon="lock">
    Custom objects require a **HubSpot Enterprise** subscription on at least one Hub (Marketing, Sales, Service, Content, or Operations). Enterprise allows up to 10 custom object definitions.
  </Accordion>
</AccordionGroup>

| Pros                                                    | Cons                          |
| ------------------------------------------------------- | ----------------------------- |
| Partners are a first-class object with their own schema | Requires **Enterprise**       |
| Rich per-partner data (tier, region, focus, program)    | Upfront schema design         |
| Clean separation of partners from customer Companies    | More moving parts to maintain |
| Full label support for sourced vs. influenced           | Overkill for small programs   |

***

## Multi-tier attribution - more than one partner on a deal

Real ecosystems rarely have exactly one partner per deal. A referrer surfaces it, a reseller closes it, an implementation partner delivers it. Introw models this natively: **you can define several named attributions on the same object**, each with its own name. This is not limited to associations or a custom object - **every method here can be repeated, including a plain property**: add one property (or label) per role, map each as its own attribution, and one deal credits several partners across tiers.

```mermaid theme={"theme":{"light":"github-light","dark":"github-dark"}}
flowchart LR
  deal["One Deal"]
  deal -->|"label: Partner sourced"| s["Sourcing partner"]
  deal -->|"label: Partner influenced"| i["Influencing partner"]
  deal -->|"property: Implementation partner"| d["Delivery partner"]
```

You can mix and match the mechanisms to express roles:

<CardGroup cols={3}>
  <Card title="Multiple association labels" icon="tags">
    One label per role - "Partner sourced", "Partner influenced" - each its own named attribution.
  </Card>

  <Card title="Multiple properties" icon="tag">
    Separate dropdowns like "Referring partner" and "Delivery partner" on the same deal, each mapped independently.
  </Card>

  <Card title="Custom object roles" icon="cubes">
    Several partner-object records on one deal, each under a role label.
  </Card>
</CardGroup>

<Note>
  Each named attribution is **independently reportable**, so several partners can be credited on one {object_1} - a sourcing partner and an influencing partner side by side - and your commission plans run on whichever attribution(s) you scope them to. Name each attribution clearly and it reads that way in reporting, in the portal, and to partners.
</Note>

***

## Two-way by design - read *and* write

Attribution isn't only about reading what exists. Introw also **writes attribution the same way you defined it**, so the model holds no matter who creates the record.

```mermaid theme={"theme":{"light":"github-light","dark":"github-dark"}}
flowchart LR
  partner["Partner submits<br/>a form in the portal"] --> introw["Introw form automation"]
  introw -->|"creates the record"| record["New record"]
  introw -->|"attaches the partner via<br/>your configured method"| link["Configured attribution"]
  record --- link
  link --> compliant["Record is born<br/>correctly attributed"]
```

<CardGroup cols={2}>
  <Card title="Backwards compatibility" icon="clock-rotate-left">
    Point Introw at your existing model and every historic {object_2} becomes attributable, in the right partner's pipeline. Nothing to backfill.
  </Card>

  <Card title="Data hygiene going forward" icon="broom">
    A partner registering through a form is attached with the **exact method you configured** - compliant from creation, not reconciled later.
  </Card>

  <Card title="No RevOps work either way" icon="circle-check">
    You never restructure {crm_1}. Tell Introw once how objects link to partners; reading old records and writing new ones follow that one definition.
  </Card>
</CardGroup>

***

## Choosing a method

| Your situation                       | Recommended method                        | Plan needed         |
| ------------------------------------ | ----------------------------------------- | ------------------- |
| Starter plan, one partner per deal   | Custom property (Introw-managed dropdown) | Any                 |
| Growing program, native associations | Association label                         | Professional+       |
| Distinguish sourced vs. influenced   | Association labels (one per role)         | Professional+       |
| Multiple partners / roles per deal   | Multiple labels or properties             | Any / Professional+ |
| Large program, rich partner data     | Custom object + labels                    | Enterprise          |

<Tip>
  Whichever you choose, configuration is the same shape: open **Object Linking**, pick the method, name the attribution, decide if it's commission-eligible, save. Introw handles the rest - no code, no consultant.
</Tip>

## Set it up

Whichever method you chose, you configure it in the same place: the **Object Linking** screen. This is the same attribution step the connect wizard runs, reopened any time to add or refine a mapping.

<Tabs>
  <Tab title="Video">
    <video controls playsInline preload="none" poster="https://assets.introw.io/docs/features/integrations/crm/guides/link-hubspot-deals-to-introw/steps/01.png?v=1787341530" className="w-full rounded-xl" src="https://assets.introw.io/docs/features/integrations/crm/guides/link-hubspot-deals-to-introw/video.webm?v=1787341530#t=2.5" />
  </Tab>

  <Tab title="Click through">
    <iframe className="w-full rounded-xl" style={{ width: "100%", aspectRatio: "16 / 11", border: 0, backgroundColor: "#FAFAFA" }} src="https://assets.introw.io/docs/features/integrations/crm/guides/link-hubspot-deals-to-introw/walkthrough.html?v=1787341530" />
  </Tab>
</Tabs>

<Steps>
  <Step title="Open Object Linking">
    Go to [Integrations](https://app.introw.io/settings/integrations?category=crm), open the connected HubSpot connection with **Configure**, and go to **Which objects do you link with partners?**. Select **Add object** to create a mapping, or open the existing **Deal** mapping to edit it. Configure **Deal** at minimum, since deal attribution is what reporting and commissions run on.
  </Step>

  <Step title="Choose how deals attribute to partners">
    On **How do you attribute partners to Deal objects?**, pick the method that matches your data: **Custom properties**, **Associations**, or **No attribution yet** (Introw creates a managed partner property on the Deal object in one click). This mirrors the three methods above.
  </Step>

  <Step title="Configure the method and map values">
    Fill in the detail: for a **property**, select the one that holds the partner; for an **association**, confirm the label that represents the partner relationship. If a property stores coded values rather than partner names, use **Match property values to Introw partners** to line each value up with the right partner record.
  </Step>

  <Step title="Name the attribution and save">
    Set **What name do you want to use for this attribution?** so the link reads clearly to your team and partners (for example "Influencing partner"), then select **Add Deal attribution** (or **Save** when editing). Confirm when Introw asks you to verify. To credit **more than one partner on the same deal**, add another Deal attribution with a different property or label (for example a "Delivery partner" alongside a "Referring partner") - each is its own named attribution. Repeat **Add object** to credit other record types too (contacts, companies, tickets).
  </Step>
</Steps>

## Verify it worked

Open a partner-influenced {object_3} in {crm_2}. In Introw it shows attributed to the right partner under your attribution name, and that partner's sourced/influenced pipeline reflects it in reporting and commissions. For a partner-created {object_3}, confirm the attribution (association, field, or relation row) was written on the {crm_2} record itself.

## Related

<CardGroup cols={2}>
  <Card title="Connect HubSpot" icon="book-open" href="./connect-hubspot">
    Set up the connection and run this attribution step inside the wizard.
  </Card>

  <Card title="Partner attribution in Salesforce" icon="book-open" href="./attribution-in-salesforce">
    The same depth for Salesforce - lookups, relation tables, and roles.
  </Card>

  <Card title="Partner attribution in Pipedrive" icon="book-open" href="./attribution-in-pipedrive">
    The property-based method for Pipedrive.
  </Card>

  <Card title="Show & rename CRM fields" icon="table-columns" href="./show-and-rename-crm-fields">
    Put any HubSpot field on your Introw tables, overviews, and partner views - renamed to partner-friendly labels.
  </Card>
</CardGroup>