DEV Community: Nabeel Krissane

Stopping Fraud Before It Starts: How AI Detects Fake Documents

Nabeel Krissane — Thu, 02 Oct 2025 19:04:22 +0000

Every platform that deals with user identity faces the same challenge:

How do you know if someone is who they say they are?

From financial apps to online marketplaces, fraudsters constantly try to bypass verification by submitting fake IDs, passports, or altered documents. Traditionally, the process of detecting these fakes required manual review — a slow, expensive, and error-prone method.

Today, thanks to AI, we can stop fraud before it starts.

The Growing Problem of Fake Documents

Fake IDs and forged passports aren’t just a problem for governments. Online businesses face them daily:

Marketplaces dealing with fake seller accounts.
Fintech apps preventing fraudulent transactions.
Social platforms stopping bots from pretending to be real users.

The cost of letting a fake slip through isn’t just financial — it damages user trust and makes compliance with regulations harder.

Why AI Is a Game-Changer

Artificial Intelligence (AI) can process and analyze images far faster and more accurately than humans. When applied to identity verification, AI can:

Detect tampered or photoshopped areas.
Recognize whether a document matches real government-issued templates.
Verify if an image truly contains an ID or passport at all.

Instead of relying on people to spot subtle mistakes, AI does it automatically — and in real-time.

How It Works in Practice

Here’s an example using Deep Detect, an AI-powered API that makes document verification simple.

With just one request, you can check if an uploaded file contains a valid ID or passport:


bash
curl -X POST "https://api.deepdetect.ai/check" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://example.com/uploaded-passport.jpg",
    "service": "id-detection"
  }'

Build an ID Document Detection App in Minutes with Deep Detect

Nabeel Krissane — Sat, 27 Sep 2025 15:41:51 +0000

Want to automatically detect ID documents (passports, ID cards, driver licenses) in your app? With Deep Detect you can set up a detection flow in under 15 minutes.

1. Get your API key & services

Sign up at deepdetect.app
You’ll get an API key.
To list available detection services (like ID documents, faces, license plates, etc.), call the services endpoint:

curl --location 'https://deepdetect.app/api/get-services' \
  --header 'dd-api-key: YOUR_API_KEY'

This returns service codes you’ll use when analyzing images.

2. Call the analyze-image endpoint

Basic request (replace SERVICE-CODE with your ID detection service code):

curl --location 'https://deepdetect.app/api/analyze-image' \
  --header 'dd-api-key: YOUR_API_KEY' \
  --form 'image=@"/path/to/file.jpg"' \
  --form 'action="SERVICE-CODE"'

The API responds with predictions + confidence scores. You can decide thresholds (e.g., passport confidence > 0.7).

3. Add a tiny proxy server

Never expose your API key in frontend code. Quick Node.js proxy example:

app.post('/api/detect-id', upload.single('image'), async (req, res) => {
  const form = new FormData();
  form.append('image', fs.createReadStream(req.file.path));
  form.append('action', process.env.DD_SERVICE);

  const ddRes = await axios.post('https://deepdetect.app/api/analyze-image', form, {
    headers: { 'dd-api-key': process.env.DD_API_KEY, ...form.getHeaders() },
  });

  res.json(ddRes.data);
});

Frontend just uploads to /api/detect-id and shows the result.

4. That’s it 🎉

List services with /api/services.
Detect ID documents with /api/analyze-image.
Wrap it in a small backend proxy.
Use predictions + confidence scores to flag or process ID documents in your app. In minutes, you’ve got a working ID document detection app powered by Deep Detect.

How to Detect NSFW Images in Your Platform Using Deep Detect API

Nabeel Krissane — Sun, 22 Jun 2025 15:46:30 +0000

Ensuring a safe and user-friendly environment on your platform is more critical than ever, especially with the rise of user-generated content across social media, forums, and e-commerce sites. NSFW (Not Safe For Work) images—encompassing explicit adult content, nudity, or sexual activity—can alienate users, damage your brand reputation, and even lead to legal challenges. Fortunately, the Deep Detect API offers a robust solution to detect and filter such content seamlessly. In this post, we’ll dive into how you can integrate this powerful tool into your platform to enhance safety and compliance.

What is Deep Detect?

Deep Detect is a state-of-the-art SaaS platform designed to provide advanced image analysis services tailored for content moderation, security, and compliance. One of its key offerings is the NSFW detection service, accessible via the service code XeAkkf. This feature leverages cutting-edge AI to identify inappropriate content with high accuracy, making it an essential tool for platforms aiming to maintain strict moderation policies. Beyond NSFW detection, Deep Detect supports a wide range of services, from identifying weapons and hate symbols to detecting AI-generated images, offering a comprehensive moderation suite.

Why NSFW Detection Matters

In today’s digital landscape, user trust is paramount. Unmoderated NSFW content can drive away loyal users, attract negative attention, and result in regulatory fines, especially under laws like the EU’s Digital Services Act. Manually reviewing images is time-consuming and impractical for scaling platforms. The Deep Detect API automates this process, allowing you to focus on growth while ensuring a safe environment for your community.

Getting Started with Deep Detect

To harness the power of Deep Detect, you’ll need to sign up at deepdetect.app to obtain an API key. This key unlocks access to all available services, including NSFW detection. The platform offers a flexible pay-as-you-go pricing model, making it accessible for startups and established businesses alike. Once you have your API key, you’re ready to integrate the service into your application.

