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

# Field mapping reference per CRM

> What object each connector creates, which lead fields land where, and what happens to your email history.

export const Screenshot = ({id, alt, caption, frame = 'browser', url, marks = [], lang = 'en', workspace = 'northwind-outbound'}) => {
  const src = `/images/screenshots/${lang}/${id}.png`;
  const chrome = url ? `app.pipelime.ai/${workspace}${url}` : 'app.pipelime.ai';
  return <figure className={`pl-shot pl-shot--${frame} not-prose`}>
      <div className="pl-shot__frame">
        {frame !== 'bare' && <div className="pl-shot__bar">
            <span className="pl-shot__dots">
              <span className="pl-shot__dot" />
              <span className="pl-shot__dot" />
              <span className="pl-shot__dot" />
            </span>
            <span className="pl-shot__url">{chrome}</span>
          </div>}
        <div className="pl-shot__media">
          <img src={src} alt={alt} loading="lazy" />
          {marks.map(mark => <span key={mark.n} className="pl-shot__mark" style={{
    left: `${mark.x}%`,
    top: `${mark.y}%`
  }} aria-hidden="true">
              {mark.n}
            </span>)}
        </div>
      </div>
      {caption && <figcaption className="pl-shot__caption">{caption}</figcaption>}
    </figure>;
};

Every connector reads the same lead, but the record it creates and the fields it fills are different for each one. This page has the exact shape, connector by connector, and what becomes of your email history once a push succeeds.

<div className="pl-availability">
  <div className="pl-availability__row">
    <div className="pl-availability__label">Where</div>
    <div className="pl-availability__value"><span className="pl-path">Integrations<span className="pl-path__sep">→</span>Integrations<span className="pl-path__sep">→</span>Apps & CRM</span></div>
  </div>

  <div className="pl-availability__row">
    <div className="pl-availability__label">Your role needs</div>
    <div className="pl-availability__value">Read access to Apps & CRM <code>read-integrations</code>. Admin, Member and Viewer have it by default.</div>
  </div>

  <div className="pl-availability__row">
    <div className="pl-availability__label">To create or change</div>
    <div className="pl-availability__value"><code>create-integrations</code> to add one, <code>update-integrations</code> to change one, on top of the permission above.</div>
  </div>

  <div className="pl-availability__note">If you cannot find this in your sidebar, your workspace may have a custom menu configuration. Contact support and we will check it for you.</div>
</div>

A push starts in one of three ways: [automatically](/en/integrations/auto-push-and-stage-filters), from the **Push to CRM** button on a lead, or from a workflow's [**Send to CRM**](/en/workflows/crm-and-integration-blocks) block. All three send the same thing, so everything below applies to all three. The only difference is that the block's picker offers every connector here except Slack.

## What each connector creates

| Connector  | Creates                                                        | Claims the lead                            |
| ---------- | -------------------------------------------------------------- | ------------------------------------------ |
| HubSpot    | A contact                                                      | Yes                                        |
| Salesforce | A Lead record                                                  | Yes                                        |
| Odoo       | A `crm.lead` record                                            | Yes                                        |
| Kommo      | A lead, with an embedded contact and company                   | Yes                                        |
| HeyReach   | An entry in a LinkedIn outreach list, not a CRM record         | Yes, with a made-up ID standing in for one |
| Slack      | No record. A chat message in the channel you connected instead | Never                                      |
| Webhook    | Whatever your endpoint creates                                 | Only if your endpoint echoes an ID back    |

<Note>
  Only one connector ever creates a record for a given lead: HubSpot, Salesforce, Odoo, Kommo and HeyReach are exclusive, and once one of them has claimed a lead an automatic push to the others is skipped. Slack and the webhook connector are additive, so they never claim a lead and a CRM push can still happen afterwards. See [Auto-push analyzed leads and stage filters](/en/integrations/auto-push-and-stage-filters) for exactly how that's decided, and [Push a lead to your CRM manually](/en/integrations/push-to-crm-manually) for the one-off button, which does not check who already owns the lead.
