Enrich HubSpot Companies with Apollo, Output.ai and Zapier SDK No OAuth Required

zapier_hubspot_company_enrichment/
├── workflow.ts          # Orchestration — parallel fetch, then map, then upsert
├── steps.ts             # 4 steps: enrich, fetchIndustries, mapIndustry, upsert
├── types.ts             # Zod schemas and TypeScript types
├── prompts/
│   └── map_hubspot_industry@v1.prompt  # Haiku — semantic industry mapping
└── scenarios/
    └── stripe.json      # Test input: Stripe

import { workflow } from '@outputai/core';
import {
  enrichCompanyWithApollo,
  fetchHubspotIndustries,
  mapHubspotIndustry,
  upsertHubspotCompany,
} from './steps.js';
import { workflowInputSchema, workflowOutputSchema } from './types.js';

export default workflow({
  name: 'zapier_company_enrichment',
  description:
    'Enriches a company profile using Apollo via REST API and upserts the result into HubSpot via Zapier SDK',
  inputSchema: workflowInputSchema,
  outputSchema: workflowOutputSchema,
  fn: async (input) => {
    // Steps 1 + 2 -- Enrich via Apollo and fetch HubSpot industry choices in parallel
    const [apolloData, { industries }] = await Promise.all([
      enrichCompanyWithApollo({ website: input.website }),
      fetchHubspotIndustries(),
    ]);

    // Step 3 -- Map Apollo's raw industry string to a valid HubSpot enum (if any)
    const hubspotIndustry = apolloData.industry
      ? (
          await mapHubspotIndustry({
            industry: apolloData.industry,
            hubspotIndustries: industries,
          })
        ).hubspotIndustry
      : undefined;

    // Step 4 -- Upsert the enriched + mapped company into HubSpot via Zapier
    const { hubspotCompanyId, action } = await upsertHubspotCompany({
      ...apolloData,
      hubspotIndustry,
    });

    return {
      companyName: apolloData.name,
      website: input.website,
      hubspotCompanyId,
      apolloData,
      action,
    };
  },
});

import { step } from '@outputai/core';
import { generateText, Output } from '@outputai/llm';
import { enrichOrganization } from '../../shared/clients/apollo.js';
import { createZapierClient } from '../../shared/clients/zapier.js';
import {
  enrichCompanyInputSchema,
  apolloCompanySchema,
  fetchHubspotIndustriesOutputSchema,
  mapHubspotIndustryInputSchema,
  mapHubspotIndustryOutputSchema,
  hubspotUpsertInputSchema,
  hubspotUpsertOutputSchema,
  zapierHubspotResponseSchema,
} from './types.js';

const HUBSPOT_CONNECTION_ID = 'your-hubspot-connection-id';

function extractDomain(website: string): string {
  const url = new URL(website);
  return url.hostname.replace(/^www\./, '');
}

// --- Step 1: Enrich company via Apollo REST API ---

export const enrichCompanyWithApollo = step({
  name: 'enrich_company_with_apollo',
  description: 'Enriches company data using Apollo REST API directly',
  inputSchema: enrichCompanyInputSchema,
  outputSchema: apolloCompanySchema,
  fn: async ({ website }) => {
    const domain = extractDomain(website);
    const org = await enrichOrganization(domain);

    if (!org?.name) {
      throw new Error(`Apollo returned no data for domain: ${domain}`);
    }

    return {
      name: org.name,
      website: org.website_url ?? website,
      domain: org.primary_domain ?? domain,
      industry: org.industry ?? undefined,
      employeeCount: org.estimated_num_employees ?? undefined,
      estimatedRevenue: org.annual_revenue_printed ?? undefined,
      description: org.short_description ?? undefined,
      linkedinUrl: org.linkedin_url ?? undefined,
      city: org.city ?? undefined,
      country: org.country ?? undefined,
      keywords: Array.isArray(org.keywords) ? org.keywords : undefined,
      totalFunding: org.total_funding ?? undefined,
      latestFundingRound: org.latest_funding_round_date ?? undefined,
      fundingStage: org.latest_funding_stage ?? undefined,
    };
  },
});

// --- Step 2: Fetch HubSpot industry enum choices via the Zapier SDK ---

export const fetchHubspotIndustries = step({
  name: 'fetch_hubspot_industries',
  description: 'Fetches available HubSpot industry field choices via Zapier SDK',
  outputSchema: fetchHubspotIndustriesOutputSchema,
  fn: async () => {
    const zapier = createZapierClient();

    const industries: string[] = [];
    for await (const item of zapier
      .listInputFieldChoices({
        appKey: 'hubspot',
        actionType: 'search_or_write',
        actionKey: 'company_crmSearch',
        inputFieldKey: 'industry',
        connectionId: HUBSPOT_CONNECTION_ID,
      })
      .items()) {
      const value = item.value ?? item.key ?? item.label;
      if (value) industries.push(value);
    }

    return { industries };
  },
});

