Looking for the Brevmont product? Go to brevmont.com

Brevmont Labs research

Research note No. 12

dealer crm dom injection chrome extension

When the API Doesn't Exist, the DOM Is the Answer

9 min readTechnical analysisBrevmont Labs

AI Summary

Many dealer CRM APIs do not expose the depth a workflow-level integration needs at the store's actual configuration. Vendor websites can make the integration landscape look cleaner than it feels in deployment. A new vendor in this category has two practical choices. Build a standalone product the rep has to leave the CRM to use, or ride the rep's authenticated browser session and work inside the page the rep already has open. The standalone path risks becoming another tab the rep ignores. The session-riding path can disappear into the workflow. Browser automation, as a third option, often fails against modern session and bot-detection infrastructure. Chrome extensions ride the rep's session and avoid some of those failure modes. The human is the auth token. That architectural choice matters more than the demo screen.

Source: Brevmont Labs, dealer CRM integration architecture analysis, March 2026.


A vendor's integration page that does not match the deployment reality

Many category-leading dealer CRMs publish integration directories. The directories list partner logos. The marketing copy describes a stack in which the CRM is the hub and other tools plug into it cleanly. The principal evaluating one of these platforms can reasonably conclude that the platform composes with the rest of the dealer's stack.

The deployment reality at the rooftop can diverge from the directory. A store may have lead injection from the dealer website into the CRM, inventory sync from the DMS into the CRM, or a calendar tie to a digital retailing tool. Past those obvious workflows, an integration listed in a directory may still depend on the dealer's license, configuration, vendor relationship, or data permissions.

This is the API gap the next-layer vendor encounters. The CRM publishes integration documentation. The documentation describes endpoints that, at the dealer's specific configuration, are not enabled, not licensed, not configured, or not technically capable of carrying the data depth a real integration would require. Building against the documented APIs produces a vendor relationship that depends on configurations the dealer's specific deployment does not have.

A new vendor that wants to operate inside the rep's daily workflow has to make an architectural decision in front of this gap. The decision determines whether the product gets used.

The two paths

The first path is the standalone product. A separate web application or desktop tool. The rep logs into it through a separate authentication, opens it in a separate tab or window, and uses it alongside the CRM. The standalone product can have a polished UI, fast performance, and a clean data model. It can be everything the CRM is not.

The standalone product also has a structural problem. The rep has to leave the CRM to use it. The dealer rep is already operating across many simultaneous tabs. The standalone product becomes one more tab the rep might not open. The product gets blamed. The rep gets blamed. The architecture deserves scrutiny too, because the tool lives outside the rep's existing surface.

The second path is the layer that rides inside the existing surface. A Chrome extension can read visible customer context from the DOM where the rep is already looking at it. It can prepare a draft, help with a CRM-ready note, or support the same workflow the rep would otherwise complete by hand. The rep does not change tabs.

This is why the browser-surface path is worth taking seriously. The rep does not have to adopt a new system of record. The rep has to learn one new control near the screen already doing the work. The friction is lower because the context switch is lower.

The architectural decision is not the entire product, but it changes the odds. Standalone tools have to win attention. Browser layers can start inside the attention the rep already has.

The architectural test

Before building against any SaaS without a deep API, the architectural test reduces to two questions.

Can data be read from the DOM. The CRM renders the customer record on the page. The browser exposes that record as HTML. An extension can parse the HTML and extract the fields the rep is looking at. If the data is on the page, the data is readable.

Can writes be triggered through DOM events. The rep types a note into the activity log by pressing keys, clicking buttons, and moving the mouse. The browser exposes those events as APIs the extension can dispatch. An extension can synthesize the same sequence of events and write the note as if the rep had typed it. If the typing path exists for a human, the typing path exists for the extension.

In the CRM surfaces Brevmont has worked against, both questions have been testable enough to support useful workflows. The DOM is rendered. Events can often be matched. The vendor's failure to ship a deep API is not always the end of the integration story. It can be the beginning of a different integration architecture.

This was not always true. Older CRMs ran on rendered HTML that was harder to parse, and event APIs were less standardized. Modern browser applications often produce DOM and event patterns that an extension can inspect and test. The technical conditions are better than they used to be, though every target surface still has to be validated directly.

The auth-token observation

The reason browser extensions work where browser automation fails is the authentication problem.

