Use Logo.dev in Flutter, Swift, Kotlin, Java, PHP, Apex, and Vue

This page shows two tasks in Flutter (Dart), Swift, Kotlin, Java, PHP, Apex (Salesforce), and Vue:

Show a logo. The Logo.dev CDN is a URL. Your app loads https://img.logo.dev/{domain} with a publishable key, and no server is involved.
Call the API. Brand returns a company’s name, logo, colors, and more as JSON from GET /v2/brands. Call it from your server with a secret key.

For other languages, use the same URL and the same request.

Keys

Get your API keys

Your dashboard has a publishable key for the Logo.dev CDN and a secret key for the Logo.dev API. Every plan includes both.

Key	Prefix	Where it goes
Publishable key	`pk_`	The `token` query parameter. Safe in client code, such as a mobile app or a web page.
Secret key	`sk_`	The `Authorization: Bearer` header. Server code only.

The samples use the placeholders LOGO_DEV_PUBLISHABLE_KEY and LOGO_DEV_SECRET_KEY. Replace LOGO_DEV_PUBLISHABLE_KEY with your publishable key. The server samples read LOGO_DEV_SECRET_KEY from an environment variable, so set it to your secret key. To stop other websites from using your publishable key, add domain restrictions. Restrictions check the Referer header that a web browser sends. Native Flutter, Swift, and Kotlin apps send no Referer, so with restrictions on, their logo requests return 401. Do not turn on restrictions for a key that a native app uses.

Show a logo

Each sample loads the logo for a domain at 64 pixels, with retina=true for dense screens. format=png keeps the background transparent. For the other parameters, see the CDN overview.

company_logo.dart

import 'package:flutter/material.dart';

class CompanyLogo extends StatelessWidget {
  const CompanyLogo({super.key, required this.domain});

  final String domain;

  @override
  Widget build(BuildContext context) {
    return Image.network(
      'https://img.logo.dev/$domain?token=LOGO_DEV_PUBLISHABLE_KEY&size=64&retina=true&format=png',
      width: 64,
      height: 64,
      semanticLabel: '$domain logo',
    );
  }
}

CompanyLogo.swift

import SwiftUI

struct CompanyLogo: View {
    let domain: String

    var body: some View {
        AsyncImage(url: URL(string: "https://img.logo.dev/\(domain)?token=LOGO_DEV_PUBLISHABLE_KEY&size=64&retina=true&format=png")) { image in
            image.resizable().scaledToFit()
        } placeholder: {
            ProgressView()
        }
        .frame(width: 64, height: 64)
        .accessibilityLabel("\(domain) logo")
    }
}

This sample uses Jetpack Compose and Coil. Add io.coil-kt.coil3:coil-compose and io.coil-kt.coil3:coil-network-okhttp to your dependencies.

CompanyLogo.kt

import androidx.compose.foundation.layout.size
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp
import coil3.compose.AsyncImage

@Composable
fun CompanyLogo(domain: String) {
    AsyncImage(
        model = "https://img.logo.dev/$domain?token=LOGO_DEV_PUBLISHABLE_KEY&size=64&retina=true&format=png",
        contentDescription = "$domain logo",
        modifier = Modifier.size(64.dp),
    )
}

Build the URL on the server, and put it in the src of an <img> in your template.

LogoDevUrl.java

import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;

public class LogoDevUrl {
    private static final String PUBLISHABLE_KEY = "LOGO_DEV_PUBLISHABLE_KEY";

    public static String logoUrl(String domain) {
        return "https://img.logo.dev/"
            + URLEncoder.encode(domain, StandardCharsets.UTF_8)
            + "?token=" + PUBLISHABLE_KEY
            + "&size=64&retina=true&format=png";
    }
}

company-logo.php

<?php
$url = 'https://img.logo.dev/' . rawurlencode($domain) . '?' . http_build_query([
    'token' => 'LOGO_DEV_PUBLISHABLE_KEY',
    'size' => 64,
    'retina' => 'true',
    'format' => 'png',
]);
?>
<img
  src="<?= htmlspecialchars($url) ?>"
  alt="<?= htmlspecialchars($domain) ?> logo"
  width="64"
  height="64"
