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

> ## Agent Instructions
> Brandfetch returns real company logos, brand data, and brand context. It does not design, generate, or edit logos.
> To show a logo in a user interface, use the Logo API as an image URL in an <img> tag, such as https://cdn.brandfetch.io/domain/{domain}?c={CLIENT_ID}. The client ID is public and belongs in frontend code. Never download, proxy, re-host, or optimize these images on a server, because requests that look programmatic are redirected with automated_traffic. In Next.js, this means next/image needs a custom loader or the unoptimized prop.
> To turn a company name that a user types into a domain, use the Brand Search API with the same client ID, and keep only the domain the user picks.
> For colors, fonts, downloadable logo files, and company data as JSON, call the Brand API from a server with the header Authorization: Bearer {API_KEY}, reading the key from an environment variable and never exposing it to the browser. Prefer typed routes such as /v2/brands/domain/{domain} and /v2/brands/ticker/{ticker} over the auto-detect route /v2/brands/{identifier}.
> Use the Brand Context API for a written summary of what a company does, who it sells to, and how it sounds, and the Transaction API to identify the merchant behind a card or bank transaction label.
> When a request fails, branch on the x-bf-error header code rather than on the status code or the message text. Every code, and what to do about it, is listed at https://docs.brandfetch.com/concepts/errors.
> Requests for brandfetch.com are free on the Brand API and Brand Context API, so use that domain in tests and examples.
> Brand API responses can be cached for up to 30 days, while Logo API images must be hotlinked rather than stored and Brand Search results must not be stored at all. See https://docs.brandfetch.com/concepts/caching.
> If the user has no credentials yet, https://brandfetch.com/auth.md explains how they get a client ID and an API key. An agent without an account can pay $0.10 per Brand API, Brand Context API, or Transaction API request with x402 or MPP, as described at https://docs.brandfetch.com/agents/pay-per-request.

# Logo walls and customer logos

> Build a customer logo wall, logo carousel, or animated logo grid from a list of domains, with logos that stay current, balance by size, and switch versions in dark mode

A logo wall is the row of customer, partner, or investor logos that sits under a hero or next to a pricing table, and it's usually built by hand: someone downloads each logo, resizes it, fixes the ones that vanish in dark mode, and starts again when a customer rebrands. With the [Logo API](https://docs.brandfetch.com/logo-api/overview.md), each logo is an image URL keyed by the company's domain, so the wall becomes a list of domains and a little layout, and it stays current without anyone touching it.

## Customer logo grid

A grid of wordmarks with a fixed column count keeps every row full, and each logo sits centered in a cell of the same height. This one also sizes each logo by its shape and switches to the light version of every logo in dark mode, both of which are explained below the code.

> [tab] Preview
>
> Preview

> [tab] Code
>
> ```tsx CustomerLogos.tsx theme={null}
> import { useEffect, useRef, useState } from "react";
>
> const CLIENT_ID = "YOUR_CLIENT_ID"; // free client ID from developers.brandfetch.com/register
>
> const DOMAINS = [
>   "airbnb.com", "github.com", "google.com", "intel.com",
>   "okta.com", "canva.com", "attio.com", "linkedin.com",
> ];
>
> // give every logo about the same area, so wide wordmarks and square marks look equally heavy
> const AREA = 2304; // a 4:1 wordmark renders at about 96 × 24
> const heightFor = (img: HTMLImageElement) =>
>   Math.min(40, Math.max(16, Math.sqrt(AREA / (img.naturalWidth / img.naturalHeight))));
>
> const logo = (domain: string, theme: "light" | "dark") =>
>   `https://cdn.brandfetch.io/domain/${domain}/h/80/theme/${theme}/fallback/404/logo?c=${CLIENT_ID}`;
>
> function LogoTile({ domain }: { domain: string }) {
>   const onLight = useRef<HTMLImageElement>(null);
>   const onDark = useRef<HTMLImageElement>(null);
>   const [height, setHeight] = useState(28);
>   const [noLight, setNoLight] = useState(false);
>   const [missing, setMissing] = useState(false);
>
>   // with server rendering, an image can finish before React attaches onLoad or onError
>   useEffect(() => {
>     const a = onLight.current;
>     const b = onDark.current;
>     if (a?.complete) a.naturalWidth ? setHeight(heightFor(a)) : setMissing(true);
>     if (b?.complete && b.naturalWidth === 0) setNoLight(true);
>   }, []);
>
>   if (missing) return null;
>
>   return (
>     <div className="flex h-16 items-center justify-center">
>       {/* theme/dark is the logo for light backgrounds */}
>       <img
>         ref={onLight}
>         src={logo(domain, "dark")}
>         alt={`${domain} logo`}
>         style={{ height }}
>         onLoad={(e) => setHeight(heightFor(e.currentTarget))}
>         onError={() => setMissing(true)}
>         className={`w-auto max-w-[80%] object-contain ${
>           noLight ? "dark:brightness-0 dark:invert" : "dark:hidden"
>         }`}
>       />
>       {/* theme/light is the logo for dark backgrounds; some brands don't have one */}
>       {!noLight && (
>         <img
>           ref={onDark}
>           src={logo(domain, "light")}
>           alt={`${domain} logo`}
>           style={{ height }}
>           onError={() => setNoLight(true)}
>           className="hidden w-auto max-w-[80%] object-contain dark:block"
>         />
>       )}
>     </div>
>   );
> }
>
> export function CustomerLogos() {
>   return (
>     <div className="grid w-full grid-cols-2 gap-2 sm:grid-cols-4">
>       {DOMAINS.map((domain) => (
>         <LogoTile key={domain} domain={domain} />
>       ))}
>     </div>
>   );
> }
> ```

Want a customer logo wall in your app? This prompt gives your AI coding tool everything it needs to build it in your framework.

Build a "trusted by" wall of customer or partner logos as a uniform grid with a fixed column count (4 columns, 2 on mobile), so every row stays full. Give each cell a fixed height and center the logo in it.

Fetch each logo from Brandfetch's Logo API (get a free client ID at `https://developers.brandfetch.com/register`):

