YYousaf
Guide

GoHighLevel Custom CSS Tutorial

Where to add custom CSS in GoHighLevel, how to scope it so it doesn't break, and copy-ready examples for colors, buttons, and layout tweaks.

YBy Yousaf9 min read

This GoHighLevel custom CSS tutorial shows where to add CSS inside the platform, how to scope it so it doesn't bleed into the rest of the dashboard, and how to write rules that survive GoHighLevel's updates. You'll also get clean, commented examples you can adapt.

Where to add custom CSS in GoHighLevel

There are two places I put GoHighLevel custom CSS, and they don't overlap. The first is the agency-level field under Agency Settings → Company, in the white-label area, where there's a Custom CSS box with a Custom JavaScript box beside it. Anything saved there is injected into the app for every user in every sub-account of your agency. It's the only place that styles the dashboard itself—sidebar, top bar, contacts, conversations, calendars, settings—so it's where a brand theme belongs.

The second is the funnel and website builder. Each page has its own custom CSS field in the page settings, and the funnel-level tracking code field accepts a <style> block if you want rules shared across every page in that funnel. CSS added in the builder renders only on those published pages. It never touches the dashboard, and agency CSS never touches your funnels. I mention this up front because the most common message I get—'I added the CSS and nothing changed'—is almost always CSS in the wrong box.

A few practical notes before you paste anything. The agency field takes raw CSS, not a <style> tag, so don't wrap it. Saving applies it live for every logged-in user on their next page load, which means you're editing production: test on a sub-account nobody is paying for, and keep the CSS in a file on your machine or in a Git repo rather than treating the text box as the source of truth. There's no version history in that box that I've ever found, so if you overwrite something good it's gone. This GoHighLevel custom CSS tutorial assumes you're on a plan that exposes the white-label settings; if you can't find the field, that's the first thing to check.

How to scope CSS so it doesn't break the dashboard

The first mistake everyone makes with GoHighLevel custom CSS is writing rules the way they'd write them for their own site: button { }, a { }, .card { }. Inside HighLevel that's a shotgun. The dashboard is one large single-page app, and a bare button selector hits the primary action in a contact panel, the icon buttons in the conversation toolbar, the pagination controls, the date picker arrows, and a few dozen other things you never looked at. Half of them end up looking wrong, and you find out from a client.

So every selector I write starts from an anchor. An anchor is a container you've verified in DevTools—the ID on the app root or the sidebar, or a semantic attribute like [role="dialog"] or [type="submit"]—and the rule only reaches down from there. #sidebar-v2 a is scoped; a is not. A scoped rule that misfires affects one region of the screen. An unscoped rule that misfires affects the whole product.

Second, keep specificity low on purpose. Wrap your anchors in :where(), which contributes zero specificity, so your rules stay flat and easy to override later. The alternative—stacking classes until you win, then reaching for !important when you still don't—is how people end up in an !important war with the platform's compiled stylesheet, where every new rule needs the flag just to be seen. You'll still need !important in a few places, because HighLevel's styles are compiled and often more specific than anything reasonable you can write. Use it as a deliberate decision on the theme layer (backgrounds, text color, accent) and nowhere else.

Third, prefer HTML attributes over class names whenever both are available. input[type="email"] stays true for as long as the element is an email input; a component-library class stays true until the next build. Fourth, test across screens, not just the one you were staring at: the dashboard home, a contact record, a conversation, a calendar, the settings area, and at least one modal. Resize to tablet width too. HighLevel's layout shifts at narrower widths, and a padding tweak that looked fine on a 27-inch monitor can push the sidebar off-screen at 1024px. The block below shows the difference between an unscoped rule and a scoped one; the intent is identical, the blast radius is not.

css
Unscoped vs. scoped: same intent, very different blast radius.
/* Too broad: hits every button in the app */
button {
  background: #1f6feb;
}

/* Scoped: only submit buttons inside the app root.
   :where() keeps the ID from inflating specificity. */
:where(#app) button[type="submit"] {
  background: var(--brand-accent);
}

Example: customize GoHighLevel theme colors

The fastest way to customize GoHighLevel theme colors across the whole app is to never write a hex value inside a rule. Every theme I ship starts with a token block: the brand palette declared once as CSS custom properties on :root, with every rule referencing a token. When an agency rebrands—and they do, more often than you'd expect—the change is a handful of lines rather than a find-and-replace across a file nobody remembers writing. It's the same approach behind the white-label theme customizer I built for agencies: the UI edits the tokens, and the rules underneath never change.

The first block below is the base token set. The names describe the job of the color, not the color itself—--brand-accent, not --orange—so they still make sense after a rebrand. Two details matter. Declaring on :root makes the tokens available everywhere in the app, including inside modals and drawers that mount outside the main layout. And hover and focus colors get their own tokens instead of being derived in your head; color-mix() works in current browsers if you'd rather derive them, but explicit values are easier for a non-developer at the agency to edit later.