/>

Apex runs on the server, so the logo loads in a Lightning web component. Create a component named companyLogo.

companyLogo.html

<template>
    <img src={logoUrl} alt={altText} width="64" height="64" />
</template>

companyLogo.js

import { LightningElement, api } from "lwc";

export default class CompanyLogo extends LightningElement {
    @api domain;

    get logoUrl() {
        return `https://img.logo.dev/${encodeURIComponent(this.domain)}?token=LOGO_DEV_PUBLISHABLE_KEY&size=64&retina=true&format=png`;
    }

    get altText() {
        return `${this.domain} logo`;
    }
}

In Setup, add https://img.logo.dev to Trusted URLs and allow it for img-src. Without it, Salesforce blocks the image under its Content Security Policy.

Add your publishable key to .env as VITE_LOGO_DEV_PUBLISHABLE_KEY. Vite exposes only variables with the VITE_ prefix to client code.

CompanyLogo.vue

<script setup>
import { computed } from "vue";

const props = defineProps({ domain: { type: String, required: true } });

const src = computed(
  () =>
    `https://img.logo.dev/${encodeURIComponent(props.domain)}?token=${import.meta.env.VITE_LOGO_DEV_PUBLISHABLE_KEY}&size=64&retina=true&format=png`,
);
</script>

<template>
  <img :src="src" :alt="`${domain} logo`" width="64" height="64" />
</template>

If Logo.dev has no logo for a domain, the CDN returns a generated monogram, so the image never breaks. See fallback images.

Call the API

Each sample sends GET https://api.logo.dev/v2/brands?domain=... with the secret key, waits up to 20 seconds, and reads the brand from data. Run it on your server. Never ship the secret key in a mobile app or a web page.

This sample is Dart for a server, such as a Shelf app. Add the http package.

brand.dart

import 'dart:convert';
import 'dart:io';

import 'package:http/http.dart' as http;

Future<Map<String, dynamic>?> fetchBrand(String domain) async {
  final response = await http
      .get(
        Uri.https('api.logo.dev', '/v2/brands', {'domain': domain}),
        headers: {
          'Authorization': 'Bearer ${Platform.environment['LOGO_DEV_SECRET_KEY']}',
        },
      )
      .timeout(const Duration(seconds: 20));

  if (response.statusCode == 200) {
    return jsonDecode(response.body)['data'] as Map<String, dynamic>;
  }
  if (response.statusCode == 202 || response.statusCode == 404) {
    return null;
  }
  throw HttpException('Logo.dev returned ${response.statusCode}');
}

This sample is for server-side Swift, such as Vapor. Do not put it in an iOS app.

Brand.swift

import Foundation
#if canImport(FoundationNetworking)
import FoundationNetworking
#endif

struct BrandResponse: Decodable {
    struct Brand: Decodable {
        struct Logo: Decodable {
            let url: URL
        }

        let name: String
        let domain: String
        let logo: Logo?
    }

    let data: Brand
}

func fetchBrand(domain: String) async throws -> BrandResponse.Brand? {
    var components = URLComponents(string: "https://api.logo.dev/v2/brands")!
    components.queryItems = [URLQueryItem(name: "domain", value: domain)]

    var request = URLRequest(url: components.url!, timeoutInterval: 20)
    let key = ProcessInfo.processInfo.environment["LOGO_DEV_SECRET_KEY"] ?? ""
    request.setValue("Bearer \(key)", forHTTPHeaderField: "Authorization")

    let (data, response) = try await URLSession.shared.data(for: request)
    guard let http = response as? HTTPURLResponse else {
        throw URLError(.badServerResponse)
    }

    switch http.statusCode {
    case 200:
        return try JSONDecoder().decode(BrandResponse.self, from: data).data
    case 202, 404:
        return nil
    default:
        throw URLError(.badServerResponse)
    }
}