* Light backgrounds: `https://cdn.brandfetch.io/domain/{domain}/h/80/theme/dark/fallback/404/logo?c=YOUR_CLIENT_ID`
* Dark backgrounds: `https://cdn.brandfetch.io/domain/{domain}/h/80/theme/light/fallback/404/logo?c=YOUR_CLIENT_ID`

Show the version that matches my app's current theme. Some brands have no `theme/light` logo, and the request then returns a 404; in that case show the `theme/dark` logo in dark mode with the CSS filter `brightness(0) invert(1)`, which turns it white. If the `theme/dark` request fails too, leave the brand out of the wall.

Size each logo by area rather than by height, so wide wordmarks and square marks carry the same visual weight: once the image loads, set its height to `clamp(16, sqrt(2304 / aspectRatio), 40)` pixels, where `aspectRatio` is `naturalWidth / naturalHeight`. With server rendering, also check `img.complete` and `img.naturalWidth` after mount, because an image can finish loading before the load and error handlers are attached.

Use the Logo API the intended way: hotlink the CDN URL directly in the image `src`, don't download, cache, or re-host the file. Requests are free with a client ID and always return the brand's current logo.

### Make logos of different shapes look the same size

Logos come in every shape, from square marks to long wordmarks, and giving them all the same height makes the wide ones dominate the row while the square ones look small. The grid above sizes each logo by area instead, so its height follows from its aspect ratio and a 4:1 wordmark renders at about 96 by 24 pixels while a square mark is capped at 40 by 40. Clamping the height between 16 and 40 pixels keeps very wide and very tall logos inside the cell, and the `h/80` in the URL gives a sharp image on high-density screens at any height in that range.

### Show the right version in dark mode

The grid requests `theme/dark`, the logo made for light backgrounds, and `theme/light`, the version made for dark backgrounds, then shows whichever matches the page. Both URLs end in `fallback/404`, so a brand without a light version fails cleanly and gets its regular logo turned white with a CSS filter, and a brand that can't be found drops out of the wall instead of showing the Brandfetch logo in its place. [Dark mode logos](https://docs.brandfetch.com/guides/dark-mode-logos.md) covers the theme option in more depth, including a `<picture>` version that follows the system setting.

## Scrolling logo carousel

An auto-scrolling row loops seamlessly, so it can show two or three times as many logos in the same footprint, which suits long partner lists. The square `icon` variant keeps every mark colorful and the same size, so the row reads as one even band in light and dark mode alike.

> [tab] Preview
>
> Preview

