DEV Community: MarkPy

Python Guide: How to Detect If a Domain Is a Scam

MarkPy — Sun, 14 Dec 2025 17:43:38 +0000

Shopping online and signing up for new websites are everyday activities, but so is stumbling across scam domains. These shady sites may take your money, steal sensitive info, or vanish after operating for only a few weeks. So, how can you tell if a domain is sketchy—before you get burned?

In this complete guide, you’ll learn how to use Python to automatically screen websites for scam signals. You’ll see why and how each check works, get a working script, learn to interpret results, and discover how to tailor it for your needs.

What You'll Learn

Why scam domains are so hard to spot
Which technical signals matter most—and why
How to fetch WHOIS, DNS, HTTPS, and content info in Python
A full script that weighs each check to give you a risk score
How to interpret results wisely (and avoid false positives)
Where to look for deeper verification or more advanced checks

Why Are Scam Domains So Common?

Scammers can create a slick web store or fake landing page in minutes. Most use:

Cheap or free domains registered in the last year, often just weeks ago
WHOIS privacy shields to hide their real identity
No real email setup—just a web form, if that
Broken or missing HTTPS
Aggressive sales or big discounts (to lure impulse buyers)
Almost no “real” policy pages, social proof, or company footprint
Many legitimate startups show some of these signals at first, of course. But the more red flags you spot together, the higher the risk.

Red Flags You Can Automatically Check

Domain Age: Was the website registered in the last few months? Most scams use brand new domains.
WHOIS Privacy: When a domain owner hides behind privacy services (like WhoisGuard, DomainsByProxy), you can’t verify them.
No MX Record: Real businesses usually have a public email setup. Scam sites often don’t bother.
HTTPS/SSL: No HTTPS or expired certificates are big trust issues.
Suspicious On-Page Content: Language like “70% off today only!” and generic “secure checkout” badges are classic scam tactics.
Missing or Fake Contact/Policy Pages: If there’s no easy way to reach out, or refund and privacy policies are missing or copy-pasted, beware.
Each single signal isn’t proof of a scam, but several together raise the odds considerably.

What you'll need:

Python 3.7 or above
Required libraries: python-whois, requests, beautifulsoup4, dnspython, tldextract Install them with: pip install python-whois requests beautifulsoup4 dnspython tldextract

The Python Code Explained

Below is a script that does the following:

Fetches WHOIS info to check domain age and privacy
Checks DNS records for email (MX)
Tries to fetch homepage using HTTPS (and falls back to HTTP)
Scrapes for suspicious text (flash sales, missing policies, trust badges)
Combines evidence into a risk score and verdict
Just fill in your target domain as a command line argument.

import re
import json
import whois
import requests
import dns.resolver
from bs4 import BeautifulSoup
from datetime import datetime, timezone
import tldextract

HEADERS = {"User-Agent": "Mozilla/5.0 (DomainRisk/0.1)"}
TIMEOUT = 10

def domain_age_days(w):
    created = w.get("creation_date")
    if isinstance(created, list): created = created[0] if created else None
    if not isinstance(created, datetime): return None
    if created.tzinfo is None: created = created.replace(tzinfo=timezone.utc)
    return (datetime.now(timezone.utc) - created).days

def whois_privacy(w):
    text = " ".join(str(w.get(k, "")).lower() for k in ["registrar","org","name"])
    return any(t in text for t in ["privacy","proxy","whoisguard","redacted","withheld"])

def resolve_dns(domain):
    out = {"A": [], "MX": []}
    try: out["A"] = [r.to_text() for r in dns.resolver.resolve(domain, "A")]
    except Exception: pass
    try: out["MX"] = [r.to_text() for r in dns.resolver.resolve(domain, "MX")]
    except Exception: pass
    return out

def fetch(url):
    try:
        r = requests.get(url, headers=HEADERS, timeout=TIMEOUT)
        if 200 <= r.status_code < 400: return r.text
    except Exception: pass
    return None

def text_signals(html):
    soup = BeautifulSoup(html, "html.parser")
    text = re.sub(r"\s+", " ", soup.get_text(" ").lower())
    signals = {
        "aggressive_discounts": bool(re.search(r"\b(\d{2,3})% off\b|flash sale|limited time", text)),
        "no_contact_info": not any(k in text for k in ["contact us","email","phone","address"]),
        "no_returns_policy": not any(k in text for k in ["refund","returns","return policy"]),
    }
    trust_imgs = [img for img in soup.find_all("img", alt=True) if "trust" in img.get("alt","").lower()]
    signals["trust_badges_unverified"] = any(img.parent.name != "a" for img in trust_imgs)
    return signals