</Note>

## How the name, email and phone are read

Wherever a connector below sends an email or a phone number, it sends the most recently added one, not the first. If a lead has two emails on file, the newer one goes out.

HubSpot, Salesforce, Kommo, HeyReach and the webhook default payload all split the name on the first space: everything before that space becomes a first name, everything after becomes a last name. "Maria Elena Garcia" becomes first name "Maria", last name "Elena Garcia". Odoo sends the whole name in one field instead, and Slack prints it whole in the message.

<Warning>
  A webhook you map yourself is the exception to the rule above. The mapping picker's lead email and lead phone options resolve to the *first* email and *first* phone on the lead. The unmapped default payload further down this page sends the most recent of each. Two webhook connectors on the same lead can send two different addresses for that reason.
</Warning>

## HubSpot

| PipeLime field                                             | HubSpot contact property |
| ---------------------------------------------------------- | ------------------------ |
| First word of the lead's name                              | `firstname`              |
| Rest of the lead's name                                    | `lastname`               |
| Most recently added email                                  | `email`                  |
| Most recently added phone                                  | `phone`                  |
| Job title                                                  | `jobtitle`               |
| The lead's LinkedIn link                                   | `linkedinbio`            |
| Company name                                               | `company`                |
| Company website (its Website-type link, or its first link) | `website`                |
| Company industry                                           | `industry`               |

Company size is never sent. HubSpot's matching property belongs to the Company object, not the Contact, and PipeLime doesn't create a Company object here.

Once the contact exists, a Note is attached in a second call, carrying whichever of these the lead has: the lead's LinkedIn link again, the lead's own description, the company's description and summary, and a list of the company's saved links. Then one email engagement is created per message in the lead's thread, warm-up traffic skipped, each keeping its direction (sent or received), subject and body.

## Salesforce

| PipeLime field                                                | Salesforce Lead field |
| ------------------------------------------------------------- | --------------------- |
| First word of the lead's name                                 | `FirstName`           |
| Rest of the lead's name                                       | `LastName`            |
| Company name, or the literal "Unknown" when the lead has none | `Company`             |
| Most recently added email                                     | `Email`               |
| Most recently added phone                                     | `Phone`               |
| Job title                                                     | `Title`               |
| Company website                                               | `Website`             |
| Company industry                                              | `Industry`            |
| Your workspace's brand name                                   | `LeadSource`          |
| The same note content as HubSpot's, above                     | `Description`         |

Salesforce refuses a Lead without a last name and a company, so both have a fallback. A single-word name (no space in it) becomes the whole `LastName` on its own, with `FirstName` left blank. A lead with no name at all gets the literal "Unknown" as its `LastName`, the same way a lead with no company gets it as its `Company`. `LeadSource` carries PipeLime by default, or your own partner name if the workspace has partner branding.

Activities follow in a second set of calls: one completed Task titled "{brand} — Lead Notes" carrying the consolidated note content, and one completed Task per non-warm-up message, its subject "Email (Sent): {subject}" or "Email (Received): {subject}", body the message text with any HTML stripped out.

## Odoo

| PipeLime field                                                                                                       | Odoo `crm.lead` field |
| -------------------------------------------------------------------------------------------------------------------- | --------------------- |
| The lead's name, or its email, or "{brand} Lead" if it has neither, with the company name appended when there is one | `name`                |
| Lead or Opportunity, from the connector's **Create pushed leads as** setting                                         | `type`                |
| The lead's full name, unsplit                                                                                        | `contact_name`        |
| Company name                                                                                                         | `partner_name`        |
| Most recently added email                                                                                            | `email_from`          |
| Most recently added phone                                                                                            | `phone`               |
| Job title                                                                                                            | `function`            |
| Company website                                                                                                      | `website`             |
| The same note content as HubSpot's, above                                                                            | `description`         |

**Create pushed leads as** sits in the Odoo connect dialog, with **Opportunity** picked for you. Odoo's `description` field is HTML, so line breaks in the notes are converted before they're sent. Email history goes to the record's chatter instead of a separate object: one message per non-warm-up message, each with a small header naming its direction and date, and its full HTML body kept intact rather than stripped.