> [tab] Code
>
> ```tsx LogoMarquee.tsx theme={null}
> const CLIENT_ID = "YOUR_CLIENT_ID"; // free client ID from developers.brandfetch.com/register
>
> const DOMAINS = [
>   "shopify.com", "airbnb.com", "nike.com", "discord.com", "slack.com",
>   "stripe.com", "dropbox.com", "reddit.com", "medium.com", "meta.com",
> ];
>
> export function LogoMarquee() {
>   const track = [...DOMAINS, ...DOMAINS]; // duplicate so the loop has no seam
>
>   return (
>     <div className="bf-marquee-fade w-full max-w-[520px] overflow-hidden">
>       <style>{`
>         .bf-marquee-fade { -webkit-mask-image: linear-gradient(to right, transparent, black 12%, black 88%, transparent); mask-image: linear-gradient(to right, transparent, black 12%, black 88%, transparent); }
>         .bf-marquee-track { animation: bf-scroll 22s linear infinite; }
>         .bf-marquee:hover .bf-marquee-track { animation-play-state: paused; }
>         @keyframes bf-scroll { from { transform: translateX(0); } to { transform: translateX(-50%); } }
>       `}</style>
>       <div className="bf-marquee">
>         <div className="bf-marquee-track flex w-max items-center gap-6 py-2">
>           {track.map((domain, i) => (
>             <img
>               key={i}
>               src={`https://cdn.brandfetch.io/domain/${domain}/w/80/h/80/fallback/lettermark/icon?c=${CLIENT_ID}`}
>               alt={`${domain} logo`}
>               className="h-10 w-10 shrink-0 rounded-xl"
>             />
>           ))}
>         </div>
>       </div>
>     </div>
>   );
> }
> ```

Want an auto-scrolling logo carousel in your app? This prompt gives your AI coding tool everything it needs to build it in your framework.

Build an auto-scrolling logo marquee that loops seamlessly.

Render a row of partner logos twice back-to-back (so the loop has no visible seam), each fetched as a square `icon` from `https://cdn.brandfetch.io/domain/{domain}/w/80/h/80/fallback/lettermark/icon?c=YOUR_CLIENT_ID` (get a free client ID at `https://developers.brandfetch.com/register`). Icons are colorful and all the same size, so the band stays even and vivid.

Animate the track horizontally from `translateX(0)` to `translateX(-50%)` on an infinite linear loop (about 15-25s), pause the animation on hover, and fade the edges with a `mask-image` gradient so logos don't appear abruptly.

Use the Logo API the intended way: hotlink the CDN URL directly in the image `src`, don't download, cache, or re-host the file. Requests are free with a client ID and always return the brand's current logo.

## Animated logo wall

A 6×3 grid where every tile flips in 3D on its Y axis to reveal a second brand on the back face, staggered on a diagonal so the wall ripples rather than flipping in unison, which shows 36 brands in the space of 18.

> [tab] Preview
>
> Preview

> [tab] Code
>
> ```tsx FlipWall.tsx theme={null}
> const CLIENT_ID = "YOUR_CLIENT_ID"; // free client ID from developers.brandfetch.com/register
>
> const POOL = [
>   "framer.com", "netflix.com", "airbnb.com", "uber.com", "lyft.com", "doordash.com",
>   "tiktok.com", "snapchat.com", "producthunt.com", "reddit.com", "twitch.tv", "linkedin.com",
>   "discord.com", "medium.com", "google.com", "microsoft.com", "apple.com", "amazon.com",
>   "meta.com", "adobe.com", "salesforce.com", "nvidia.com", "samsung.com", "sony.com",
>   "x.com", "slack.com", "vimeo.com", "dribbble.com", "stripe.com", "github.com",
>   "gitlab.com", "dropbox.com", "zoom.us", "asana.com", "trello.com", "atlassian.com",
> ];
>
> const src = (d: string) =>
>   `https://cdn.brandfetch.io/domain/${d}/w/112/h/112/fallback/lettermark/icon?c=${CLIENT_ID}`;
>
> export function FlipWall() {
>   const tiles = Array.from({ length: 18 }, (_, i) => {
>     const row = Math.floor(i / 6);
>     const col = i % 6;
>     return { a: POOL[i], b: POOL[i + 18], d: -((row + col) * 0.35), i };
>   });
>
>   return (
>     <div className="grid gap-6" style={{ gridTemplateColumns: "repeat(6, 44px)" }}>
>       <style>{`
>         @keyframes bf-flip {
>           0%, 42%  { transform: rotateY(0deg); }
>           50%, 92% { transform: rotateY(180deg); }
>           100%     { transform: rotateY(360deg); }
>         }
>       `}</style>
>       {tiles.map(({ a, b, d, i }) => (
>         <div key={i} style={{ perspective: "700px" }} className="h-11 w-11">
>           <div
>             className="relative h-full w-full"
>             style={{
>               transformStyle: "preserve-3d",
>               animationName: "bf-flip",
>               animationDuration: "6s",
>               animationTimingFunction: "ease-in-out",
>               animationIterationCount: "infinite",
>               animationDelay: `${d}s`,
>             }}
>           >
>             <img src={src(a)} alt={a} className="absolute inset-0 h-full w-full rounded-xl object-contain" style={{ backfaceVisibility: "hidden", WebkitBackfaceVisibility: "hidden" }} />
>             <img src={src(b)} alt={b} className="absolute inset-0 h-full w-full rounded-xl object-contain" style={{ backfaceVisibility: "hidden", WebkitBackfaceVisibility: "hidden", transform: "rotateY(180deg)" }} />
>           </div>
>         </div>
>       ))}
>     </div>
>   );
> }
> ```

Want an animated logo grid that 3D-flips between brands? This prompt gives your AI coding tool everything it needs to build it in your framework.

Build an animated logo wall as a grid (e.g. 6×3) of square icon tiles that flip in 3D to reveal a second brand, so the wall shows twice as many brands as it has slots. Each tile is a card with a front face (brand A) and a back face (brand B) that rotates on its Y axis.

Set `perspective` on the tile wrapper, `transform-style: preserve-3d` on the rotating inner element, and `backface-visibility: hidden` on both faces (the back face pre-rotated `rotateY(180deg)`). Animate the inner element's `rotateY` with a CSS `@keyframes` (0° → 180° → 360°, with holds so each face stays readable), and stagger the `animation-delay` by grid position (row + column) so the flips ripple diagonally across the wall.

Render each face from Brandfetch's Logo API `icon` variant: `https://cdn.brandfetch.io/domain/{domain}/w/56/h/56/fallback/lettermark/icon?c=YOUR_CLIENT_ID` (get a free client ID at `https://developers.brandfetch.com/register`). Use `fallback/lettermark` so a tile never shows a broken image.