This sample is for a JVM server, such as Ktor or Spring. It uses kotlinx-serialization-json.

Brand.kt

import java.net.URI
import java.net.URLEncoder
import java.net.http.HttpClient
import java.net.http.HttpRequest
import java.net.http.HttpResponse
import java.time.Duration
import kotlinx.serialization.json.Json
import kotlinx.serialization.json.JsonObject
import kotlinx.serialization.json.jsonObject

private val client = HttpClient.newHttpClient()

fun fetchBrand(domain: String): JsonObject? {
    val query = URLEncoder.encode(domain, Charsets.UTF_8)
    val request = HttpRequest.newBuilder(URI.create("https://api.logo.dev/v2/brands?domain=$query"))
        .header("Authorization", "Bearer ${System.getenv("LOGO_DEV_SECRET_KEY")}")
        .timeout(Duration.ofSeconds(20))
        .build()

    val response = client.send(request, HttpResponse.BodyHandlers.ofString())
    return when (response.statusCode()) {
        200 -> Json.parseToJsonElement(response.body()).jsonObject.getValue("data").jsonObject
        202, 404 -> null
        else -> error("Logo.dev returned ${response.statusCode()}")
    }
}

This sample uses java.net.http, built in since Java 11. It returns the JSON body. Parse it with the JSON library you already use, such as Jackson or Gson.

LogoDevBrand.java

import java.net.URI;
import java.net.URLEncoder;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;
import java.time.Duration;

public class LogoDevBrand {
    private static final HttpClient CLIENT = HttpClient.newHttpClient();

    public static String fetchBrand(String domain) throws Exception {
        String query = URLEncoder.encode(domain, StandardCharsets.UTF_8);
        HttpRequest request = HttpRequest.newBuilder(
                URI.create("https://api.logo.dev/v2/brands?domain=" + query))
            .header("Authorization", "Bearer " + System.getenv("LOGO_DEV_SECRET_KEY"))
            .timeout(Duration.ofSeconds(20))
            .GET()
            .build();

        HttpResponse<String> response =
            CLIENT.send(request, HttpResponse.BodyHandlers.ofString());
        if (response.statusCode() != 200) {
            throw new IllegalStateException("Logo.dev returned " + response.statusCode());
        }
        return response.body();
    }
}

This sample uses the cURL extension.

brand.php

<?php
function fetchBrand(string $domain): ?array
{
    $curl = curl_init('https://api.logo.dev/v2/brands?' . http_build_query(['domain' => $domain]));
    curl_setopt_array($curl, [
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_TIMEOUT => 20,
        CURLOPT_HTTPHEADER => ['Authorization: Bearer ' . getenv('LOGO_DEV_SECRET_KEY')],
    ]);
    $body = curl_exec($curl);
    $status = curl_getinfo($curl, CURLINFO_RESPONSE_CODE);

    if ($status === 200) {
        return json_decode($body, true, 512, JSON_THROW_ON_ERROR)['data'];
    }
    if ($status === 202 || $status === 404) {
        return null;
    }
    throw new RuntimeException("Logo.dev returned $status");
}

Apex callouts need a Named Credential, which keeps the secret key out of your code. In Setup, create a Named Credential named Logo_dev for https://api.logo.dev. Configure it to send the header Authorization: Bearer LOGO_DEV_SECRET_KEY, with your secret key in place of the placeholder.

LogoDevBrand.cls

public with sharing class LogoDevBrand {
    public static Map<String, Object> fetchBrand(String domain) {
        HttpRequest request = new HttpRequest();
        request.setEndpoint('callout:Logo_dev/v2/brands?domain=' + EncodingUtil.urlEncode(domain, 'UTF-8'));
        request.setMethod('GET');
        request.setTimeout(20000);

        HttpResponse response = new Http().send(request);
        Integer status = response.getStatusCode();

        if (status == 200) {
            Map<String, Object> body = (Map<String, Object>) JSON.deserializeUntyped(response.getBody());
            return (Map<String, Object>) body.get('data');
        }
        if (status == 202 || status == 404) {
            return null;
        }
        throw new CalloutException('Logo.dev returned ' + status);
    }
}