def risk_score(signals):
    weights = {
        "domain_very_new": 20,
        "whois_privacy": 5,
        "no_mx": 4,
        "no_https": 8,
        "aggressive_discounts": 10,
        "no_contact_info": 10,
        "no_returns_policy": 8,
        "trust_badges_unverified": 8,
    }
    return sum(weights[k] for k, v in signals.items() if v and k in weights)

def analyze(domain):
    ext = tldextract.extract(domain)
    norm = ".".join(p for p in [ext.domain, ext.suffix] if p)
    if ext.subdomain: norm = f"{ext.subdomain}.{norm}"

    w = whois.whois(norm) or {}
    age = domain_age_days(w)
    dns = resolve_dns(norm)
    https_ok = fetch(f"https://{norm}") is not None
    html = fetch(f"https://{norm}") or fetch(f"http://{norm}")

    signals = {
        "domain_very_new": age is None or age < 90,
        "whois_privacy": whois_privacy(w),
        "no_mx": len(dns.get("MX", [])) == 0,
        "no_https": not https_ok,
    }
    if html:
        signals.update(text_signals(html))

    score = risk_score(signals)
    band = "High Risk" if score >= 50 else ("Moderate Risk" if score >= 30 else "Lower Risk")
    return {
        "domain": norm,
        "age_days": age,
        "dns": dns,
        "signals": signals,
        "risk_score": score,
        "risk_band": band,
    }

if __name__ == "__main__":
    import sys
    if len(sys.argv) < 2:
        print("Usage: python scan.py <domain>")
        raise SystemExit(1)
    print(json.dumps(analyze(sys.argv[1]), indent=2))

Running the Script

Save your script as scan.py.
Open your terminal.
Type: pip install python-whois requests beautifulsoup4 dnspython tldextract
To test a domain, type: python scan.py example.com

You’ll get a clear JSON output with:

Domain age
DNS status (especially MX/email)
Aggressive discount detection, missing policies, unverified trust badges
A risk_score and one of: High Risk, Moderate Risk, Lower Risk

Real World Example

Want to see this in action? Here’s a review where an automatic “robot” check was part of catching a likely scam:
CKlinen.com: A Scam Fashion Store Review

Conclusion

With a little Python and the right checks, you can screen for scam domains faster and more accurately than ever before. Stay curious, share what works, and help keep friends and family safe when they shop online.

If you have suggestions or want to contribute improvements to this script, leave a comment or open a GitHub gist—every bit helps in the fight against online fraud!

Extracting Images from a Website Using Python: A Comprehensive Guide

MarkPy — Sun, 08 Oct 2023 22:07:39 +0000

In today's digital age, websites are filled with captivating images that grab users' attention and enhance their browsing experience.
Whether you are building a web scraper, conducting research, or simply want to collect images for personal use, knowing how to extract images from a website programmatically can be a valuable skill.
In this comprehensive guide, we will explore how to achieve this using Python.

Why Extract Images from a Website?

Before diving into the technical aspects, it's crucial to understand why you might want to extract images from a website. Here are a few common use cases:

Data Collection: Extracting images as part of web scraping to collect data for research, analysis, or machine learning projects.
Content Aggregation: Building a content aggregator that collects images from multiple sources for a website, blog, or app.
Backup: Creating a backup of images from your own website or social media profiles.
Visual Recognition: Gathering training data for machine learning models, particularly in computer vision tasks.

Tools and Libraries

Python

Python is a versatile programming language known for its simplicity and readability. It has a vast ecosystem of libraries that make web scraping and image manipulation straightforward.

Requests Library

The Requests library is essential for making HTTP requests to fetch website content. You can use it to download web pages and subsequently parse them.

BeautifulSoup

BeautifulSoup is a Python library used for parsing HTML and XML documents. It is particularly useful for extracting data from web pages and navigating the DOM (Document Object Model).

Selenium

Selenium is a powerful tool for web automation and testing. It can interact with web pages in a way that simulates user behavior, making it invaluable for handling dynamic web content.

Basic Image Extraction with BeautifulSoup

To extract images from a website using BeautifulSoup, you'll follow these steps:

Send an HTTP GET request to the target URL using the Requests library.
Parse the HTML content of the page with BeautifulSoup.
Locate the HTML elements that contain the image URLs.
Extract and download the images to your local machine.