Modern web applications protect themselves against scripted access through layers of session validation. Cookies. Tokens. Browser fingerprints. Bot-detection scoring. Captchas at the threshold. A script running in a server somewhere, trying to log in as a salesperson and pull data from the CRM, will hit one of these layers within minutes. The session expires. The token rotates. The fingerprint does not match. The bot detector flags the activity. The script is locked out.

This is the failure mode Brevmont has seen in browser-automation experiments. Playwright. Puppeteer. Headless Chrome. The work can function briefly and then break when the session, fingerprint, or interaction pattern stops matching normal user behavior. The architectural model is fragile.

The Chrome extension model inverts the problem. The extension does not authenticate. The rep authenticates. The rep logs into the CRM the same way he has always logged in. The extension rides on the rep's authenticated session. The extension does nothing the rep could not do himself with his own keyboard. The CRM cannot tell the difference between the rep's clicks and the extension's clicks because there is no real difference at the protocol level.

The human is the auth token. The extension is the layer that gives the human leverage. Browser automation tries to forge the human. Chrome extensions ride the human. The first dies. The second lives.

Why this matters more than it sounds like

This is not a technical footnote. It is an architectural constraint for dealer software. Deep APIs are uneven across the category. Integration directories can read cleaner than the deployment reality. The integrations that get built by small teams may be the ones that work inside the customer's existing browser session.

That constraint shapes everything downstream. The product surface is the existing tool, not a new tab. The data layer is the DOM and the rep's authenticated session, not a webhook. The deployment model is a Chrome Web Store install and a license key, not a six-month integration project. The pricing model is per-seat per-month, because the value is captured per-rep per-day. The sales motion is to the GM who sees the rep's screen, not to the IT director who sees the integration roadmap.

The vendors who recognize this architectural pattern can build useful workflow layers without waiting for perfect APIs. The vendors who only promise integrations that the dealer cannot actually use will keep leaving room for browser-side execution tools.

What the extension architecture cannot do

Extensions have constraints. They cannot run when the rep is offline. They cannot persist data across sessions without backend infrastructure. They cannot reach into systems the browser does not access. They are limited to what the rep is currently looking at.

These constraints sound like limits. They are also the reason the architecture works. The extension can only act when the rep is acting. It cannot blast a thousand customers in the background. It is bounded by the human's working hours and presence. That bound is a feature, not a defect. The customer does not get spammed. The CRM does not flag the activity. The rep stays in the loop on every action that uses his identity.

The pieces of the workflow that need to run when the rep is not present, including overnight lead ingestion or scheduled reactivations, live on a backend. The backend talks to the extension when the rep is online. The rep's session does the visible work. The backend does the invisible work. Both respect the auth-token rule.

This hybrid is the right architecture for a tool that rides a human relationship. The relationship belongs to the rep. The system has no auth token of its own.

For the commercial workflow this architecture supports, see Brevmont's page on Facebook Marketplace lead capture for dealers. The page describes the buyer-conversation use case. This essay explains the browser-side architecture pattern.

What this looks like five years from now

Over time, tools that demand a new login and a new tab will have to prove they are worth the attention cost. Some will be. Many will not. The tools that live inside the rep's browser session have a different adoption problem because they begin closer to the work.

The CRMs themselves may improve their APIs. They may publish more integrations. But dealer software economics still reward lock-in, and that means workflow vendors should not build their entire product truth on the hope of perfect API access.

The new layer is where practical execution software can live. The extension that drafts reviewed generations, prepares notes, and supports CRM work can become the surface the rep notices. The CRM remains the system of record.

When integration is impossible at the API layer, the answer is the DOM. The human is the auth token. Browser automation tries to forge the auth token and fails. Extensions ride it and win.

This is the architectural decision Brevmont is betting on. The category does not need another standalone tab pretending the CRM boundary is clean. It needs a layer that respects where the rep already works.


*Brevmont Labs publishes analysis on the execution layer beneath relationship-driven sales. The architectural arguments in this essay should be validated against each target CRM surface before they are treated as implementation proof.*

Research standard

This is company research from the floor.

Brevmont Labs labels each piece by evidence type: observation, experiment, analysis, research finding, or hypothesis. No anonymous quotes. No invented benchmarks. When a claim needs public proof, the essay should say where the proof comes from.

Subscribe

New essays on the 27th of each month.

← Research archive

One email per month. No marketing in between. Unsubscribe one click.