A Vue app runs in the browser, so call the API from a server route. This sample is a Nuxt route.The route spends your API credits, so it accepts only signed-in users and limits each session to 50 lookups a day. Without these checks, anyone who finds the route can look up brands with your secret key. The sign-in check comes from nuxt-auth-utils. Add it with npx nuxi module add auth-utils, or call the check from your own auth library instead.Set NUXT_LOGO_DEV_SECRET_KEY in the server environment, and declare the key in nuxt.config.ts:

nuxt.config.ts

export default defineNuxtConfig({
  modules: ["nuxt-auth-utils"],
  runtimeConfig: {
    logoDevSecretKey: "",
  },
});

server/api/brand.get.ts

const DAILY_LOOKUPS_PER_SESSION = 50;

export default defineEventHandler(async (event) => {
  const session = await requireUserSession(event);

  const domain = String(getQuery(event).domain ?? "").trim().toLowerCase();
  if (!/^[a-z0-9-]+(\.[a-z0-9-]+)+$/.test(domain)) {
    throw createError({ statusCode: 400, statusMessage: "Invalid domain" });
  }

  const counter = `brand-lookups:${session.id}:${new Date().toISOString().slice(0, 10)}`;
  const used = (await useStorage().getItem<number>(counter)) ?? 0;
  if (used >= DAILY_LOOKUPS_PER_SESSION) {
    throw createError({ statusCode: 429, statusMessage: "Daily lookup limit reached" });
  }
  await useStorage().setItem(counter, used + 1);

  const response = await fetch(
    `https://api.logo.dev/v2/brands?domain=${encodeURIComponent(domain)}`,
    {
      headers: { Authorization: `Bearer ${useRuntimeConfig().logoDevSecretKey}` },
      signal: AbortSignal.timeout(20_000),
    },
  );

  if (response.status !== 200) {
    setResponseStatus(event, response.status);
    return null;
  }

  const { data } = await response.json();
  return { name: data.name, logo: data.logo?.url ?? null };
});

Your components call /api/brand?domain=stripe.com. The route returns the brand’s name and logo URL, or null with the Logo.dev status. A request with no session returns 401, and a request over the daily limit returns 429.useStorage() keeps the count in server memory, so the count resets when the server restarts. If you run more than one server, mount a shared storage driver, such as Redis. Logo.dev bills each new domain once per 24 hours. See what is billed.

Handle each status

Only a 200 carries a brand. The samples return no brand for 202 and 404 (Java throws), and throw for any other status.

Status	Meaning	What to do
`200`	The brand is ready.	Use `data`. `data.logo` can be `null`.
`202`	Logo.dev is indexing the brand.	Retry after the `Retry-After` seconds.
`404`	No brand matches.	Show the CDN logo or a placeholder.

data.logo.url is a signed download URL that stops working after about 24 hours. Download the file if you need to keep it. See images. For the full response, see Brand.

Next steps

CDN parameters

Size, format, theme, and lookups by name, ticker, or ISIN.

Brand

Every identifier, field, and status the API returns.

Keys and restrictions

Create keys and limit a publishable key to your domains.

Rate limits

Check the limits before you ship.

Get started

CDN

API

Platform

Switch to Logo.dev

Integrations

Get your logo seen

Comparisons

Support

Use Logo.dev in Flutter, Swift, Kotlin, Java, PHP, Apex, and Vue

Keys

Get your API keys

Show a logo

Call the API

Handle each status

Next steps

CDN parameters

Brand

Keys and restrictions

Rate limits

​Keys

Get your API keys

​Show a logo

​Call the API

​Handle each status

​Next steps

CDN parameters

Brand

Keys and restrictions

Rate limits

Keys

Show a logo

Call the API

Handle each status

Next steps