Python Integration Example

Below is a detailed Python script using the requests library to detect NSFW images with the Deep Detect API. Replace XXX with your actual API key and update the file_path to point to your image file:

import requests

url = "https://deepdetect.app/api/analyze-image"
api_key = "XXX"
file_path = "/path/to/file"

with open(file_path, "rb") as image_file:
    files = {"image": image_file}
    data = {"action": "XeAkkf"}
    headers = {"Accept": "application/json", "dd-api-key": api_key}

    response = requests.post(url, files=files, data=data, headers=headers)

    if response.status_code == 200:
        result = response.json()
        print("NSFW Detection Result:", result)
        if result.get("is_nsfw", False):
            print("Image contains NSFW content. Take action!")
        else:
            print("Image is safe.")
    else:
        print("Error:", response.status_code, response.text)

How to Use the Script

Install Dependencies: Ensure you have requests installed (pip install requests).
Update Credentials: Insert your API key and the path to the image you want to analyze.
Run the Script: Execute it to get a JSON response indicating NSFW status.
Act on Results: Use the output to flag or remove inappropriate content in your platform.

How the Deep Detect API Works

The process is straightforward:

Upload the Image: The script sends the image file to the API endpoint.
Specify the Action: The action parameter set to XeAkkf triggers the NSFW detection service.
Receive the Response: The API returns a JSON object with details, including a boolean indicating NSFW content presence.
Automate Moderation: Integrate the result into your workflow to block or review flagged images.

Benefits of Using Deep Detect

High Accuracy: Powered by advanced AI, it minimizes false positives and negatives.
Ease of Integration: The API is developer-friendly and works with any programming language.
Scalability: The pay-as-you-go plan adapts to your usage, perfect for growing platforms.
Comprehensive Coverage: Beyond NSFW, detect violence (5fK43A), hate symbols (XTv6pq), or copyrighted content (ZEuGTB).
Time-Saving: Automates what would otherwise require extensive manual review.

Expanding Your Moderation Strategy

While NSFW detection is a great starting point, consider combining it with other Deep Detect services for a holistic approach. For instance:

Use 5fK43A to detect violence or gore.
Employ XTv6pq to identify hate symbols.
Leverage ZEuGTB to protect against copyrighted material.

This multi-layered moderation ensures your platform remains safe and compliant across all content types.

Next Steps

Integrate the Deep Detect API into your platform’s content moderation pipeline today. Start with a small test using the provided script, then scale to real-time analysis as needed. Visit deepdetect.app to sign up for a free trial and explore the full range of features. Join a growing community of developers and businesses leveraging Deep Detect to create safer digital spaces.

Happy coding, and let’s build a safer internet together with Deep Detect!

How to Host a Flutter Web App on Microsoft Azure

Nabeel Krissane — Wed, 22 Mar 2023 09:08:12 +0000

Flutter has become an increasingly popular framework for developing cross-platform mobile applications. In addition to mobile apps, Flutter also supports web app development, enabling developers to create responsive and engaging web experiences. Microsoft Azure is a cloud computing platform that provides various services for hosting, deploying, and managing web applications. In this article, we'll guide you through the process of hosting a Flutter web app on Microsoft Azure.

Prerequisites

Before diving into the process, make sure you have the following:

A Flutter web app: Create a new Flutter web app or use an existing one.
Microsoft Azure account: Sign up for a free trial or use your existing account.
Azure CLI: Install the Azure Command-Line Interface (CLI) on your machine.

Build the Flutter Web App

To deploy the Flutter web app, first, you need to build it for production. Open a terminal and navigate to the root directory of your Flutter project. Run the following command:
flutter build web
This command will generate the necessary files for your web app in the build/web directory.

Set Up a Storage Account on Azure

A Storage Account in Azure is used to store and manage your web app's files. To create a new storage account, follow these steps:

Sign in to the Azure portal.
Click on "Create a resource" in the left sidebar.
Search for "Storage Account" and click "Create."
Fill in the required fields, such as subscription, resource group, account name, and location. Click "Review + create" and then "Create" to finalize.

Enable Static Website Hosting

Once your storage account is created, enable static website hosting:

Navigate to your storage account in the Azure portal.
Click on "Static website" under the "Settings" section.
Set "Static website" to "Enabled.".
Set "Index document name" to "index.html" and "Error document path" to "404.html."
Click "Save."

Deploy Your Flutter Web App

Now that your storage account is set up and static website hosting is enabled, you can deploy your Flutter web app. First, sign in to Azure CLI using:
az login
Once logged in, navigate to the build/web directory of your Flutter project and run the following command:
az storage blob upload-batch -s . -d '$web' --account-name <YourStorageAccountName> --account-key <YourStorageAccountKey>
Replace <YourStorageAccountName> and <YourStorageAccountKey> with the appropriate values from your storage account. You can find these in the "Access keys" section of your storage account settings in the Azure portal.

Access Your Flutter Web App

After deploying your web app, you can access it using the provided URL. In the Azure portal, navigate to your storage account and click on "Static website" under the "Settings" section. You'll see the "Primary endpoint" URL. Open this URL in a web browser to see your Flutter web app in action.
And voila your web app is hosted on Microsoft Azure!