Logo Detection: How to Build a Logo Detector

Your brand’s logo is a valuable asset. Which means it’s important to understand how it’s being used and where.

Fortunately, Creating a logo detection engine doesn’t have to be hard. In fact, we’ve created a widget that will build a basic logo detector for your brand in just seconds.

Just put in your company’s URL, and a custom logo detector will be built for you, directly on the page.

Want free access to your logo detector?

The example above highlights what a model can do in seconds - but it’s not perfect.

Fortunately, Nyckel has another turnkey tool that makes it easy to create a production-ready logo detector in just minutes.

Reach out below for access. It’s free, and our API makes it easy to use at scale.

What’s the purpose of logo detection?

Logo detection is a task that scans images to see if they contain your brand’s logo (and, if so, if it’s being used correctly).

For instance:

1. Do all your assets - internal presentations, ads, brochures, etc. - contain your logo?



2. Is that logo being used correctly? (Right orientation / updated logo / not pixelated / etc.)



3. Is someone on the internet misusing your trademarked logo?



4. Is someone using your logo to sell counterfeit goods?

At first glance, monitoring such logo usage may seem daunting, as it involves scanning images across a variety of sources. The good news is, AI makes it easy to accomplish the above tasks. It specifically involves machine learning and building a custom logo detection model. With a tool like Nyckel, you could launch the functionality in just a few hours, without needing machine learning experience.

How exactly does logo detection work?

Logo detection uses image classification to analyze and categorize images by their content.

Classification involves machine learning algorithms — specifically deep learning models like Convolutional Neural Networks (CNNs) — that can identify patterns within images. Examples include a Recyclability Identifier or a Flight Delay Predictor.

With a logo detector, the classification model gets trained on image samples that contain your logo. The more training data you give, the better, so it’s recommended you upload everything possible: banner ads, standalone logo files, favicons, brochures, etc.

At the same time, it’s important to also upload samples that don’t contain your logo. These images should mirror your logo sample formats (for example, if you upload banner ads with your logo, also upload banner ads without your logo).

While machine learning can feel complicated, it doesn’t have to be. SaaS tools like Nyckel can abstract the complexity, making it easy for anyone to create a custom logo detector.

Can logo detection identify off-brand logo usage?

A logo detector can certainly identify right and wrong logo usage.

This can be useful in a few scenarios:

1. A logo refresh/rebrand. Your model can detect what assets still contain the old logo.



2. Asset auditing. No one is perfect, and your marketing team may have made a mistake, like using a pixelated logo on a high-res asset. A logo detection engine can quickly review your assets and identify any errors.
3. Off-brand third-party usage. You can also mine social network data to see if anyone is using your logo incorrectly.

To build these off-brand logo models, you’d want to create a variety of classes, such as:

1. Correct Logo
2. Incorrect Orientation (upside down, slanted, etc.)
3. Blurry
4. Cropped
5. Off-Color
6. No Logo

You’d then need samples for each. This means building out images that purposefully contain incorrect logo usage.

Fortunately, creating these samples can be done programmatically (for the most part). For example, here’s a Python script that creates 15 blurry versions of a logo, each with slightly different blurriness levels. You could run this across multiple images and then upload that set as your “Blurry” class.

import os
import requests
from PIL import Image, ImageFilter
from io import BytesIO

def download_image(image_url):
    """Download an image from a URL."""
    response = requests.get(image_url)
    img = Image.open(BytesIO(response.content))
    return img

def process_and_save_image(img, image_path, suffix, folder):
    """Save the processed image to the specified folder."""
    filename, ext = os.path.splitext(os.path.basename(image_path))
    new_filename = f"{filename}_{suffix}{ext}"
    img.save(os.path.join(folder, new_filename))

def apply_blur_and_save(img, folder, base_filename):
    """Apply different levels of Gaussian blur and save each image."""
    max_radius = 8  
    num_images = 15 
    start_radius = (7 / 24.0) ** 2 * max_radius

    for i in range(num_images):
        scale = i / (num_images - 1)
        radius = ((scale * (max_radius - start_radius)) + start_radius)
        blurred_img = img.filter(ImageFilter.GaussianBlur(radius=radius))
        process_and_save_image(blurred_img, base_filename, f"blur_{i}", folder)

def process_image_from_url(image_url):
    """Process an image from a URL and save versions with varying blurriness."""
    img = download_image(image_url)
    if not os.path.exists('blurred_images'):
        os.mkdir('blurred_images')
    apply_blur_and_save(img, 'blurred_images', os.path.basename(image_url))

image_url = 'https://www.nyckel.com/favicon.png'  # Replace with the actual image URL
process_image_from_url(image_url)

(Not technical? Just copy and paste the above code into a Google Colab notebook. Update the image URL at the bottom, run it, and the images will download to the folder icon.)

If you’re interested in an off-brand logo detection API with these categories prebuilt, please reach out! Nyckel can create it for you.

Why would I track logo usage across the web?

Custom logo recognition also allows for efficient scanning of the web to find unauthorized or counterfeit use of your logo.

Using AI to identify counterfeit goods

If you sell a physical product, logo detection allows you to automatically identify when people are selling counterfeit goods.

You can do this by scraping the major eCommerce sites and sending product images to your logo detection engine. You’d then flag any instance where the model detected your logo.