import requests
from bs4 import BeautifulSoup
from urllib.request import urlretrieve

# Send an HTTP GET request
url = 'https://example.com'
response = requests.get(url)

# Parse HTML content
soup = BeautifulSoup(response.text, 'html.parser')

# Find and download images
img_tags = soup.find_all('img')
for img in img_tags:
    img_url = img.get('src')
    if img_url:
        img_name = img_url.split('/')[-1]
        urlretrieve(img_url, img_name)

Here is a breakdown of the code:

Import libraries: The code imports the following libraries:
- requests: This library is used to send HTTP requests.
- bs4: This library is used to parse HTML content.
- urllib.request: This library is used to download files over the internet.
Send an HTTP GET request: The code uses the requests.get() function to send an HTTP GET request to the website https://example.com. The response from the website is stored in the variable response.
Parse HTML content: The code uses the BeautifulSoup() function to parse the HTML content of the response. The parsed HTML content is stored in the variable soup.
Find and download images: The code uses the find_all() method to find all <img> tags in the parsed HTML content. The get() method is used to get the src attribute of each <img> tag. The src attribute contains the URL of the image.
Download images: For each image URL, the code uses the urlretrieve() function to download the image to the current working directory. The image is saved with the filename specified by the img_name variable.

To use this code, simply replace the https://example.com URL with the URL of the website that you want to download images from. Then, run the code and all of the images from the website will be downloaded to the current working directory.

Advanced Image Extraction with Selenium

While BeautifulSoup is excellent for static websites, some sites rely heavily on JavaScript to load content dynamically. In such cases, you may need Selenium to interact with the page and access images.

from selenium import webdriver

# Set up Selenium webdriver
driver = webdriver.Chrome(executable_path='path/to/chromedriver')
driver.get('https://example.com')

# Find and download images
img_elements = driver.find_elements_by_tag_name('img')
for img in img_elements:
    img_url = img.get_attribute('src')
    if img_url:
        img_name = img_url.split('/')[-1]
        urlretrieve(img_url, img_name)

# Close the browser
driver.quit()

Here is a breakdown of the code:

Import library: The code imports the selenium library. This library is used to automate web browsers.
Set up Selenium webdriver: The code creates a new webdriver.Chrome() object. This object represents the Chrome browser. The executable_path parameter specifies the path to the ChromeDriver executable file.
Go to the website: The code uses the get() method to navigate to the website https://example.com.
Find and download images: The code uses the find_elements_by_tag_name() method to find all <img> tags on the page. The get_attribute() method is used to get the src attribute of each <img> tag. The src attribute contains the URL of the image.
Download images: For each image URL, the code uses the urlretrieve() function to download the image to the current working directory. The image is saved with the filename specified by the img_name variable.
Close the browser: The code uses the quit() method to close the Chrome browser.

Conclusion

Extracting images from a website using Python is a valuable skill that opens up numerous possibilities, from data collection to content aggregation and machine learning. With the right tools and libraries at your disposal, you can automate the process and efficiently gather the images you need.

In this guide, we've covered the basics of image extraction using Python, including libraries like Requests, BeautifulSoup and Selenium. Additionally, we've discussed more advanced topics such as handling authentication, dealing with JavaScript-loaded images, and image processing.

As you explore this fascinating field, remember to respect website terms of use and copyright restrictions when extracting and using images.
Happy image extracting!

How to Test Internet Speed in Python

MarkPy — Mon, 06 Dec 2021 20:56:59 +0000

Probably, you have used the speedtest website before, but did you know that speedtest has a python library.

In this tutorial, We will learn to use the speedtest library to test your internet Speed. We'll also learn how to use speedtest command lines.

Let's get started.

Speedtest instalation

To install speedtest via pip, follow this command:

pip install speedtest-cli

Test internet speed (script)

After installing the speedtest package. Now, let's see how to use it with the code.

In the following code, I'll test my internet download speed.

import speedtest

# Speed test
st = speedtest.Speedtest()

# Download Speed
ds = st.download()

print(ds)

let me explain.

First, we import the speedtest package. Then, called Speedtest() class. Next, test my download speed using the download() method. Finally, print the result.

Output:

3422459.073187817

As you can see, the internet speed is in Bytes. To make it readable, we'll use the following function.

def humansize(nbytes):
    suffixes = ['B', 'KB', 'MB', 'GB', 'TB', 'PB']
    i = 0
    while nbytes >= 1024 and i < len(suffixes)-1:
        nbytes /= 1024.
        i += 1
    f = ('%.2f' % nbytes).rstrip('0').rstrip('.')
    return '%s %s' % (f, suffixes[i])