## Kommo

Kommo is the only connector here that creates a genuinely separate Company object alongside the lead and contact, in one combined request.

| PipeLime field                                                                                                     | Kommo field                     |
| ------------------------------------------------------------------------------------------------------------------ | ------------------------------- |
| The lead's name, or "{brand} lead"                                                                                 | Lead `name`                     |
| Your workspace's brand name                                                                                        | A tag added to the lead         |
| First word of the lead's name, or the lead's email, or "Unknown" if it has neither                                 | Contact `first_name`            |
| Rest of the lead's name                                                                                            | Contact `last_name`             |
| Most recently added email                                                                                          | Contact `EMAIL` custom field    |
| Most recently added phone                                                                                          | Contact `PHONE` custom field    |
| Job title                                                                                                          | Contact `POSITION` custom field |
| Company name (only sent when the lead has one)                                                                     | Company `name`                  |
| Company website (its Website-type link, its first link, or a domain PipeLime found for the company, in that order) | Company `WEB` custom field      |

PipeLime never sets a pipeline or a stage on the created lead, so it drops into your account's default pipeline and first stage. Email history follows in a single second call: one consolidated note with the same content as HubSpot's, plus one note per non-warm-up message, all written as Kommo's own "common" note type.

## HeyReach

HeyReach doesn't create a CRM record. It adds the lead to a list for LinkedIn outreach.

| PipeLime field                  | HeyReach field |
| ------------------------------- | -------------- |
| First word of the lead's name   | `firstName`    |
| Rest of the lead's name         | `lastName`     |
| The lead's LinkedIn link        | `profileUrl`   |
| Company name                    | `companyName`  |
| Job title                       | `position`     |
| Most recently added email       | `emailAddress` |
| City, state and country, joined | `location`     |

No phone number is sent, and there's no note or email history: HeyReach's list call has nowhere to put either. Because the API doesn't return a per-lead ID, PipeLime makes one up so the lead still shows as pushed, in the shape `hr_{list id}_{lead id}`. If HeyReach rejects every lead in the request, the message you see is "HeyReach rejected the lead. Ensure the lead has a valid LinkedIn profile URL or email."

## Slack

Slack is the one connector that creates nothing to look up afterwards. It posts a single chat message to the channel you connected, and once that message is sent there's no further object on Slack's side tying back to the lead.

The message opens with a headline picked from the lead's stage: "New lead", "Lead contacted", "New opportunity", "Meeting booked", "Lead converted" or "Lead closed". Under it sit the lead's name, job title and company, then a small grey line carrying whichever of industry, company size and location the lead has. Next comes a bar labelled "Lead score". That score is not the lead's own: it is read from the most recent non-warm-up message that carries one, and the bar is left out when there is none.

Contact details follow on a single row: the email as a mailto link, the phone as plain text, and LinkedIn and the company website as links. Then the most recent inbound reply, quoted, if the lead has replied. Then the meeting time and a join link, once the lead reaches Meeting Scheduled. The message ends with a button reading "View in" and your workspace's brand name, which opens the lead's own page, and a second reading "Email" and the lead's first name when the lead has an address. None of it is attached to a record, because there is no record: the message itself is the only trace the push leaves.

## Webhook

The webhook connector is the one you configure yourself, choosing your own field names in a mapping. See [Connect a webhook](/en/integrations/connect-a-webhook) for setting that up. Leave the mapping empty, and this fixed default shape goes out instead:

| Key                | Value                                                      |
| ------------------ | ---------------------------------------------------------- |
| `id`               | The lead's own ID                                          |
| `name`             | The lead's full name                                       |
| `first_name`       | First word of the lead's name                              |
| `last_name`        | Rest of the lead's name                                    |
| `email`            | Most recently added email                                  |
| `phone`            | Most recently added phone                                  |
| `job_title`        | Job title                                                  |
| `linkedin_url`     | The lead's LinkedIn link                                   |
| `stage`            | Stage                                                      |
| `status`           | Status                                                     |
| `source`           | Source                                                     |
| `possibility_rate` | The lead's possibility rate                                |
| `tags`             | Tag names                                                  |
| `country`          | Primary location's country                                 |
| `state`            | Primary location's state                                   |
| `city`             | Primary location's city                                    |
| `company_name`     | Company name                                               |
| `company_industry` | Company industry                                           |
| `company_size`     | Company size                                               |
| `company_website`  | Company website (its Website-type link, or its first link) |

`stage` is always one of `untouched`, `contacted`, `opportunity`, `meeting_scheduled`, `converted` or `closed`. `status` is `pending`, `analyzing`, `analyzed` or `error`. `source` is `search`, `import`, `manual`, `automatic`, `website_tracker`, `whatsapp`, `web_form`, `instagram`, `mercadolibre` or `api`.

PipeLime also appends its own keys at the end of every push, mapped or not: `event` (what triggered it), `lead_id` and `sent_at`. A mapping can rename or drop any field above, but never these.

<Screenshot id="integrations/what-gets-pushed-per-crm--webhook-payload" url="/integrations" alt="The webhook test result dialog titled Test delivered, holding a green panel that reads Your endpoint accepted the test payload with an HTTP 200 chip, a What we sent block listing the fixed default payload as formatted JSON with id set to null, a Their reply block showing the endpoint's JSON response, and a Detected record ID line underneath" caption="This same shape reaches any endpoint with no field mapping configured, whether it's a real push or this test. The id reads null here, and lead_id is missing entirely, only because the sample lead behind Send test was never saved. A real push carries the lead's actual id in both." />

Leave the field mapping empty and choose **Send test** to see this exact shape before you save anything. Add a mapping and the test sends the mapped payload instead.

If capturing a record ID is on, which it is by default, PipeLime looks for one in the reply under one of its usual shapes (`id`, `data.id`, `record.id`, and similar), unless you've told it exactly where to look. Find one, and the lead is stamped as synced with that connector, unless a record-creating CRM already claimed it first. Find nothing, and the push still succeeds; it is just never recorded as synced.

## What happens to your email history

| Connector  | Email history                                                                                |
| ---------- | -------------------------------------------------------------------------------------------- |
| HubSpot    | One Note, plus one email engagement per non-warm-up message                                  |
| Salesforce | One consolidated Task, plus one Task per non-warm-up message                                 |
| Odoo       | One chatter note per non-warm-up message                                                     |
| Kommo      | One consolidated note, plus one note per non-warm-up message                                 |
| HeyReach   | None                                                                                         |
| Slack      | None kept afterwards. The most recent reply appears inside the message itself, that one time |
| Webhook    | None automatically. Message content isn't one of the fields a mapping can reach              |

<Warning>
  Every Note, Task, engagement and chatter post above is written in a follow-up call, after the record itself already exists, and a failure there is only ever written to the server log. If that call fails, the contact, Lead or `crm.lead` is still there, and nothing in the app tells you its history is missing.
</Warning>

## Related

<CardGroup cols={2}>
  <Card title="Auto-push analyzed leads and stage filters" icon="send" href="/en/integrations/auto-push-and-stage-filters">
    What triggers an automatic push, which stages it fires on, and every reason a lead is silently skipped.
  </Card>

  <Card title="Connect a webhook" icon="webhook" href="/en/integrations/connect-a-webhook">
    Point PipeLime at any HTTP endpoint, choose the fields to send and what to call them, and test it before you save.
  </Card>

  <Card title="Push a lead to your CRM manually" icon="plug" href="/en/integrations/push-to-crm-manually">
    Send one lead from its own page, and read the badge it leaves behind once it's synced.
  </Card>

  <Card title="Merge variables and lead fields" icon="braces" href="/en/workflows/merge-variables-and-lead-fields">
    The values you can drop into a message or a condition, and the exact names to type.
  </Card>
</CardGroup>