Use the Logo API the intended way: hotlink the CDN URL directly in the image `src`, don't download, cache, or re-host the file. Requests are free with a client ID and always return the brand's current logo.

## Inline logo swap

A single rotating slot works inline too, so you can drop it into a headline or a "trusted by" line and cycle several brands through the sentence.

> [tab] Preview
>
> Preview
>
> Trusted by
>
> and 20,000+ teams

> [tab] Code
>
> ```tsx InlineLogoSwap.tsx theme={null}
> const CLIENT_ID = "YOUR_CLIENT_ID"; // free client ID from developers.brandfetch.com/register
>
> const DOMAINS = ["airbnb.com", "slack.com", "discord.com", "linear.app", "stripe.com"];
>
> const src = (d: string) =>
>   `https://cdn.brandfetch.io/domain/${d}/w/96/h/96/fallback/lettermark/icon?c=${CLIENT_ID}`;
>
> export function InlineLogoSwap() {
>   return (
>     <div className="flex items-center gap-3 text-lg font-medium">
>       <style>{`
>         @keyframes bf-logocycle {
>           0%   { opacity: 1; transform: scale(1); }
>           15%  { opacity: 1; transform: scale(1); }
>           20%  { opacity: 0; transform: scale(0.9); }
>           95%  { opacity: 0; transform: scale(0.9); }
>           100% { opacity: 1; transform: scale(1); }
>         }
>       `}</style>
>       <span>Trusted by</span>
>       <span className="relative inline-block h-9 w-9 align-middle">
>         {DOMAINS.map((d, i) => (
>           <img
>             key={d}
>             src={src(d)}
>             alt={d}
>             className="absolute inset-0 h-9 w-9 rounded-lg object-contain"
>             style={{
>               animationName: "bf-logocycle",
>               animationDuration: "10s",
>               animationTimingFunction: "cubic-bezier(0.4, 0, 0.2, 1)",
>               animationIterationCount: "infinite",
>               animationDelay: `${-(i * 2)}s`,
>             }}
>           />
>         ))}
>       </span>
>       <span>and 20,000+ teams</span>
>     </div>
>   );
> }
> ```

Want an inline logo that rotates through brands inside a headline? This prompt gives your AI coding tool everything it needs to build it in your framework.

Build an inline animated logo slot that rotates through several company icons, sized to sit inside a line of text (e.g. "Trusted by \[logo] and 20,000+ teams").

Stack the icons absolutely in a small fixed-size inline-block span and crossfade them with a CSS `@keyframes` animation. With N icons, give each the same keyframe (visible for \~1/N of the cycle, then hidden) and offset each one's `animation-delay` by cycle/N so they rotate one after another. Fetch each icon from `https://cdn.brandfetch.io/domain/{domain}/w/48/h/48/fallback/lettermark/icon?c=YOUR_CLIENT_ID` (get a free client ID at `https://developers.brandfetch.com/register`).