#Readable
print(humansize(ds))

Output:

3.56 MB

Now, let's test the upload speed using the upload() method.

import speedtest

# Speed test
st = speedtest.Speedtest()

# Upload speed
us = st.upload()

print(us)

#Readable
print(humansize(us))

Output:

386382.6586620888
301.51 KB

Speedtest command lines

Speedtest also provides the command lines for testing our internet speed.

Usage:

Help command:

speedtest-cli -h

Output:

usage: speedtest-cli [-h] [--no-download] [--no-upload] [--single] [--bytes]
                         [--share] [--simple] [--csv]
                         [--csv-delimiter CSV_DELIMITER] [--csv-header] [--json]
                         [--list] [--server SERVER] [--exclude EXCLUDE]
                         [--mini MINI] [--source SOURCE] [--timeout TIMEOUT]
                         [--secure] [--no-pre-allocate] [--version]

Command line interface for testing internet bandwidth using speedtest.net.

Test Internet Speed:

speedtest-cli

Output:

    Retrieving speedtest.net configuration...
    Testing from xxx Telecom (196.89.30.99)...
    Retrieving speedtest.net server list...
    Selecting best server based on ping...
    Hosted by xxx Telecom (xxx) [394.57 km]: 29.1 ms
    Testing download speed................................................................................
    Download: 8.30 Mbit/s
    Testing upload speed......................................................................................................
    Upload: 10.33 Mbit/s

This command above tests ping, download, and upload speed.

Test Internet Speed with the share link:

speedtest-cli --share

Output:

    Retrieving speedtest.net configuration...
    Testing from xxx Telecom (196.89.30.99)...
    Retrieving speedtest.net server list...
    Selecting best server based on ping...
    Hosted by xxx Telecom (xxx) [394.57 km]: 28.131 ms
    Testing download speed................................................................................
    Download: 3.74 Mbit/s
    Testing upload speed......................................................................................................
    Upload: 0.39 Mbit/s
    Share results: http://www.speedtest.net/result/12339819892.png

As you can see, we've got a URL of the results. Let's open it in the browser.

Result:

I hope this is easy to understand. See you later.

References

https://pypi.org/project/speedtest-cli/

Python: Test Internet Speed

Understanding Django HttpResponse

MarkPy — Sat, 14 Nov 2020 19:22:53 +0000

HttpResponse() is a class that returns an HTTP response.
in this tutorial, we'll understand how to use HttpResponse with simple examples.

1. HttpResponse

As we said, HttpResponse() returns an HTTP response, so in this first example, we'll write a simple view that returns some HTML contents.

views.py

In our views.py file, we need to add this view function.

from django.http import HttpResponse

def http_response(request):
    return HttpResponse('<h1>Hello HttpResponse</h1>')

urls.py

Now, let's add a path for the view.

path('http-response/', http_response),

Result:

2. HttpResponse with form

In this second example, we'll write a view that we'll use HttpResponse as a form response.

Let's, see the example.

Views.py

In our views, we need to this following view function.

def http_response_form(request):
    if request.method == "POST":
        username = request.POST.get('username')
        if username:
            return HttpResponse(f'<h1>hello {username}</h1>')
        else:
            return HttpResponse('<h1>please, enter your username</h1>')

    return render(request, "HttpResponse.html")

So, after submitting the form, if the username's input is not empty, the browser we'll return hello with the username, else the browser we'll return please, enter your username.

urls.py

Adding a path for ou view.

path('http-response-form', http_response_form, name="httpresponse")

HttpResponse.html

<!DOCTYPE html>
<html>
<head>
    <title>Test httpResponse with form</title>
</head>
<body style="padding-top: 20px">


    <form method="POST" action="{% url 'httpresponse' %}">
        {% csrf_token %}
        <input type="text" name="username">
        <input type="submit" name="submit">
    </form>

</body>
</html>

Now let's test the function.

Submitting "mark" username

Result:

Submitting an empty username.

Result:

How to Use Django HttpResponse

Happy coding!

Get Proxy List by Using Python

MarkPy — Sat, 04 Jul 2020 14:07:45 +0000

In this tutorial, We'll learn how to get a fresh proxy by using Proxyscrape library.

1. Proxyscrape Installation

pip install proxyscrape

2. getting united states proxy

In the first example, we'll get a proxy of united states

