Integrating Draftboard with HubSpot

Updated September 28, 2026: the API details below now match the current Integration API reference.

Relationship Data in Your HubSpot Workflow

HubSpot is where your marketing and sales teams live. Integrating Draftboard's relationship data means your team can see warm paths, personalize outreach, and prioritize accounts without leaving HubSpot.

What You Can Build

1. Custom Properties on Records

Add relationship data to Companies and Contacts:

• Best connector name
• Relationship score
• Path context
• Has warm path (yes/no)

2. Smart Lists & Segmentation

Create lists based on relationship data:

• "High-value accounts with warm paths"
• "Contacts with relationship score > 70"
• "Accounts with no network coverage"

3. Personalized Sequences

Use relationship data in email templates:

• Mention mutual connections
• Reference shared company history
• Adjust tone based on relationship strength

4. Workflow Automation

Trigger actions based on relationship data:

• Alert reps when a warm path is found
• Enroll in different sequences based on score
• Mark the intro as requested in Draftboard when a rep asks for it

Integration Options

Everything below runs on the Draftboard Integration API. Create a token in the Draftboard app under Settings → API Keys; the full reference is at intros.draftboard.com/api.

Option 1: API + Workflows

Use a Custom Code action in HubSpot Operations Hub to call the API. This is the approach the rest of this guide walks through.

Option 2: Automation platforms

Call the API from a generic HTTP request step in Zapier, Make, or a similar tool.

Option 3: Scheduled sync

Pull relationship data on a schedule and write it to HubSpot. GET /api/v1/integration/targets and GET /api/v1/integration/targets/{target_id}/connections accept updatedSince, so each run can fetch only what changed.

Setting Up Custom Properties

On Company records:

On Contact records:

Building with Operations Hub

Step 1: Create a Custom Code Action

In HubSpot Workflows, add a Custom Code action. Store your Draftboard token as a secret named DRAFTBOARD_API_TOKEN and pass the company's name property in as an input field.

Draftboard's company search matches a company by name (or a saved person's name or title), not by domain, and it only knows companies where you have saved targets. The code looks for an exact name match, picks the company's highest-scoring target, and reads the paths to that person:

const axios = require('axios');

// Written on every run with no path, so values from an earlier run don't linger
const NO_WARM_PATH = {
  best_connector: '',
  relationship_score: 0,
  path_context: '',
  has_warm_path: false,
  warm_paths_count: 0,
  best_intro_id: ''
};

exports.main = async (event) => {
  const companyName = (event.inputFields['name'] || '').trim();
  if (companyName.length < 2) {
    return { outputFields: NO_WARM_PATH };
  }
  const headers = { Authorization: `Bearer ${process.env.DRAFTBOARD_API_TOKEN}` };

  // 1. Find the company among the accounts where you have saved targets
  const accountsResponse = await axios.get(
    'https://intros.draftboard.com/api/v1/integration/accounts',
    { headers, params: { query: companyName } }
  );
  const account = accountsResponse.data.accounts.find(
    (a) => a.name.toLowerCase() === companyName.toLowerCase()
  );

  if (!account || account.pathsCount === 0) {
    return { outputFields: NO_WARM_PATH };
  }

  // 2. List that company's targets (only targets with a path are returned)
  const targetsResponse = await axios.get(
    'https://intros.draftboard.com/api/v1/integration/targets',
    { headers, params: { accountId: account.id } }
  );
  const bestTarget = [...targetsResponse.data.targets].sort((a, b) => b.score - a.score)[0];

  if (!bestTarget) {
    return { outputFields: NO_WARM_PATH };
  }

  // 3. Read the paths to that target and keep the strongest
  const connectionsResponse = await axios.get(
    `https://intros.draftboard.com/api/v1/integration/targets/${bestTarget.id}/connections`,
    { headers }
  );
  const bestPath = [...connectionsResponse.data.connections].sort((a, b) => b.score - a.score)[0];

  if (!bestPath) {
    return { outputFields: NO_WARM_PATH };
  }

  return {
    outputFields: {
      best_connector: `${bestPath.firstName} ${bestPath.lastName}`,
      relationship_score: account.score,
      path_context: (bestPath.scoreDetails ?? []).join(' '),
      has_warm_path: true,
      warm_paths_count: account.pathsCount,
      best_intro_id: bestPath.id
    }
  };
};