Let’s say you’re a shoes brand and you’ve had issues with counterfeiters re-selling your items on eBay. They are smart enough not to include your brand name in the listing itself, though (just in the images). So, finding these people isn’t as easy as just doing a search for your brand name.

To address this, you could:

1. First, build a web scraper that searches for key terms, such as 'new running shoes'. Here's an overview of how to scrape eBay.
2. Next, you pull each listing's images. With eBay, your scraper could look for the below strings:



3. Then, send those image URLs via an API to your classification tool, such as Nyckel.



4. Finally, have an alert that pings your legal team should the model find a match. Someone would then manually doublecheck the listing.

This could also be done across social networks like X, Instagram, and TikTok. There are multiple tools in the market - like SmartProxy - that help brands build such scrapers.

Using logo detection to find logo trademark infringement

You can also use your classification model to scan the web for logo trademark infringement, such as:

1. Someone creating a logo that's eerily similar to yours.



A logo detector would most likely return a "yes" for any logo that's strikingly similar.

2. A business using you as social proof without your permission

If either scenario is a concern, you could build web scrapers that scan online forums and business sites for such logo misuse. Then, just connect these scrapers with your classification model, which will surface any offending images.

Using AI to monitor your user community

If you have a community that produces user-generated content, it’s good to mine your channel for on-brand logo usage.

Sometimes community members - thanks to the feeling of community you’ve fomented - will co-op your logo in content they create. And sometimes those people may use it incorrectly, even if they mean well. Scanning your own forums can ensure that all user-generated content aligns with brand standards.

This could be particularly relevant if people are using AI image generators to produce content. These tools are highly likely to produce off-brand versions.

How do I create a logo detector for my brand?

At the top of the article, we offer a widget for easily building a logo detector for your brand’s logo. Just input your company’s URL, and a custom detector will appear on the page.

Then, just reach out to Nyckel for access. It can be used immediately at scale.

How do I connect to a logo detection engine?

Whether you’re using a web scraper, a digital asset manager (like Canto and Adobe Experience Manager, or another asset repository like Google Drive, there are a few ways to integrate.

Below we will use Nyckel as an example, but if you’re an ML expert and want something more complicated, services like Roboflow and Google’s Vertex AI offer logo detection APIs as well.

API

Once your logo detector is trained, you can integrate with the model via APIs. Here, you’d send the image as a URL or as image bytes. The request could look like:

curl -X POST \
  -H 'Authorization: Bearer <accessToken>' \
  -H 'Content-Type: application/json' \
  -d '{"data":"<data>"}' \
  'https://www.nyckel.com/v1/functions/<functionId>/invoke'

The response would provide the prediction:

{
  "labelName": "Contains Nyckel Logo",
  "labelId": "label_2n5a7za51n329v0l",
  "confidence": 0.76
}

In the above response, you can see that the image sample was predicted to include Nyckel’s logo. The confidence score refers to how confident the model is in its prediction (0 to 1, with 1 being the most confident).

User Interface (UI)

Alternatively, you could use the UI. That said, this will likely just be for testing. If you’re using a logo detector, you’re probably using it to identify images at scale. There’s no point to do it one-by-one (your eye works just as well!).

Zapier

You can also connect your scraper or digital asset manager to Nyckel via Zapier, a marketing automation tool.

In the below example, when we upload an image to a specific Google Drive folder, it gets sent to Nyckel for classification and then the prediction populates in Slack.

Here’s that Zap in action:

Integrating using Zapier involves purchasing at least the Starter plan, as you need multi-zap functionality.

How do I monitor the accuracy of my model?

There are a few ways to monitor performance.

-Track your model’s accuracy using a confusion matrix. This visualization shows you how well the predicted labels align with the actual labels.</li>

Above, the binary model rarely identifies the logo as being there when it’s not, but there are many false positives (where “No Logo” images getting incorrectly tagged as “Has Logo”). To address this, you’d upload more training samples for both classes.

-Use active learning, a feature that takes incoming, actual requests and surfaces some for manual review. You’d then audit the predictions and fix any errors as needed, which would help improve the model. This process will give you a sense of how accurate the model is.</li> </ol>

What about prebuilt brand logo identifiers?

The difference between “logo detection” and “logo identifier” can be confusing. In this article, we use logo detection to refer to custom models built specifically for finding one’s own logo. It’s binary classification: “does the asset include my logo or not?”

We believe, meanwhile, that the phrase “logo identifier” should refer to a tool that identifies what brand a given logo represents (from a predefined list).

Others don’t necessarily use the same terminology. EdenAI, for example, has a Logo Detection category that is just prebuilt APIs for identifying other brand’s logos.

Whether you want to call them “logo identifiers” or “logo detectors,” these prebuilt tools all do the same thing: they ingest an image and identify what well-known brand logos are visible.

These solutions, then, are not alternatives to a logo detector trained off your brand’s logos. They also won’t work for identifying off-brand logo usage (blurry, cropped, etc.).

If your goal is to detect and monitor your own logo across internal or external assets, your best bet is building your own logo detection engine.

What are my next steps in launching a custom logo detection tool?

We highly recommend trying out the widget above. It’ll create a logo detector for your company’s logo in just seconds. If you like it, you can use it for free, just reach out to us below!