import proxyscrape
collector = proxyscrape.create_collector('my-collector', 'http')  # Create a collector for http resources
proxy = collector.get_proxy({'country': 'united states'})  # Retrieve a united states proxy
print(proxy) # print the proxy

So first we have imported the library, then created our collector, finally, chose the country, now let's see the output.

Proxy(host='103.105.49.53', port='80', code='us', country='united states', anonymous=True, type='http', source='free-proxy-list')

Print the host and the port:

print(f"{proxy.host}:{proxy.port}")
#output
103.105.49.53:80

3. Getting proxies list

In this part, we'll get a France list of proxies

syntax:

collector.get_proxies()

Example

proxy = collector.get_proxies({'country': 'france'})  
print(proxy)

Output

[Proxy(host='51.158.123.35', port='8811', code='fr', country='france', anonymous=True, type='http', source='anonymous-proxy'), 
Proxy(host='195.154.233.187', port='3838', code='fr', country='france', anonymous=True, type='https', source='free-proxy-list'), 
Proxy(host='195.154.51.252', port='3838', code='fr', country='france', anonymous=True, type='https', source='free-proxy-list'), 
Proxy(host='195.154.52.142', port='3838', code='fr', country='france', anonymous=True, type='https', source='free-proxy-list'), 
Proxy(host='212.83.140.218', port='3838', code='fr', country='france', anonymous=True, type='https', source='free-proxy-list'), 
Proxy(host='51.158.123.250', port='8811', code='fr', country='france', anonymous=True, type='https', source='free-proxy-list'), 
Proxy(host='195.154.47.113', port='3838', code='fr', country='france', anonymous=True, type='https', source='free-proxy-list'), 
Proxy(host='51.158.98.121', port='8811', code='fr', country='france', anonymous=True, type='https', source='anonymous-proxy'), 
Proxy(host='159.8.114.34', port='8123', code='fr', country='france', anonymous=True, type='http', source='free-proxy-list'), 
Proxy(host='195.154.56.105', port='3838', code='fr', country='france', anonymous=True, type='https', source='free-proxy-list'), 
Proxy(host='195.154.52.142', port='3838', code='fr', country='france', anonymous=True, type='https', source='anonymous-proxy'), 
Proxy(host='195.154.56.105', port='3838', code='fr', country='france', anonymous=True, type='https', source='anonymous-proxy'), 
Proxy(host='51.158.98.121', port='8811', code='fr', country='france', anonymous=True, type='http', source='free-proxy-list'), 
Proxy(host='51.158.123.250', port='8811', code='fr', country='france', anonymous=True, type='https', source='anonymous-proxy'), 
Proxy(host='51.158.119.88', port='8811', code='fr', country='france', anonymous=True, type='https', source='free-proxy-list'), 
Proxy(host='163.172.120.204', port='3838', code='fr', country='france', anonymous=True, type='https', source='free-proxy-list'), 
Proxy(host='46.218.155.194', port='3128', code='fr', country='france', anonymous=True, type='https', source='free-proxy-list'), 
Proxy(host='51.15.156.144', port='3838', code='fr', country='france', anonymous=True, type='https', source='free-proxy-list'), 
Proxy(host='51.158.165.18', port='8811', code='fr', country='france', anonymous=True, type='https', source='free-proxy-list')]

References:
proxyscrape Library

PyTutorial

working with Django model ChoiceField

MarkPy — Thu, 23 Apr 2020 00:22:04 +0000

Today we going to explore how to work with model ChoiceField in Django.
To better understand, let's see the following examples.

#models.py
#Django Models ChoiceField    
class Profile(models.Model):
    # Country Choices
    CHOICES = (
        ('US', 'United States'),
        ('FR', 'France'),
        ('CN', 'China'),
        ('RU', 'Russia'),
        ('IT', 'Italy'),
    )
    username = models.CharField(max_length=300)
    country = models.CharField(max_length=300, choices = CHOICES)

    def __str__(self):
        return self.username

Result:

Grouped Model ChoiceField

class Profile(models.Model):
    # Country Choices
    CHOICES = [
    ('Europe', (
            ('FR', 'France'),
            ('ES', 'Spain'),
        )
    ),
    ('Africa', (
            ('MA', 'Morocco'),
            ('DZ', 'Algeria'),
        )
    ),
    ]
    username = models.CharField(max_length=300)
    country = models.CharField(max_length=300, choices = CHOICES)

    def __str__(self):
        return self.username

Result:

Reference:
Django Model ChoiceField

All Done!