Use the Logo API the intended way: hotlink the CDN URL directly in the image `src`, don't download, cache, or re-host the file. Requests are free with a client ID and always return the brand's current logo.

## Implementation

**1. List your customers by domain**

The domain is all the Logo API needs. If you only have company names, match them to domains first with the [Brand Search API](https://docs.brandfetch.com/brand-search-api/overview.md).

**2. Pick the logo type for the layout**

End the URL with `/logo` for grids of wordmarks, where the company's full name carries the wall, and with `/icon` for carousels, flip walls, and anywhere logos need to be the same square size.

**3. Choose a fallback**

On a wordmark wall, add `fallback/404` and leave out any brand whose request fails, so the Brandfetch logo never lands on your wall. Icon layouts can use `fallback/lettermark` instead, which keeps every tile filled with a monogram.

**4. Hotlink the images**

Point each `<img>` straight at the CDN URL rather than downloading the files, which keeps every logo current when a customer rebrands and is how the free Logo API is meant to be used.

## Other ways to build a logo wall

The same Logo API URLs drive a few ready-made versions, which can save you from writing the component yourself:

* The [shadcn/ui Logo Wall](https://docs.brandfetch.com/integrations/shadcn.md#logo-wall) component takes a list of domains and a column count, and it balances logos by area the same way the grid above does.
* The [PowerPoint macro](https://docs.brandfetch.com/integrations/microsoft-powerpoint.md#build-the-logo-wall) places a grid of logos on the current slide from a list of domains, for decks and sales material.
* In an AI assistant connected to the [Brandfetch MCP server](https://docs.brandfetch.com/mcp/overview.md), the `get_brands` tool fetches up to 25 brands in one call, so you can ask for a logo wall in a chat and get the logos and their URLs back together.

## Pricing

The [Logo API](https://docs.brandfetch.com/logo-api/overview.md) is free with a client ID, and because each logo loads straight from the Brandfetch CDN, a wall on a busy landing page needs no backend, storage, or build step. See [plans](https://brandfetch.com/developers/pricing) for quotas.

## FAQ

> [accordion] How do I make a customer logo wall?
>
> List your customers' domains, point an `<img>` at `https://cdn.brandfetch.io/domain/{domain}/logo?c=YOUR_CLIENT_ID` for each one, and lay them out in a grid with a fixed number of columns. The [grid above](#customer-logo-grid) adds sizing and dark mode on top of that.

> [accordion] How many logos should a logo wall have?
>
> Enough to fill every row of the grid, so a four-column wall works best with 4, 8, or 12 logos. When there are more than that, a [scrolling carousel](#scrolling-logo-carousel) or an [animated wall](#animated-logo-wall) shows more brands in the same space.

> [accordion] How do I make logos of different shapes look the same size?
>
> Size each logo by area instead of giving every logo the same height, so a wide wordmark comes out shorter than a square mark and both carry the same visual weight. The [grid above](#make-logos-of-different-shapes-look-the-same-size) does this with one formula.

> [accordion] How do I show customer logos in dark mode?
>
> Request `theme/light` for dark backgrounds and `theme/dark` for light ones, and show the version that matches the page. Add `fallback/404` so a brand without a light version can fall back to its regular logo turned white with a CSS filter, as described in [Dark mode logos](https://docs.brandfetch.com/guides/dark-mode-logos.md).

> [accordion] Why does the Brandfetch logo appear on my logo wall?
>
> The Logo API returns the Brandfetch logo by default when a brand has no logo of the requested type or theme. Add `fallback/404` to the URL and leave out any logo whose request fails.

> [accordion] Do I need permission to show a customer's logo on my website?
>
> It depends on your agreement with that customer and on the customer's own brand guidelines, so check both before the wall goes live. The [logo fair use guide](https://docs.brandfetch.com/guides/logo-fair-use.md) covers how logos can be used more generally.

## Going further

> [card] [Logo API parameters](https://docs.brandfetch.com/logo-api/parameters.md)
>
> Sizing, type, theme, and fallback options for every logo.

> [card] [Dark mode logos](https://docs.brandfetch.com/guides/dark-mode-logos.md)
>
> Switch logo versions with the system theme or your app's toggle.

> [card] [Get started](https://developers.brandfetch.com/register)
>
> Create a free account and start building.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.