css
Design tokens: declare the palette once, reference it everywhere.
:root {
  /* Surfaces */
  --brand-sidebar: #141a26;
  --brand-header: #ffffff;
  --brand-surface: #f6f7fb;

  /* Text */
  --brand-text: #1c2331;
  --brand-text-muted: #6b7280;
  --brand-text-on-dark: #e8ecf4;

  /* Accent and states */
  --brand-accent: #e8734a;
  --brand-accent-hover: #d1623b;
  --brand-accent-text: #ffffff;
  --brand-focus: rgba(232, 115, 74, 0.35);

  /* Shape */
  --brand-radius: 8px;
}

The second block applies the tokens to the frame of the app. It's deliberately the reduced version—background, text, active state, and nothing structural—because the sidebar is the part of HighLevel that gets rebuilt most often, and a thin layer is a cheap layer to fix. Check in DevTools what marks the active navigation item before relying on .active, and confirm the sidebar ID and header class are still what the app renders today. For the fuller sidebar treatment, including hover states and the navigation header, see how to customize the GoHighLevel dashboard with CSS.

css
A reduced, update-friendly sidebar and header layer built on the tokens.
/* Sidebar frame. Verify the ID in DevTools before relying on it. */
:where(#sidebar-v2) {
  background: var(--brand-sidebar) !important;
}

:where(#sidebar-v2) a {
  color: var(--brand-text-on-dark) !important;
}

:where(#sidebar-v2) a.active {
  background: var(--brand-accent) !important;
  color: var(--brand-accent-text) !important;
}

/* Top bar: color only, nothing structural */
:where(.hl_header) {
  background: var(--brand-header) !important;
  border-bottom: 1px solid #e5e7eb;
}

That's the whole theme layer for the frame: tokens plus about twenty lines. Wire it into a proper white-label customization and the stock look is gone from every screen. The file also stays small as you add to it, because each new rule references tokens that already exist rather than introducing colors of its own.

Example: restyling buttons and inputs

Buttons and form inputs are the second thing an agency notices after the sidebar. They're on every screen, and they're where the platform's own accent color shows through hardest. They're also where naive CSS does the most damage, so this is the example to copy most carefully.

The strategy is to anchor on HTML attributes rather than component classes. A submit button is button[type="submit"] whatever framework rendered it; a text field is input[type="text"] or input[type="email"] regardless of the wrapper around it. Scope those inside the app root so your funnel pages and any embedded third-party widgets are untouched, and pull every color from the token block. The full example is below.

css
Scoped button and input restyle using attribute anchors and tokens.
/* Primary buttons: attribute-anchored, scoped, token-driven */
:where(#app) button[type="submit"] {
  background: var(--brand-accent) !important;
  border-color: var(--brand-accent) !important;
  color: var(--brand-accent-text) !important;
  border-radius: var(--brand-radius);
  font-weight: 600;
  transition: background 120ms ease;
}

:where(#app) button[type="submit"]:hover {
  background: var(--brand-accent-hover) !important;
  border-color: var(--brand-accent-hover) !important;
}

:where(#app) button[type="submit"]:focus-visible {
  outline: 2px solid var(--brand-accent);
  outline-offset: 2px;
}

/* Inputs: shape and focus ring only. Leave sizing alone. */
:where(#app) :is(
  input[type="text"],
  input[type="email"],
  input[type="tel"],
  input[type="search"],
  textarea,
  select
) {
  border-radius: var(--brand-radius);
  border-color: #d5d9e2;
}

:where(#app) :is(input, textarea, select):focus {
  border-color: var(--brand-accent) !important;
  box-shadow: 0 0 0 3px var(--brand-focus) !important;
}

A few choices in that block are worth explaining. I restyle shape, color, and focus; I don't touch height, padding, or font-size on inputs. HighLevel's forms are laid out assuming its own control sizes, and changing them produces misaligned rows in places you'll never test. The focus ring is a box-shadow rather than an outline so it follows the border radius, and :focus-visible on the button keeps keyboard users oriented without drawing a ring on every mouse click. The transition is short on purpose—anything over about 150ms makes a data-entry tool feel sluggish.

Attribute anchors won't catch everything. Plenty of HighLevel buttons are plain <button> elements with a component class and no type, and for those you have two honest options: target the class the platform uses today (verify it in DevTools, and accept that it's the line most likely to need maintenance), or leave them on the default style and let the primary actions carry the brand. If what you actually want is new buttons wired to your own tools, that's a custom buttons job that needs JavaScript; these GoHighLevel custom code examples are the styling layer that sits underneath it.

Why update-safe CSS matters

HighLevel ships to production constantly. The dashboard is a single-page app assembled from components, and when a component is refactored its generated class names can change with no announcement, no changelog entry, and no visible difference to anyone who isn't styling it. CSS pinned to those names stops matching, and because CSS fails silently, nothing errors. The sidebar just goes back to stock one Tuesday morning and your client asks what happened.

You can't prevent that. What you can control is how much of your CSS is exposed to it. I think of every selector as having a shelf life: IDs on structural containers and native HTML attributes are the longest-lived; readable semantic classes with a platform prefix are medium; anything that looks generated or belongs to a UI component library is short. Build the theme on the first group, accept the second where you must, and avoid the third unless the rule is trivial to delete. This is why this GoHighLevel custom CSS tutorial leans so hard on anchors and tokens—they're what makes the next step cheap.