Every list endpoint returns 20 results per page by default, sorted strongest-first for accounts. If a broad name matches more than 20 companies, or a company has more than 20 targets, pass pageNumber and resultPerPage (or read nextPage) to see the rest.

The sample has no try/catch on purpose: if a call fails, for example with a 429 when you go over the rate limit, the action fails instead of overwriting good properties with "no warm path". The company query must be at least 2 characters.

If a company isn't in Draftboard yet, add its people first: import their LinkedIn profile URLs with POST /api/v1/integration/targets/import, or start a search by company domain and job title with POST /api/v1/integration/search/accounts. People found by a search land in your Backlog (the API's /pool) and only become targets once you confirm them with POST /api/v1/integration/pool/confirm. Paths are found asynchronously after that, so a new company can take a while to return results.

Step 2: Create an Enrollment Trigger

Trigger the workflow when:

• Company is created
• Company property is updated
• Manually triggered

Step 3: Update Properties

After the custom code action, add actions to update the Company properties with the returned values.

Using in Sequences

Personalization tokens:

Once relationship data is on Contact records, use it in email templates:

Hi {{contact.firstname}},

{% if contact.connector_name %}
I noticed we're both connected to {{contact.connector_name}} -
{% if contact.shared_company %}
from their time at {{contact.shared_company}}.
{% endif %}
{% endif %}

[Rest of email...]

For shared_company, read the company from the path's relationshipDetails (the employment record). It is only present when Draftboard holds that signal for the pair, so leave the property empty otherwise.

Sequence branching:

Create different sequences based on relationship score:

• Score 70+: "Warm path - direct" sequence (3 emails, confident tone)
• Score 40-69: "Warm path - soft" sequence (4 emails, softer reference)
• Score under 40: "Cold with context" sequence (5 emails, minimal relationship mention)

Smart List Examples

"Warm Path Accounts"

• Company property: `has_warm_path` is true
• Company property: `relationship_score` is greater than 50

"High-Priority Targets"

• Company property: ICP score is greater than 80
• AND Company property: `has_warm_path` is true

"Network Gaps"

• Company property: ICP score is greater than 80
• AND Company property: `has_warm_path` is false

Use these lists for:

• Targeted campaigns
• Rep assignments
• Network expansion focus

Workflow Automation Ideas

Warm Path Alert:

When `relationship_score` is updated to >70 on a Company:

• Send Slack notification to company owner
• Create task: "Request warm intro via [best_connector]"

Sequence Enrollment:

When Contact is created:

• Check relationship score
• Enroll in appropriate sequence based on tier

Intro Status Sync:

When task "Request warm intro" is completed:

• Update deal property: "Warm intro requested = true"
• Call POST /api/v1/integration/intros/{intro_id}/requested with the stored `best_intro_id`, so Draftboard shows the intro as requested too
• Later, mark it with /completed or /declined as the intro lands or falls through

Dashboard & Reporting

Create a custom dashboard with:

• Pie chart: Companies with warm path vs. without
• Bar chart: Average relationship score by deal stage
• Table: Top connectors by available paths
• Funnel: Deals with warm intro involvement

Track over time:

• % of pipeline with warm path involvement
• Win rate by relationship score tier
• Cycle time impact of warm intros

Best Practices

Start simple:

Begin with just the core properties (`has_warm_path`, `relationship_score`, `best_connector`). Add complexity after proving value.

Sync regularly, within the rate limits:

Set up a nightly or weekly sync to keep data fresh. The API has separate read and write rate limits and returns 429 when you go over; the reference lists the current limits and the headers that tell you when to retry.

Train the team:

Ensure reps understand what the properties mean and how to act on them.

Measure everything:

Track conversion rates and cycle times by relationship tier.

Conclusion

HubSpot becomes more powerful when it understands your team's relationships. By syncing Draftboard data to custom properties, you enable smarter segmentation, personalized outreach, and automated workflows that leverage warm paths.

Want the same answers in ChatGPT, Claude, or Codex instead? Connect Draftboard's hosted MCP server - it needs no token.

---

Related Reading

• Draftboard API: Add Relationship Intelligence to Your GTM Stack
• Integrating Draftboard with Salesforce
• Using Relationship Scores in Cold Email Sequences
• LinkedIn MCP: Give Your AI Agent Access to Your Professional Network