// --- Step 3: Map Apollo's industry string to a HubSpot enum via LLM ---

export const mapHubspotIndustry = step({
  name: 'map_hubspot_industry',
  description: 'Maps a raw industry string to a valid HubSpot industry enum value using an LLM',
  inputSchema: mapHubspotIndustryInputSchema,
  outputSchema: mapHubspotIndustryOutputSchema,
  fn: async ({ industry, hubspotIndustries }) => {
    const { output } = await generateText({
      prompt: 'map_hubspot_industry@v1',
      variables: {
        industry,
        hubspotIndustries: hubspotIndustries.join(', '),
      },
      output: Output.object({ schema: mapHubspotIndustryOutputSchema }),
    });

    return output;
  },
});

// --- Step 4: Upsert into HubSpot via the Zapier SDK ---

export const upsertHubspotCompany = step({
  name: 'upsert_hubspot_company',
  description:
    'Creates or updates a HubSpot company record using enriched Apollo data via Zapier SDK',
  inputSchema: hubspotUpsertInputSchema,
  outputSchema: hubspotUpsertOutputSchema,
  fn: async (input) => {
    const zapier = createZapierClient();

    const domain = input.domain ?? extractDomain(input.website ?? '');

    const inputs = {
      first_search_property_name: 'name',
      first_search_property_value: input.name,
      name: input.name,
      domain: domain ?? '',
      website: input.website ?? '',
      city: input.city ?? '',
      country: input.country ?? '',
      industry: input.hubspotIndustry ?? '',
      numberofemployees: input.employeeCount ? String(input.employeeCount) : '',
      description: input.description ?? '',
      linkedin_company_page: input.linkedinUrl ?? '',
      total_money_raised: input.totalFunding ? String(input.totalFunding) : '',
    };

    const { data: result } = await zapier.apps.hubspot.search_or_write.company_crmSearch({
      inputs,
      connectionId: HUBSPOT_CONNECTION_ID,
    });

    const [record] = zapierHubspotResponseSchema.parse(result);

    return {
      hubspotCompanyId: record.id,
      action: record.isNew ? 'created' : 'updated',
    };
  },
});

import { z } from '@outputai/core';

export const workflowInputSchema = z.object({
  companyName: z.string().describe('The name of the company to enrich'),
  website: z.string().url().describe('The company website URL (e.g. https://acme.com)'),
});

export const apolloCompanySchema = z.object({
  name: z.string(),
  website: z.string().optional(),
  domain: z.string().optional(),
  industry: z.string().optional(),
  employeeCount: z.number().optional(),
  estimatedRevenue: z.string().optional(),
  description: z.string().optional(),
  linkedinUrl: z.string().optional(),
  city: z.string().optional(),
  country: z.string().optional(),
  keywords: z.array(z.string()).optional(),
  totalFunding: z.number().optional().describe('Total funding raised in USD'),
  latestFundingRound: z.string().optional(),
  fundingStage: z.string().optional(),
});

export const workflowOutputSchema = z.object({
  companyName: z.string(),
  website: z.string(),
  hubspotCompanyId: z.string(),
  apolloData: apolloCompanySchema,
  action: z.enum(['created', 'updated']),
});

export const hubspotUpsertInputSchema = apolloCompanySchema.extend({
  hubspotIndustry: z.string().optional(),
});

---
provider: anthropic
model: claude-haiku-4-5
temperature: 0
maxTokens: 256
---

<system>
You are an expert at mapping company industry strings to HubSpot's predefined industry ENUM values.

Given an industry category return the single best-matching HubSpot industry value.

Valid HubSpot industry values:
{{ hubspotIndustries }}

Rules:
- Return EXACTLY one value from the list above
- Pick the closest semantic match even if it's not an exact string match
- If no reasonable match exists, return the closest category
</system>

<user>
Map this industry to a HubSpot industry value:

Industry: {{ industry }}
</user>

import { createZapierSdk } from '@zapier/zapier-sdk';

const zapier = createZapierSdk({
  credentials: { clientId: '...', clientSecret: '...' },
});

const { data: result } = await zapier.apps.hubspot.search_or_write.company_crmSearch({
  inputs: {
    first_search_property_name: 'name',
    first_search_property_value: 'Stripe',
    name: 'Stripe',
    domain: 'stripe.com',
    industry: 'COMPUTER_SOFTWARE',
  },
  connectionId: HUBSPOT_CONNECTION_ID,
});