:is() and :where() help in a specific way here: they let you list several candidate anchors in one rule, so the rule keeps working as long as any one of them survives. If HighLevel renames a container, another anchor still matches and the styling holds. It's not a guarantee—you still verify after updates—but it turns a hard break into a graceful one. The block below contrasts a fragile chain with the defensive form.

css
Defensive selector strategy: shallow anchors, attributes, and :where().
/* Fragile: a deep chain of component-library classes.
   Any one of these renaming breaks the whole rule. */
.hl_wrapper .n-layout .n-layout-sider .n-menu .n-menu-item-content {
  color: #fff;
}

/* Defensive: several stable anchors in one rule, zero added
   specificity, and the rule survives if any anchor survives. */
:where(#sidebar-v2, .sidebar-v2-location) a {
  color: var(--brand-text-on-dark) !important;
}

/* Attribute anchor for modals instead of their component class.
   Confirm the role attribute is present in DevTools first. */
:where([role="dialog"]) button[type="submit"] {
  background: var(--brand-accent) !important;
}

The other half of update safety is process. Keep the CSS in a file under version control, with a comment above each selector saying what it targets and when you last verified it. After a platform update, open your test sub-account, walk the five or six screens from the scoping section, and fix anything that's drifted. With tokens and anchors, that check takes me about ten minutes and the fix is usually one line. If the CSS was pasted from a forum post with no structure, the same break can mean re-inspecting every element from scratch. Budget for maintenance either way; the only question is whether it's minutes or an afternoon.

One more boundary worth knowing. CSS can hide an element, but it can't remove it from the page, reorder the navigation, or change a label. The moment the request becomes 'make this say something else' or 'move this above that', you've left CSS, and my guide to GoHighLevel custom JavaScript snippets picks up from there.

When to hire a developer

Everything in this GoHighLevel custom CSS tutorial is doable by an agency owner with a free Saturday and DevTools open. A token block, a scoped button rule, a sidebar recolor—thirty to sixty lines, maintained by whoever wrote them. If that's your whole list, you don't need me. Copy the examples, change the hex values, test on a spare sub-account, and ship it.

The ceiling arrives faster than people expect, though, and it's worth being honest about where it is. Per-client theming—different colors for different sub-accounts—isn't a CSS problem, because the agency field is global; it needs JavaScript that reads the current location and sets an attribute your CSS can key off, and that script has to survive route changes in a single-page app. Hiding features for some users but not others, renaming menu items, restyling the login page without breaking the password-reset flow, or building a theme a non-technical team can edit without touching code are all engineering jobs, not styling jobs. And a theme that has grown to a few hundred rules across every screen needs a maintenance owner, or the first platform update turns it into a liability.

That's the work I do through my GoHighLevel custom CSS service: CSS and JavaScript that's scoped, tokenised, documented, and tested against updates—and when the goal is a product that doesn't look like HighLevel at all, it extends into full white-label customization. If your list is longer than a recolor, tell me what you're trying to build and I'll tell you honestly whether it's a CSS job, a JavaScript job, or a weekend you can handle yourself.

Frequently asked questions

Do I need the white-label plan to add custom CSS to GoHighLevel?

The agency-wide Custom CSS field sits in the white-label area of Agency Settings → Company, so you need a plan that includes white labeling to style the dashboard. Funnel and website pages accept per-page CSS in the builder regardless, but that only affects published pages, not the app interface.

Why isn't my custom CSS showing up in GoHighLevel?

Most often it's in the wrong box: dashboard styling goes in the agency field, page styling goes in the builder. If it's in the right place, check that you didn't wrap it in a <style> tag, hard-refresh to clear the cached stylesheet, and inspect the element to confirm your selector actually matches and isn't being out-specified by the platform's own rule.

Should I use !important in GoHighLevel custom CSS?

Sometimes, and deliberately. HighLevel's compiled styles are often more specific than anything sensible you can write, so colors and backgrounds on the theme layer usually need it. Keep it off layout properties and out of general-purpose rules, and keep your own specificity flat with :where() so you never end up fighting yourself.

Will my custom CSS break when GoHighLevel updates?

Rules anchored to generated class names will eventually stop matching; rules anchored to IDs and HTML attributes last much longer. Nothing in CSS can break data or functionality—the worst case is styling reverting to stock—so keep the CSS in version control and recheck your main screens after each platform release.

Can I apply different CSS to different sub-accounts?

Not with CSS alone, because the agency Custom CSS field applies to every sub-account. Per-client theming needs a small JavaScript layer that identifies the current location and sets an attribute on the page your CSS can target, which is how per-client themes are built in practice.

Can custom CSS hide menu items or change text in GoHighLevel?

CSS can hide an element with display: none, but it stays in the page and the feature remains reachable by URL. Changing labels, reordering navigation, or removing items properly requires JavaScript, which is a different set of risks in a single-page app and deserves its own approach.

Want this built for you?

Hire an engineer who specializes in GoHighLevel — apps, automation and white-label.