The Data Cleaning Problem

Data is messy. Developers and data analysts can spend up to 80% of their time just cleaning and preparing it. This involves writing custom scripts to handle typos, deduplicate records, and standardize inconsistent entries.

The Flookup API provides powerful, production-ready data cleaning algorithms through a simple API call. This allows you to reclaim that time and focus on your core work of analysis and application building.

What is the Flookup API?

The Flookup API offers a simple, powerful and affordable way to integrate advanced data cleaning and fuzzy matching directly into your applications and workflows.

It is a set of REST endpoints designed to solve common data quality challenges. Built on the same robust algorithms that power our popular Google Sheets add-on, the API makes our core data cleaning technology available programmatically.

It is a developer-friendly tool for anyone who needs to:

• Find approximate matches in a list, for example, "John Smith" versus "J. Smith".
• Calculate the similarity between two strings.
• Deduplicate a list based on how things sound, not just how they are spelled, for example, "Kristin" versus "Cristin".

Why Use a Specialised API?

In software development, you often face a "build Versus buy" decision. While you could develop your own fuzzy matching logic, using a specialised API such as Flookup offers significant advantages:

• Save Development Time:
  Building and testing complex string-matching algorithms is time-consuming. An API provides a production-ready solution in minutes, not weeks.
• Scalability and Maintenance:
  We handle the infrastructure, scaling, and maintenance. As your usage grows, the API scales with you, and you never have to worry about server updates or bug fixes.
• Access to Expert-Level Algorithms:
  Our API is powered by sophisticated, battle-tested algorithms that are continuously refined. You get the benefit of this expertise without becoming a specialist yourself.
• Focus on Your Core Product:
  By outsourcing complex data cleaning, your team can focus its energy on building the unique features that deliver value to your customers.

Core Features: Your Data Cleaning Toolkit

The API provides three powerful, focused endpoints:

1. POST /fuzzyLookup: The workhorse of the API. Give it a value and a table of data and it will find the best match based on a similarity score, even if there are typos or variations. It is the perfect tool for record linkage and data reconciliation.
2. POST /fuzzySimilarity: A straightforward way to get a percentage score of how similar two strings are. It is ideal for validation, scoring or building custom matching logic.
3. POST /uniqueList: Go beyond simple deduplication. This endpoint can create a unique list from your data by removing items that are either "fuzzy" matches, for example, 85% similar or phonetic matches, for example, sound-alikes.

Real-World Use Cases

The Flookup API is a versatile tool for developers, data analysts and anyone working with messy data. Here are a few scenarios where it shines:

E-commerce: Standardizing Supplier Data

Imagine you run an online store and receive product lists from multiple suppliers. "Apple iPhone 15 Pro" from one supplier might be "iPhone 15, Pro, Apple" from another. Use the /fuzzyLookup endpoint to match these variations to your standardised product names, ensuring a clean and consistent product catalogue.

Use the /fuzzyLookup endpoint to match these variations to your standardized product names, ensuring a clean and consistent product catalog.

Marketing: Deduplicating Contact Lists

Before launching an email campaign, you need to clean your contact list. A simple deduplication might miss entries like "John Smith" and "J. Smith".

Use the /uniqueList endpoint with a high similarity threshold to merge these near-duplicates, improving your campaign's accuracy and professionalism.

Internal Tools: Building a Simple Data Cleaner

Your non-technical colleagues often need to clean small CSV files. As a developer, you can build a simple web interface that allows them to upload a file, choose columns to clean, and call the Flookup API on the backend. This empowers your team without requiring them to write any code.

Example: Cleaning Data with Python

Integrating the Flookup API into your data scripts is simple. Here is a quick example using the popular Python requests library to find a match for "acme inc" in a list of company names.

import requests
import json
# Your secret API key
API_KEY = "your_api_key_here"
# The data you want to find a match for
lookup_value = [["acme inc"]]
# The list of potential matches
company_list = [["Acme Corporation"], ["Beta Co"], ["Gamma LLC"]]
payload = {
"apiKey": API_KEY,
"lookup_value": lookup_value,
"table_array": company_list,
"lookup_col": 1,
"index_num": 1,
"threshold": 0.7
}
try:
response = requests.post("https://api.getflookup.com/fuzzyLookup", json=payload)
response.raise_for_status()  # Raise an exception for bad status codes (4xx or 5xx)
data = response.json()
if "result" in data:
print("API call successful!")
print(f"Best match: {data['result'][0][0]}")
print(f"Similarity score: {data['result'][0][1]}")
else:
print(f"API returned an error: {data.get('error', 'Unknown error')}")
except requests.exceptions.RequestException as e:
print(f"An error occurred with the network request: {e}")
except json.JSONDecodeError:
print("Failed to decode JSON from response.")

You Might Also Like

• Fuzzy Matching Algorithms Explained
• Flookup API Documentation