DEV Community: tutorial

Meta Conversions API in Node.js: Deduplication, Hashing and Event Match Quality Done Right

Mikail (Adnoxx) — Fri, 23 Oct 2026 02:47:40 +0000

If you run an ecommerce store and send traffic from Facebook or Instagram, the browser Pixel alone no longer sees every purchase. Safari's tracking protection, ad blockers, consent banners and short-lived cookies all chip away at it. The answer Meta gives is the Conversions API (CAPI): send the same events from your server.

Most CAPI tutorials stop at "POST some JSON". In production, three details decide whether it helps or hurts: deduplication, hashing/normalisation and match quality. This post covers all three with a small Node.js implementation.

Context: our team works on peptide Meta ads, a regulated category where every purchase signal matters because audiences are narrow. Nothing below is niche-specific, though. It applies to any store.

The architecture in one paragraph

The browser fires fbq('track', 'Purchase', ...) on the thank-you page. Your backend, on the order-paid webhook, sends a Purchase event to POST https://graph.facebook.com/{API_VERSION}/{PIXEL_ID}/events. Both carry the same event_id. Meta receives two copies, sees the matching event_name + event_id, and keeps one. You get the coverage of the server and the context of the browser without double counting.

Step 1: Generate one event ID per order

Use something stable that both sides know. The order ID is ideal:

// shared helper
export const purchaseEventId = (orderId) => `purchase_${orderId}`;

On the thank-you page:

<script>
  fbq('track', 'Purchase',
    { value: 129.00, currency: 'USD', content_ids: ['SKU-123'], content_type: 'product' },
    { eventID: 'purchase_100045' } // same string the server will send
  );
</script>

Note the casing: the browser option is eventID; the server field is event_id.

Step 2: Normalise, then hash

CAPI expects personal data hashed with SHA-256, after normalisation. Hashing an un-normalised value is the most common reason match quality stays low, because " John@Mail.com " and "john@mail.com" produce different hashes.

import crypto from 'node:crypto';

const sha256 = (v) => crypto.createHash('sha256').update(v).digest('hex');

const norm = {
  email: (e) => e.trim().toLowerCase(),
  phone: (p) => p.replace(/\D/g, ''),            // digits only, include country code
  name:  (n) => n.trim().toLowerCase(),
  zip:   (z) => z.trim().toLowerCase().replace(/\s/g, ''),
  country: (c) => c.trim().toLowerCase(),        // ISO-3166 alpha-2, e.g. "us"
};

const hashed = (fn, v) => (v ? [sha256(fn(v))] : undefined);

Do not hash client_ip_address, client_user_agent, fbc or fbp. They are sent as plain values.

Step 3: Capture fbp and fbc at checkout

_fbp is the browser ID cookie set by the Pixel. _fbc holds the click ID when someone arrives from an ad (fbclid in the URL). Save both on the order when checkout starts, because your webhook runs later, without the browser.

// at checkout creation (server side, request available)
order.meta = {
  fbp: req.cookies._fbp,
  fbc: req.cookies._fbc
    || (req.query.fbclid ? `fb.1.${Date.now()}.${req.query.fbclid}` : undefined),
  ip: req.ip,
  ua: req.get('user-agent'),
  sourceUrl: req.get('referer'),
};

Step 4: Send the server event

const PIXEL_ID = process.env.META_PIXEL_ID;
const TOKEN = process.env.META_CAPI_TOKEN;
const API_VERSION = process.env.META_API_VERSION; // use the current Graph API version

export async function sendPurchase(order) {
  const body = {
    data: [{
      event_name: 'Purchase',
      event_time: Math.floor(new Date(order.paidAt).getTime() / 1000),
      event_id: purchaseEventId(order.id),
      action_source: 'website',
      event_source_url: order.meta.sourceUrl,
      user_data: {
        em: hashed(norm.email, order.email),
        ph: hashed(norm.phone, order.phone),
        fn: hashed(norm.name, order.firstName),
        ln: hashed(norm.name, order.lastName),
        zp: hashed(norm.zip, order.zip),
        country: hashed(norm.country, order.country),
        external_id: [sha256(String(order.customerId))],
        client_ip_address: order.meta.ip,
        client_user_agent: order.meta.ua,
        fbp: order.meta.fbp,
        fbc: order.meta.fbc,
      },
      custom_data: {
        currency: order.currency,
        value: order.total,
        order_id: String(order.id),
        content_type: 'product',
        content_ids: order.items.map((i) => i.sku),
        num_items: order.items.reduce((n, i) => n + i.qty, 0),
      },
    }],
  };

  const res = await fetch(
    `https://graph.facebook.com/${API_VERSION}/${PIXEL_ID}/events?access_token=${TOKEN}`,
    { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(body) }
  );
  if (!res.ok) throw new Error(`CAPI ${res.status}: ${await res.text()}`);
  return res.json(); // { events_received: 1, fbtrace_id: ... }
}

Call it from the payment webhook, not from the thank-you page, so a closed tab never loses a sale. Put it on a queue with retries: Meta accepts events up to 7 days old, but delivery is most useful within an hour.

Step 5: Check it in Events Manager

In Events Manager, open the Pixel's Overview:

Purchase should show Browser and Server as connection methods.
The deduplication column should show most server events matched to browser events. If server and browser counts are both high and nothing is deduplicated, your event_id values do not match.
Event Match Quality (EMQ) scores how well your user_data identifies people. Email, phone, fbp, fbc, IP and user agent together usually lift Purchase to a strong score.

Common bugs we see

Symptom	Cause
Purchases doubled in Ads Manager	`eventID` missing on the browser call, or different formats on each side
Low match quality	Hashing before normalising; phone without country code
Server events "too old"	Sending `event_time` in milliseconds instead of seconds
No `fbc` on most orders	Not persisting `fbclid` from the landing URL through checkout
Values in the wrong currency	Sending store currency while the Pixel reports customer currency

Why it matters for the ad side

Meta's delivery system optimises toward the conversions it can see. When CAPI recovers the purchases the Pixel misses, the algorithm learns from the full set of real buyers, finds more people like them, and reports ROAS you can trust. For stores in competitive or regulated niches, that difference is often what separates a profitable campaign from one that gets switched off.

If you want the marketing-side view of this setup, we wrote about Pixel and Conversions API for peptide stores.

Mikail builds tracking and Meta ads infrastructure at Adnoxx, a peptide ad agency with years in digital marketing.
adnoxx.com · peptideads@adnoxx.com · Telegram @adnoxxads · WhatsApp +1 681 379 0505 · Instagram @adnoxxofficial

Arbitrage Alert: Building a Cross-Exchange Prediction Market Monitor with Python

heavy shield — Fri, 23 Oct 2026 02:47:02 +0000

Introduction

Prediction markets like Polymarket and Kalshi provide real-time probabilities for future events. On October 18, 2024, they priced the Fed's October rate decision four percentage points apart: Polymarket implied a 92% chance of a 25bp cut, while Kalshi showed 88%. Such discrepancies create arbitrage opportunities, but manually monitoring multiple platforms is impractical. In this post, we'll build a Python agent that polls both exchanges, normalizes contract prices, and computes the spread. The agent runs in a loop with explicit termination conditions and uses only public APIs. We'll also discuss security and precision issues.

Problem

Prediction markets often disagree due to differing liquidity, fees, or user bases. For developers building AI agents, detecting these spreads programmatically is a first step toward automated trading or alerting. Challenges include:

API heterogeneity: Polymarket uses a GraphQL endpoint; Kalshi uses REST.
Contract specifications: Outcomes may be phrased differently (e.g., "Fed cuts rates by 25bp" vs. "FOMC decision: cut 25bp").
Real-time updates: Prices change frequently; polling must be efficient.
Error handling: Network failures, rate limits, and malformed responses.

We'll focus on a minimal viable monitor that fetches current prices for a specific market and computes the spread. We'll use Python 3.9+ with requests and asyncio.

Solution

Our agent will:

Fetch the current price for a given market on Polymarket and Kalshi.
Normalize prices to probabilities (0-1).
Compute the absolute difference.
Log the spread if it exceeds a threshold.
Terminate after a specified number of iterations or when a stop condition is met.

We'll define an agent loop with explicit termination: it stops after max_iterations or if a KeyboardInterrupt occurs. We'll use asyncio for concurrent polling.

Security note: This code only reads public data. Do not use eval or exec on API responses. Always validate JSON schemas.

Implementation

Prerequisites

pip install requests aiohttp

Code

import asyncio
import aiohttp
import json
from typing import Optional, Dict, Any

# Configuration
POLYMARKET_API = "https://clob.polymarket.com"
KALSHI_API = "https://api.elections.kalshi.com/trade-api/v2"

# Example market IDs (replace with actual IDs from the platforms)
POLYMARKET_MARKET_ID = "0x123..."  # Polymarket condition ID
KALSHI_TICKER = "FED-24OCT-T25"    # Kalshi market ticker

async def fetch_polymarket_price(session: aiohttp.ClientSession, market_id: str) -> Optional[float]:
    """Fetch the yes price (probability) from Polymarket."""
    # Polymarket's CLOB API requires a token ID; this is a simplified example.
    # In practice, you'd query the market's token IDs first.
    url = f"{POLYMARKET_API}/price?token_id={market_id}&side=BUY"
    try:
        async with session.get(url, timeout=10) as resp:
            if resp.status != 200:
                return None
            data = await resp.json()
            # Response format: {"price": "0.92"}
            return float(data.get("price", 0))
    except (aiohttp.ClientError, asyncio.TimeoutError, ValueError):
        return None

async def fetch_kalshi_price(session: aiohttp.ClientSession, ticker: str) -> Optional[float]:
    """Fetch the yes price from Kalshi."""
    url = f"{KALSHI_API}/markets/{ticker}"
    try:
        async with session.get(url, timeout=10) as resp:
            if resp.status != 200:
                return None
            data = await resp.json()
            # Kalshi returns prices in cents (0-100)
            yes_price = data.get("market", {}).get("yes_price")
            if yes_price is not None:
                return yes_price / 100.0
            return None
    except (aiohttp.ClientError, asyncio.TimeoutError, ValueError):
        return None

async def monitor_spread(max_iterations: int = 10, interval: int = 5, threshold: float = 0.02):
    """Poll both exchanges and log spreads above threshold."""
    async with aiohttp.ClientSession() as session:
        for i in range(max_iterations):
            poly_price, kalshi_price = await asyncio.gather(
                fetch_polymarket_price(session, POLYMARKET_MARKET_ID),
                fetch_kalshi_price(session, KALSHI_TICKER)
            )
            if poly_price is not None and kalshi_price is not None:
                spread = abs(poly_price - kalshi_price)
                print(f"Iteration {i+1}: Polymarket={poly_price:.2%}, Kalshi={kalshi_price:.2%}, Spread={spread:.2%}")
                if spread >= threshold:
                    print(f"  ALERT: Spread exceeds {threshold:.0%}")
            else:
                print(f"Iteration {i+1}: Failed to fetch prices")
            await asyncio.sleep(interval)

if __name__ == "__main__":
    asyncio.run(monitor_spread(max_iterations=5, interval=10, threshold=0.03))

Explanation

Polymarket: The CLOB API endpoint /price requires a token ID and side. In a real implementation, you'd first query /markets to get token IDs. We use a placeholder POLYMARKET_MARKET_ID.
Kalshi: The /markets/{ticker} endpoint returns a yes_price in cents. We convert to probability by dividing by 100.
Agent loop: The monitor_spread function runs for max_iterations (explicit termination). It uses asyncio.gather for concurrent fetching. Errors are caught and logged; the loop continues.
Threshold: Alerts when spread >= 3% (default). Adjust based on fees and slippage.

Note: This is a simplified example. Actual market IDs and endpoints may change. Always refer to official API docs.

Key Takeaways

Cross-exchange monitoring is feasible with public APIs, but requires careful normalization of contract specifications and price formats.
Agent loops need termination conditions: we used max_iterations and asyncio.sleep to avoid infinite loops.
Error handling is crucial: network issues and API changes can break your agent. Always validate responses and use timeouts.
Security: Never use eval or exec on API data. Use json.loads and type checks.
Precision: Prices may be strings; convert carefully. Use float only after validation.
Arbitrage opportunities may be fleeting; consider building a more robust system with WebSockets for real-time updates.

This agent is a starting point. Extend it with alerting (e.g., email, Slack) and persistent storage for historical spreads.

Bookmark It! STOP Shipping Broken Vibe Code: 10 Checks That Save Your App at 2 AM

heavy shield — Fri, 23 Oct 2026 02:46:48 +0000

Bookmark It! STOP Shipping Broken Vibe Code: 10 Checks That Save Your App at 2 AM

You know the scene: it's 2 AM, your AI agent just deployed a "minor fix," and now the entire app is returning 500s. The code looked right when the model generated it. The tests passed locally. But in production, it's a disaster. This is the cost of shipping vibe code—code that feels right but hasn't been verified.

AI coding agents are powerful, but they are also confidently wrong. They hallucinate APIs, ignore edge cases, and happily introduce security holes. If you're building agents that write or modify code, you need a guardrail layer. Below are 10 checks you can implement in Python to catch broken vibe code before it hits production. Each check is runnable and designed to be integrated into your agent's output pipeline.

The Problem: Agents Ship Vibes, Not Verified Code

An AI agent loop typically does: plan → generate code → execute → observe → repeat. Without explicit termination conditions, the loop can run forever. Without verification, it can "succeed" by producing code that runs but is semantically wrong. Worse, if your agent executes arbitrary code (e.g., via exec or subprocess), you're one prompt injection away from a remote code execution vulnerability.

The solution is a check pipeline: a set of deterministic validations applied to every code artifact before it is accepted. These checks are not a replacement for human review, but they catch the low-hanging fruit that causes 2 AM pages.

The 10 Checks

We'll implement each as a function that takes a code string (and optional context) and returns a boolean or raises an exception. We'll then compose them into a pipeline.

1. Syntax Validation

Use Python's ast.parse to ensure the code is syntactically valid.

import ast

def check_syntax(code: str) -> bool:
    try:
        ast.parse(code)
        return True
    except SyntaxError as e:
        print(f"Syntax error: {e}")
        return False

2. Import Allowlist

Agents love to import random packages. Restrict imports to a known allowlist.

def check_imports(code: str, allowed: set[str]) -> bool:
    tree = ast.parse(code)
    for node in ast.walk(tree):
        if isinstance(node, ast.Import):
            for alias in node.names:
                if alias.name.split('.')[0] not in allowed:
                    print(f"Disallowed import: {alias.name}")
                    return False
        elif isinstance(node, ast.ImportFrom):
            if node.module and node.module.split('.')[0] not in allowed:
                print(f"Disallowed import: {node.module}")
                return False
    return True

3. No Dangerous Builtins

Block eval, exec, compile, and __import__ unless explicitly allowed. Security warning: these functions can execute arbitrary code. Never enable them in untrusted contexts.

DANGEROUS = {'eval', 'exec', 'compile', '__import__'}

def check_dangerous_builtins(code: str) -> bool:
    tree = ast.parse(code)
    for node in ast.walk(tree):
        if isinstance(node, ast.Call):
            if isinstance(node.func, ast.Name) and node.func.id in DANGEROUS:
                print(f"Dangerous call: {node.func.id}")
                return False
    return True

4. No Subprocess or OS System Calls

Block subprocess, os.system, and similar modules unless the agent is explicitly authorized.

def check_subprocess(code: str) -> bool:
    tree = ast.parse(code)
    for node in ast.walk(tree):
        if isinstance(node, ast.Import):
            for alias in node.names:
                if alias.name in {'subprocess', 'os'}:
                    print(f"Disallowed module: {alias.name}")
                    return False
        elif isinstance(node, ast.ImportFrom):
            if node.module in {'subprocess', 'os'}:
                print(f"Disallowed module: {node.module}")
                return False
    return True

5. Function Signature Check

If the agent is modifying an existing function, ensure the signature matches the original. This prevents accidental API breaks.

def check_function_signature(code: str, func_name: str, expected_params: list[str]) -> bool:
    tree = ast.parse(code)
    for node in ast.walk(tree):
        if isinstance(node, ast.FunctionDef) and node.name == func_name:
            params = [arg.arg for arg in node.args.args]
            if params != expected_params:
                print(f"Signature mismatch for {func_name}: {params} != {expected_params}")
                return False
            return True
    print(f"Function {func_name} not found")
    return False

6. Test Coverage Threshold

Run the agent's generated tests and require a minimum coverage. Use coverage.py programmatically.

import coverage

def check_coverage(code: str, min_percent: float = 80.0) -> bool:
    # Write code to a temp file and run coverage
    # Simplified for brevity; in practice, use a temp directory
    import tempfile, os
    with tempfile.NamedTemporaryFile('w', suffix='.py', delete=False) as f:
        f.write(code)
        path = f.name
    cov = coverage.Coverage(source=[path])
    cov.start()
    # Execute the code (in a sandbox!)
    try:
        exec(compile(code, path, 'exec'), {})
    except Exception as e:
        print(f"Execution error: {e}")
        return False
    finally:
        cov.stop()
        cov.save()
    percent = cov.report()
    os.unlink(path)
    return percent >= min_percent

Security warning: exec here runs arbitrary code. Only use this in an isolated sandbox (e.g., Docker container with no network). Never run untrusted code on your host.

7. Lint with Flake8

Catch style issues and potential bugs.

import subprocess

def check_lint(code: str) -> bool:
    import tempfile, os
    with tempfile.NamedTemporaryFile('w', suffix='.py', delete=False) as f:
        f.write(code)
        path = f.name
    result = subprocess.run(['flake8', path], capture_output=True, text=True)
    os.unlink(path)
    if result.returncode != 0:
        print(result.stdout)
        return False
    return True

8. Type Check with Mypy

Static type checking catches many runtime errors.

def check_types(code: str) -> bool:
    import tempfile, os
    with tempfile.NamedTemporaryFile('w', suffix='.py', delete=False) as f:
        f.write(code)
        path = f.name
    result = subprocess.run(['mypy', path], capture_output=True, text=True)
    os.unlink(path)
    if result.returncode != 0:
        print(result.stdout)
        return False
    return True

9. Dependency Audit

If the agent adds dependencies, check them against a vulnerability database (e.g., pip-audit).

def check_dependencies(requirements: str) -> bool:
    import tempfile, os
    with tempfile.NamedTemporaryFile('w', suffix='.txt', delete=False) as f:
        f.write(requirements)
        path = f.name
    result = subprocess.run(['pip-audit', '-r', path], capture_output=True, text=True)
    os.unlink(path)
    if result.returncode != 0:
        print(result.stdout)
        return False
    return True

10. Explicit Agent Loop Termination

If your agent uses a loop, define a maximum iteration count and a success condition. Without this, the agent may never stop.

MAX_ITERATIONS = 10

def agent_loop(agent, task, success_check):
    for i in range(MAX_ITERATIONS):
        code = agent.generate(task)
        if success_check(code):
            return code
        task = agent.refine(task, code)
    raise RuntimeError("Agent loop exceeded maximum iterations without success")

Implementation: The Check Pipeline

Compose the checks into a single function. Use a list of (name, check) tuples. Each check returns True if passed.

def validate_code(code: str, allowed_imports: set[str], expected_func: str | None = None) -> bool:
    checks = [
        ("syntax", lambda c: check_syntax(c)),
        ("imports", lambda c: check_imports(c, allowed_imports)),
        ("dangerous", lambda c: check_dangerous_builtins(c)),
        ("subprocess", lambda c: check_subprocess(c)),
        ("lint", lambda c: check_lint(c)),
        ("types", lambda c: check_types(c)),
    ]
    if expected_func:
        checks.append(("signature", lambda c: check_function_signature(c, expected_func, ['x'])))
    for name, check in checks:
        if not check(code):
            print(f"Check failed: {name}")
            return False
    return True

Integrate this into your agent's output step: only accept code that passes all checks. For execution, always use a sandbox (e.g., docker run --rm -v $(pwd):/code python:3.11-slim).

Key Takeaways

Vibe code is a liability. Verify every artifact with deterministic checks.
Security first. Never exec untrusted code on your host. Use containers.
Explicit termination. Agent loops must have a max iteration count and a clear success condition.
Compose checks. A pipeline of small, focused validators is easier to maintain than one monolithic validator.
Bookmark this. At 2 AM, you'll want these checks in your back pocket.

These 10 checks won't catch every bug, but they'll stop the most common causes of broken deployments. Add them to your agent's CI/CD, and sleep better.

REA: Let Your AI Agent Reverse Engineer the App Features You Wish You Had

heavy shield — Fri, 23 Oct 2026 02:45:52 +0000

Introduction

You've been there: you're using an app, and you think, "If only it had feature X." But instead of waiting for the product team, you can build an AI agent that reverse engineers the app's API and implements that feature yourself. This post introduces REA (Reverse Engineering Agent), a pattern for building such agents. We'll walk through a concrete implementation in Python that inspects a web app's network traffic, infers API endpoints, and generates code to replicate missing functionality.

The Problem

Modern web apps are complex. Their features are often powered by undocumented internal APIs. When you want to extend or automate them, you're left guessing endpoints, parameters, and authentication. Manually reverse engineering is tedious and error-prone.

The Solution: REA

REA is an agent that:

Captures HTTP traffic from a target app (using a proxy like mitmproxy).
Analyzes requests/responses to identify API patterns.
Generates Python code that replicates desired features.
Validates the generated code against the live API.

The agent operates in a loop with explicit termination conditions: either it successfully generates and validates the code, or it exhausts a maximum number of iterations.

Implementation

We'll build a simplified REA using Python, mitmproxy, and OpenAI's API. The agent will reverse engineer a hypothetical "todo" feature from a demo app.

Prerequisites

pip install mitmproxy openai requests

Step 1: Capture Traffic

We'll use mitmproxy's scripting to log requests to a file. Save this as capture.py:

from mitmproxy import http
import json

class Capture:
    def response(self, flow: http.HTTPFlow):
        if "api" in flow.request.pretty_url:
            entry = {
                "method": flow.request.method,
                "url": flow.request.pretty_url,
                "headers": dict(flow.request.headers),
                "body": flow.request.get_text(),
                "response": flow.response.get_text()
            }
            with open("traffic.jsonl", "a") as f:
                f.write(json.dumps(entry) + "\n")

addons = [Capture()]

Run mitmproxy with this script:

mitmproxy -s capture.py

Configure your browser to use mitmproxy as a proxy, then use the app to trigger the feature you want to replicate. The traffic will be logged to traffic.jsonl.

Step 2: Analyze Traffic and Generate Code

Now, we'll write the REA agent. It reads the captured traffic, asks an LLM to infer the API, and generates Python code. We'll use OpenAI's function calling to structure the output.

import json
import openai

openai.api_key = "YOUR_API_KEY"

# Load captured traffic
traffic = []
with open("traffic.jsonl") as f:
    for line in f:
        traffic.append(json.loads(line))

# Prepare a summary for the LLM
summary = []
for entry in traffic:
    summary.append({
        "method": entry["method"],
        "url": entry["url"],
        "request_body": entry["body"],
        "response_snippet": entry["response"][:200]
    })

prompt = f"""
Given these HTTP requests and responses from a web app, infer the API endpoints and generate Python code using the `requests` library to perform the following feature: "Create a new todo item".

Traffic summary:
{json.dumps(summary, indent=2)}

Return a JSON object with keys: `endpoint`, `method`, `headers`, `payload_template`, and `code`. The `code` should be a complete Python function that takes necessary parameters and returns the response.
"""

response = openai.ChatCompletion.create(
    model="gpt-4",
    messages=[{"role": "user", "content": prompt}],
    temperature=0
)

result = json.loads(response.choices[0].message.content)
print("Generated code:\n", result["code"])

Step 3: Validate Generated Code

The agent should test the generated code against the live API. We'll extract the function and run it with sample data.

import requests

# Extract the function from generated code (simplified)
# In production, use a sandboxed environment!
exec(result["code"], globals())  # SECURITY WARNING: Never exec untrusted code in production.

# Assuming the function is named `create_todo`
try:
    response = create_todo("Test todo")
    if response.status_code == 200:
        print("Validation successful!")
    else:
        print("Validation failed:", response.status_code)
except Exception as e:
    print("Error during validation:", e)

The Agent Loop

A full REA agent would iterate: if validation fails, it feeds the error back to the LLM to refine the code. The loop terminates when validation succeeds or after max_iterations (e.g., 5).

max_iterations = 5
for i in range(max_iterations):
    # Generate code (as above)
    # Validate
    if validation_success:
        break
    else:
        # Add error to prompt for next iteration
        prompt += f"\nPrevious attempt failed with error: {error}"

Key Takeaways

REA agents can automate reverse engineering of web APIs by combining traffic capture with LLM-powered code generation.
Always include explicit termination conditions in agent loops to avoid infinite execution.
Security: Never execute generated code without sandboxing. Use containers or restricted environments.
This approach is for educational purposes; respect terms of service and privacy laws.

By building your own REA, you can unlock features that apps don't provide, tailored to your workflow.

Note: This implementation is inspired by agentic patterns but is not a formal protocol. The term "REA" is used descriptively.

🎥 Video: The Display Class in Limn Engine

Kehinde Owolabi — Fri, 23 Oct 2026 02:45:19 +0000

🎥 Video: The Display Class in Limn Engine

A full walkthrough of the Display class — creating the game window, setting the background, and controlling the canvas.

🎯 Watch the Video

👉 Learn about the Display class in Limn Engine — YouTube

This is the next video in the Limn Engine tutorial series. It focuses on the Display class — the foundation of every Limn Engine game. It walks through creating the game window, setting the background color, and controlling the canvas.

Official documentation:

👉 limn-engine-doc.vercel.app

📖 Introduction

Every Limn Engine game starts with one line:

const display = new Display();

That single line creates the canvas, sets up the game loop, and prepares the engine to draw. Everything else — every component, every particle, every score, every pixel — is drawn through the Display.

The Display class is easy to use but easy to misuse. There are a few things you need to get right — the order of perform() and start(), the variable name display, and the difference between the canvas and the world. Getting them wrong doesn't crash the engine, but it does make your game behave in ways that are hard to debug.

This video walks through the Display class from start to finish.

Here's what the video covers:

Creating a Display and starting the canvas
The perform() method — why it comes first, and what breaks if you forget
Setting the background color
Sizing the canvas
The camera and how it relates to the Display
Common mistakes and how to avoid them

🎬 What the Video Covers

Creating a Display. The video starts with the one-line setup — new Display() — and explains what happens under the hood when you create it. The engine creates a canvas element, sets up a 2D drawing context, and prepares the game loop.

The perform() method. Most of the video focuses on this. display.perform() is what switches the engine from the default setInterval loop to requestAnimationFrame. Without it, the game runs at about 50fps with inconsistent pacing. With it, the game runs at a smooth 60fps (or whatever the monitor's refresh rate is).

The order matters: perform() must come before start(). If you call start() first, the patch doesn't take effect, and the game runs on the slow loop. This is one of the most common mistakes beginners make.

Setting the background color. The video shows display.backgroundColor(), which sets the canvas background via CSS. It also shows the gradient options — lgradient() for linear gradients and rgradient() for radial ones — for more polished backgrounds.

Sizing the canvas. display.start(width, height) sets the canvas dimensions. The video covers how to choose a size, how the size relates to mobile screens, and how to scale the canvas with CSS without changing its internal resolution.

The camera. The Display has a camera attached to it. The video explains how the camera moves independently of the canvas, how world coordinates differ from screen coordinates, and how to set the camera's world size so it doesn't scroll past the edges of the level.

Common mistakes. The video finishes with the most common Display-related bugs: forgetting perform(), using a different variable name than display, and calling start() more than once.

🚀 Try It Yourself

The engine:

👉 limn-engine-doc.vercel.app

The online editor (no download required):

👉 limn-engine-doc.vercel.app/editor

The arcade (play games made by others):

👉 limn-engine-doc.vercel.app/arcade

📺 Full Video Series

This video is part of the ongoing Limn Engine tutorial series. Here's the current lineup:

#	Video	What It Covers
1	Series Start	Introduction to the series
2	—	Setup and first Display
3	—	Components and movement
4	Introduction to Limn Engine	What Limn is, and how to get started
5	The Display Class	Creating the game window, background colors, and canvas control

📝 Quick Reference: The Display Class

Here's the minimal Display setup from the video, in case you want to follow along without typing every line:

<!DOCTYPE html>
<html>
<head>
  <title>Display Demo</title>
  <script src="epic.js"></script>
</head>
<body>
  <script>
    // Create the engine
    const display = new Display();

    // MUST come before start()
    display.perform();

    // Create the canvas
    display.start(800, 600);

    // Set the background
    display.backgroundColor("#0a0a0a");

    // Game loop
    function update(dt) {
      // Game logic goes here
    }
  </script>
</body>
</html>

And here's the gradient version, for a more polished background:

display.lgradient("bottom", "#0f3460", "#16213e");
// or
display.rgradient("#1a1a2e", "#0a0a0f");

📊 What You've Learned

Concept	Why It Matters
`new Display()`	Creates the canvas, the game loop, and the camera
`display.perform()`	Switches to `requestAnimationFrame` for smooth 60fps
Order matters	`perform()` must come before `start()`
`display.start(w, h)`	Sets the canvas size and begins the game loop
`display.backgroundColor()`	Sets the canvas background via CSS
`display.lgradient()` / `rgradient()`	Gradient backgrounds for a more polished look
`display.camera`	Controls what part of the world is visible

⚠️ Common Mistakes to Avoid

Forgetting perform(). Without it, your game runs at about 50fps on an unreliable setInterval loop. Movement feels inconsistent, and dt doesn't behave the way you expect.

Calling start() before perform(). The patch doesn't take effect if start() has already run. Always call perform() first.

Naming the Display something else. The engine references display internally. Calling your instance game or app will throw errors in places you don't expect.

Calling start() more than once. The engine creates a canvas on every start() call. Multiple calls stack multiple canvases on the page.

🐛 Found a Bug?

If you find something in the video that doesn't work, report it on GitHub:

👉 github.com/terracodes004/limn-engine-doc/issues

Please include your browser, your device, and the timestamp in the video where the issue appears.

🔗 Resources

Resource	Link
YouTube Video	The Display Class
Previous Video	Introduction to Limn Engine
Limn Engine Docs	limn-engine-doc.vercel.app
Limn Studio (Editor)	limn-engine-doc.vercel.app/editor
Limn Arcade	limn-engine-doc.vercel.app/arcade
GitHub Repository	github.com/terracodes004/limn-engine-doc
Report Bugs	github.com/terracodes004/limn-engine-doc/issues
Discord	discord.gg/kVpSmYWXr
Kehinde on DEV.to	dev.to/kehinde_owolabi_e2e54567a

🎯 The One-Line Summary

"A full walkthrough of the Display class — creating the game window, setting the background, sizing the canvas, and controlling the camera in Limn Engine." 🎮🚀

Draw your game into existence — one Display at a time. 🎮🚀

When a desktop automation is unsure whether Save worked

macro8n | Desktop Automation — Fri, 23 Oct 2026 02:44:04 +0000

A desktop workflow submits a form. The app pauses, then the window changes. Did the record save, or did the request fail?

That is an unknown outcome, and it deserves its own state in the workflow. Treating every uncertainty as a failure can create duplicate records. Treating it as success can silently lose work.

Model the result as three states

For a record-entry task, track:

Not submitted: the workflow has not triggered Save.
Confirmed: the app shows a reliable success signal, or the record can be found afterward.
Unknown: Save was triggered, but the workflow did not get enough evidence to decide.

Only the first state is safe to submit again automatically. In the unknown state, stop and inspect before retrying.

Prefer an idempotent operation when one exists

If the service offers an API, ask whether it supports an idempotency key or a unique external reference. Repeating the same request with the same key can then return the original result instead of creating a second record. A desktop interface may not offer that guarantee, so do not assume that clicking Save twice is harmless.

Give the workflow a way to reconcile

A unique value can help the workflow check whether a submission already landed. For example, use an order reference or a task-specific label that the app can search. After an uncertain save, look for that reference before deciding whether to submit again. Keep the search narrow and avoid logging the full form if it contains personal or confidential data.

Make the fallback explicit

If the record is found, mark the step complete and continue. If it is absent and the app is responsive, a bounded retry may be reasonable. If the search itself fails or returns ambiguous results, stop and ask a person to review. Do not turn “I could not verify it” into “it did not happen.”

Test the uncertain path

Use a test record and interrupt the flow immediately after Save: close the dialog, delay the response, or make the confirmation hard to read. Then check that the workflow enters the unknown state and does not blindly submit a second time. This edge case is often more valuable than another successful happy-path run.

A reliable automation records what it knows, distinguishes that from what it merely assumes, and chooses a safe next step. That matters most around actions that create, send, delete, or charge something.

macro8n is a local-first desktop app for building visual workflows. These design ideas apply to any UI automation tool.

Disclosure: this article was generated with AI assistance for the macro8n account.

Excel to JSON: Free Online Excel to JSON Converter — How-To Guide

Layoff Atlas — Fri, 23 Oct 2026 02:43:33 +0000

Excel to JSON: Free Online Excel to JSON Converter — How-To Guide

Spreadsheets are easy to edit but terrible to feed into code. JSON is the opposite: every API, test suite, config file, and front-end app speaks it fluently. Excel to JSON bridges the gap — it converts the first worksheet of any Excel file into clean JSON records, right in your browser, with zero sign-up.

Try it free: Excel to JSON

What the tool does

Excel to JSON parses your .xlsx (or .xls) file with the real XLSX library, takes the first worksheet, and turns each row into a JSON object keyed by the column headers. You get instant validation, a copy button, and a download button, plus sample data if you want to experiment before uploading your own file. Because the parsing happens client-side, nothing is ever sent to a server — ToolsFam never sees your spreadsheet.

When this tool is most useful

API testing: you have fixture data in a spreadsheet and need JSON payloads for Postman, Insomnia, or an automated test suite.
Frontend prototypes: loading a product catalog, employee list, or dataset from a static JSON file instead of wiring up a database on day one.
Migration checks: comparing old-system spreadsheet exports against the JSON shape the new system expects, before the real import.
Config files: turning a settings table maintained by non-developers into the JSON config your app actually reads.

How to use it, step by step

Open the tool at Excel to JSON.
Drop in your Excel file — drag and drop or use the file picker. Only the first worksheet is converted, so move the data you need onto Sheet1.
Review the parsed table. Check that headers look right, row counts match, and empty cells and numeric-looking strings (like zip codes with leading zeros) are handled as you expect.
Copy or download. Use the copy button to grab the JSON for pasting into code or API testers, or download it as a .json file.
Sanity-check before production. Confirm the output matches the schema your destination system expects — objects vs. arrays, escaped characters, and missing values are the usual suspects.

3 practical tips

Clean your headers first. Consistent, typo-free headers in row 1 become your JSON keys. Spaces and merged cells in the header row cause the most conversion headaches.
Use small representative samples. When testing a migration or API import, run a handful of rows first so the output shape is predictable before you convert the full file.
Watch out for nested values and dates. Review how the tool represents dates, booleans, and cells containing commas or quotes — different destinations expect different formats.

Frequently asked questions

Q: What does Excel to JSON convert?
A: The first worksheet of your Excel file. Each row becomes a JSON record, keyed by the column headers in row 1.

Q: Is my data uploaded anywhere?
A: No. The workbook is parsed locally in your browser with the XLSX library. Your files are never sent to ToolsFam for conversion.

Q: What input shape works best?
A: Consistent rows, clear headers, valid syntax, and small representative samples produce the most predictable conversion. Clean headers first for the cleanest output.

Q: What should I check after conversion?
A: Escaped characters, missing values, arrays versus objects, and whether the destination system expects a specific schema — review before using converted output in production.

Privacy note

Excel to JSON runs 100% in your browser — files never leave your device. There is no account, no upload, and no server-side processing, so even sensitive spreadsheets are safe to convert.

Try it free: Excel to JSON

Originality.ai Review 2026: Accuracy, Features, Pricing, and Best AI Detector Alternatives

Arnie Parks — Fri, 23 Oct 2026 02:38:52 +0000

AI-generated content is everywhere now. From blog posts and academic essays to marketing copy and technical documentation, tools like ChatGPT, Claude, and Gemini have changed how people write.

That has also created a new challenge: how can you tell whether a piece of writing was created by a human or generated by AI?

AI detection tools are designed to help answer that question. One of the better-known options is Originality.ai, a platform that focuses on identifying potentially AI-generated writing and checking content for plagiarism.

But how reliable is Originality.ai in 2026? What features does it offer? And are there alternatives worth considering?

In this Originality.ai review, we'll explore how the platform works, what its detection results mean, where it performs well, and how it compares with other AI detectors, including Winston AI.

Whether you're a blogger, editor, teacher, student, or content manager, understanding these differences can help you choose a tool that fits your workflow.

What Is Originality.ai?

Originality.ai is a content verification platform designed to help users evaluate written material.

Its primary features include AI content detection and plagiarism checking, making it relevant to publishers, website owners, editors, and teams managing large amounts of written content.

For example, imagine you run a website that publishes articles from several freelance writers.

You want to maintain consistent editorial standards, verify originality, and understand whether submitted content may have been generated using AI.

Instead of reviewing every article manually for possible AI involvement, you can use a detection tool as an additional screening step.

Originality.ai provides an AI detection assessment that can help identify content worth reviewing more closely.

However, there's an important distinction to understand.

An AI detection score is an estimate based on patterns in writing. It is not definitive proof of who wrote a document.

That limitation applies to Originality.ai and other AI detectors.

How Does Originality.ai Detect AI-Generated Content?

AI detectors analyze characteristics of written text to estimate whether it resembles human writing or content generated by language models.

These systems are generally trained using examples of human-written and AI-generated text.

During analysis, the detector evaluates patterns in the submitted material and produces a result indicating how strongly the text resembles AI-generated writing.

Originality.ai uses its own detection models to generate these assessments.

For users, the process is relatively straightforward.

You submit content, initiate a scan, and review the results.

The platform then provides an assessment that can help guide your next steps.

For instance, an editor might use the result to decide whether an article needs additional review.

A content manager might compare the result with a writer's draft history or editorial guidelines.

The important part is what happens after the scan.

Detection results become more useful when they are considered alongside other evidence rather than treated as a final verdict.

Originality.ai Accuracy in 2026: How Reliable Is It?

Accuracy is usually the first question people ask when researching an AI detector.

And it makes sense.

If you're paying for a tool that identifies AI-generated writing, you want to know whether its results are dependable.

However, AI detection accuracy is more complicated than a single percentage.

Understanding AI Detection Accuracy

When evaluating an AI detector, several factors matter.

True positives occur when the detector correctly identifies AI-generated content.

True negatives occur when it correctly recognizes human-written content.

A false positive happens when human-written text is incorrectly flagged as AI-generated.

A false negative happens when AI-generated content is classified as human-written.

These distinctions are especially important in education and professional publishing.

A false positive could lead someone to question an authentic piece of writing.

A false negative could allow AI-generated content to pass through a screening process without being identified.

A detector that performs well in one testing environment may not achieve the same results with every writing style, language, or document type.

Why Accuracy Results Can Vary

Consider three different pieces of content.

The first is a completely AI-generated blog post.

The second is a human-written essay with a few AI-assisted edits.

The third is a technical article written by a person using highly structured language.

Even though these documents have different origins, some of their writing patterns may overlap.

AI detectors can find fully generated passages easier to classify in some circumstances than heavily edited or mixed-authorship documents.

Short passages can also be more difficult to assess because they provide less text for analysis.

This is why independent testing should consider multiple document types rather than relying on a handful of examples.

Can Originality.ai Detect ChatGPT, Claude, and Gemini?

Originality.ai is designed to identify AI-generated writing, including content associated with major language models.

However, performance can vary depending on the model, the amount of editing, the length of the passage, and the detector version being used.

A passage copied directly from an AI chatbot may produce a different result from the same passage after substantial human revision.

That does not necessarily mean the detector is malfunctioning.

It reflects the broader challenge of identifying authorship from text alone.

The most practical approach is to treat AI detection as a screening method, not a guaranteed authorship test.

Originality.ai Features: What Does It Offer?

Originality.ai is more than a basic text checker.

Its appeal comes from combining several content review functions in one platform.

1. AI Content Detection

The platform's main feature is its ability to assess whether writing resembles AI-generated content.

This is useful for publishers reviewing submissions, editors managing freelance writers, and teams maintaining content standards.

For example, a blog editor might scan an article before publication and use the result to determine whether additional editorial review is appropriate.

The score should not automatically decide whether the article gets published.

Instead, it can help identify questions worth investigating.

2. Plagiarism Checking

Plagiarism detection and AI detection are often discussed together, but they address different concerns.

AI detection estimates whether writing resembles machine-generated text.

Plagiarism checking looks for similarities between submitted content and existing sources.

An article can be entirely human-written and still contain plagiarized passages.

Likewise, AI-generated content can be original in wording without necessarily being appropriate for a particular assignment or publication.

For content teams, having access to both types of checks can be useful.

3. Readability Analysis

Readability matters because content needs to be understandable to its intended audience.

A technically accurate article may still be difficult to read if the sentences are unnecessarily complicated.

Readability tools help writers and editors assess whether the language is suitable for their readers.

For website publishers, this can support the editing process, although readability scores should never replace thoughtful writing.

4. Website and Content Review Workflows

Originality.ai also targets teams that need to evaluate content across websites or larger publishing workflows.

This makes it particularly relevant to SEO professionals, content agencies, and businesses managing multiple contributors.

A team reviewing dozens of articles each week may benefit from a structured process for checking submitted content.

However, the value of these features depends on how frequently you publish and what your editorial process requires.

Originality.ai Pricing: Is It Worth Paying For?

Pricing is an important part of any Originality.ai review.

The platform has offered credit-based and subscription-oriented purchasing options, but available plans, limits, and prices can change.

Rather than relying on an outdated price quoted in an article, it's better to check the current pricing details before subscribing.

The more useful question is whether the platform's features match your workload.

If you occasionally check a short article, your needs will differ from those of an agency processing hundreds of documents.

A publisher may value plagiarism checks and content management features.

A teacher may care more about readable reports and clear explanations of flagged passages.

A student might simply want a way to review a draft before submitting it.

Before choosing a plan, consider how many words you expect to scan, which features are included, and whether repeated scans consume additional credits.

These details can affect the actual cost of using the platform.

Best Originality.ai Alternatives in 2026

Originality.ai is one option in a growing AI detection market.

Depending on your needs, another platform may offer a more suitable workflow, interface, or combination of features.

Here are several alternatives worth exploring.

1. Winston AI — A Practical Alternative for Content Verification

One alternative worth considering is Winston AI, an AI detection platform designed to help users review writing for signs of AI generation.

It is relevant to educators, writers, editors, publishers, and professionals who regularly evaluate written content.

One of its useful features is sentence-level highlighting, which helps users identify portions of a document that deserve closer attention.

Rather than relying only on an overall detection result, users can review the highlighted sections and compare them with the rest of the text.

For example, imagine you're editing a long article containing several sections.

If a scan identifies particular passages as more likely to be AI-generated, you can examine those passages individually instead of treating the entire article as one uniform piece of writing.

Winston AI also offers plagiarism checking and other writing-related features, including an AI Essay Grader.

These features may be helpful for people who want more than a single AI detection score.

How Does Winston AI Compare With Originality.ai?

Both platforms aim to help users evaluate content, but their usefulness depends on the situation.

Originality.ai is often considered by website publishers and content teams looking for AI detection alongside editorial verification features.

Winston AI may appeal to users who want an approachable detection workflow with clear reporting and passage-level review.

If you're researching detection performance, Winston AI also publishes information about its testing and benchmark results.

You can explore its discussion of AI detector accuracy across leading benchmarks.

Keep in mind that vendor-published benchmarks should be evaluated alongside independent tests, especially when comparing competing tools.

Neither platform should be treated as a perfect method for proving authorship.

The better choice is the one that fits your documents, review process, and expectations.

2. GPTZero — An Option for Reviewing AI-Generated Writing

GPTZero is another widely recognized name in AI content detection.

It focuses on helping users evaluate whether text may have been generated by AI.

The platform is frequently discussed in educational settings, where teachers and institutions may want additional context when reviewing written assignments.

For example, an instructor might use GPTZero to identify passages that deserve a closer look.

However, the instructor should also consider a student's writing history, assignment requirements, and available drafts.

Like other detectors, GPTZero can produce incorrect classifications.

Its results are best used as part of a broader review process.

3. Copyleaks — AI Detection and Plagiarism Checking

Copyleaks is another alternative for people interested in content verification.

It offers AI detection and plagiarism-related functionality, making it relevant to educational institutions and businesses.

For organizations that already use formal document review processes, having multiple verification capabilities available can be convenient.

Imagine a training organization reviewing submitted assignments.

The team may need to check for similarities with existing sources while also evaluating whether the writing resembles AI-generated content.

These are separate questions, and a platform that supports both checks can help organize the review.

As always, the final decision should involve human judgment.

4. Turnitin — Academic Integrity and Institutional Workflows

Turnitin is strongly associated with academic integrity and similarity checking.

It is commonly used by educational institutions to review student submissions.

Turnitin also offers AI writing detection capabilities in supported institutional workflows.

However, access to particular features depends on the institution and its subscription.

Unlike a general-purpose tool that an individual can immediately use for personal checks, Turnitin is often accessed through schools and universities.

Its strongest fit is usually an established academic review process.

Teachers should still avoid treating an AI detection indicator as conclusive evidence of misconduct.

Student drafts, assignment context, and direct conversations remain important.

5. ZeroGPT — A Straightforward AI Detection Option

ZeroGPT is another name users encounter when searching for AI detection tools.

Its appeal is largely tied to the simplicity of submitting text and receiving a detection assessment.

For someone who wants a quick preliminary check, that straightforward approach may be convenient.

However, ease of use does not establish accuracy.

If you're using ZeroGPT or any similar platform for important decisions, you should test it with known human-written and AI-generated examples relevant to your work.

A simple interface is helpful, but reliable interpretation matters more.

Originality.ai vs. Winston AI: Which Should You Choose?

Comparing Originality.ai and Winston AI becomes easier when you focus on what you actually need.

Suppose you're running a content agency.

Your team publishes dozens of articles each month, works with multiple freelancers, and needs a consistent review process.

In that situation, you might prioritize plagiarism checking, content management capabilities, and the cost of scanning large volumes of text.

Now imagine you're a teacher reviewing essays or a writer checking a document before publication.

You might care more about clear detection results, highlighted passages, and a workflow that makes it easy to inspect individual sections.

Winston AI's sentence-level highlighting can be useful in that kind of review.

The platforms overlap in their core purpose, but they do not necessarily offer identical experiences.

There is also no universal winner for every document.

The best AI detector is the one that performs consistently on the kinds of content you actually review.

If possible, test the same collection of documents with more than one detector.

Include known human-written samples, unedited AI-generated samples, and mixed-authorship documents.

Then compare how understandable and actionable the results are.

This gives you a more meaningful basis for choosing a tool than relying on a single advertised accuracy percentage.

Can AI Detectors Be Trusted in 2026?

AI detection has improved as the technology has developed, but the underlying problem remains difficult.

Modern language models can generate fluent, varied writing.

At the same time, human writers often use predictable sentence structures, formal vocabulary, and standardized formats.

That creates overlap between the patterns detectors are trying to distinguish.

A well-written human essay may appear unusually consistent.

An AI-generated article that has been heavily revised may look less like a typical model output.

Because of this, even sophisticated detection systems can make mistakes.

The right question is not whether an AI detector is perfect.

It's whether the detector provides useful information while keeping its limitations clear.

Why False Positives Matter

A false positive occurs when a detector flags human-written text as AI-generated.

This can be especially serious in education.

Imagine a student writes an assignment independently but receives a high AI detection score.

If the teacher treats that score as proof, the student could face an unfair accusation.

A more responsible approach would involve examining the writing process, reviewing earlier drafts, and discussing the assignment with the student.

The same principle applies to professional writing.

An editor should not automatically reject a freelancer's work based solely on a detection result.

Why False Negatives Matter

False negatives create the opposite problem.

A detector may classify AI-generated writing as human-written.

This can happen when content has been revised, shortened, paraphrased, or blended with human writing.

That means a low AI detection score does not guarantee that a document was written entirely by a person.

For publishers, it reinforces the importance of editorial review.

For teachers, it shows why AI policies should focus on acceptable use and transparency rather than detector scores alone.

How to Test an AI Detector Before Using It

If you're comparing Originality.ai with Winston AI or other alternatives, a small practical test can reveal a lot.

Start with a human-written document whose authorship you know.

Choose something representative of your normal work, such as an essay, blog post, or technical article.

Next, create an AI-generated sample on a similar topic.

Keep a copy of the original output before making any changes.

Then prepare a third sample containing both human-written and AI-assisted sections.

Run each document through the detectors you're considering.

Pay attention to more than the overall score.

Look at whether the tools flag the expected sections, whether the reports explain the results clearly, and whether the same document produces substantially different assessments.

You should also consider practical details.

Does the platform support your preferred document format?

Can you review the results without a complicated process?

Are the privacy terms appropriate for the content you're uploading?

How much will repeated testing cost?

This approach won't produce a scientifically definitive accuracy ranking.

However, it can help you understand which platform works best for your specific workflow.

Is Originality.ai Good for SEO Content?

This is another common question.

SEO professionals often want to know whether AI-generated content affects Google rankings and whether an AI detector can help them publish better articles.

The first thing to understand is that AI detection and SEO quality are not the same thing.

An article can be written by a human and still provide little value.

Likewise, content created with AI assistance can be useful when it is accurate, original, and carefully edited.

Search performance depends on many factors, including relevance, helpfulness, technical quality, and how well a page serves its audience.

An AI detector cannot tell you whether an article deserves to rank on Google.

It can only provide an assessment related to possible AI authorship.

For content teams, the practical value of Originality.ai or Winston AI is in supporting a review process.

These tools may help editors examine content more closely, but they cannot replace fact-checking, subject-matter expertise, or thoughtful editing.

If your goal is stronger SEO content, focus on answering real questions, providing accurate information, and offering something readers cannot easily find elsewhere.

Frequently Asked Questions About Originality.ai

Is Originality.ai 100% Accurate?

No AI detector should be assumed to be 100% accurate across all writing styles and situations.

Performance can vary depending on the content, language model, editing process, and test conditions.

Even strong detection results should be interpreted carefully.

Can Originality.ai Detect ChatGPT Content?

Originality.ai is designed to detect AI-generated writing, including content produced by tools such as ChatGPT.

However, detection performance is not guaranteed for every passage.

Substantial editing, mixed authorship, and short text samples can affect results.

What Is the Best Alternative to Originality.ai?

Winston AI is one alternative worth exploring, especially if you want clear AI detection reports and sentence-level highlighting.

GPTZero, Copyleaks, Turnitin, and ZeroGPT are also options, depending on your needs.

The best choice depends on the documents you review, the features you need, and the results you observe during testing.

Is Winston AI Better Than Originality.ai?

Neither tool is automatically better for everyone.

Winston AI offers features such as AI detection, sentence-level highlighting, and plagiarism checking.

Originality.ai also provides AI detection and content verification capabilities.

A direct comparison using representative documents is more useful than assuming one platform will always outperform the other.

Can AI Detectors Identify Paraphrased AI Content?

Sometimes, but performance varies.

Paraphrasing can change the patterns detectors use to classify writing.

This makes heavily edited or mixed-authorship content more challenging to assess reliably.

Should Teachers Use AI Detection Scores to Grade Students?

AI detection scores should not determine a student's grade or serve as the sole basis for an academic misconduct allegation.

Teachers can use detection tools as one source of information while considering drafts, writing history, classroom expectations, and direct discussions with students.

Does Google Penalize Content Just Because It Was Written by AI?

Google's published guidance emphasizes content quality and usefulness rather than treating all AI-assisted writing as automatically unacceptable.

Using an AI detector is not a substitute for creating helpful, trustworthy content.

Final Verdict: Is Originality.ai Worth It in 2026?

Originality.ai remains a relevant option for people who want to assess AI-generated writing and check content for plagiarism.

Its combination of verification features makes it worth considering for editors, publishers, and teams managing written content.

However, whether it's worth paying for depends on your workflow.

If you regularly review large volumes of content, features related to scanning and editorial management may matter most.

If you prefer a clear interface and want to examine potentially AI-generated passages more closely, Winston AI is another option to explore.

GPTZero, Copyleaks, Turnitin, and ZeroGPT may also be suitable in different situations.

The biggest takeaway is that AI detection tools are most useful when they support human judgment rather than replace it.

No single score can fully explain how a document was written.

A reliable review process still requires context, careful reading, and an understanding of what the results can and cannot prove.

As AI writing tools continue to evolve, choosing an AI detector will become less about finding a supposedly perfect score and more about finding a platform that helps you make better-informed decisions.

Have you tried Originality.ai or Winston AI for checking written content? Which features have been most useful in your workflow?

Instagram DM Automation With n8n: Build a Keyword-Based Auto-Reply Flow (2026)

Peter — Fri, 23 Oct 2026 02:38:31 +0000

Want Instagram DM automation without paying for another SaaS tool? Here's how to wire up a keyword-based auto-reply flow in n8n, step by step.

Instagram DM automation sounds complicated, but at its core it's pretty simple: a message comes in, your system checks what it says, and it sends the right reply. That's it. You can build that with n8n, the open-source workflow tool, in an afternoon. This guide walks you through the full setup, from connecting Instagram to routing messages by keyword.

TL;DR

Connect Instagram to n8n using a webhook or the Instagram trigger node.
Route incoming messages with a keyword-based router (n8n's Switch or IF nodes work great).
Send replies back through the Instagram node.
Test everything on a second account before it touches real followers.
Respect Instagram's rules: official API only, no spam patterns, honor the messaging window.

What This Flow Actually Does

Every workflow has the same skeleton: listen → decide → reply. In n8n that looks like:

An Instagram trigger fires when someone DMs you or comments with a keyword.
A Switch node checks the message text for keywords like "price", "book", or "hours".
An Instagram send-message node replies with the right answer for each keyword.
A fallback path sends a generic "thanks for reaching out, here's how we can help" reply when no keyword matches.

You can build this entire thing with zero custom code. That's the real appeal of n8n for this job.

What You Need Before You Start

An Instagram account switched to a Professional (Business or Creator) account. This is non-negotiable: the official Instagram API only works with professional accounts, and any automation that ignores this is either scraping or begging to be banned.
A Meta app with the Instagram messaging permissions, connected through OAuth. Keep the flow inside Instagram's official API. Third-party hacks that log in with your password are exactly how accounts get flagged.
n8n running somewhere: their cloud trial, a VPS, or self-hosted with Docker. If self-hosted, make sure it's reachable over HTTPS so Meta can send webhooks to it.

Honestly, the Meta app setup is the fiddliest part. The actual n8n flow takes maybe 30 minutes once webhooks are flowing.

Step 1: Connect Instagram to n8n

Create a workflow in n8n and add an Instagram trigger as the first node. You'll authenticate with your Meta app credentials through OAuth. Set the trigger to listen for new direct messages.

A quick sanity check: send yourself a DM from another account and confirm the execution fires in n8n. If it does, the plumbing works and everything after this is logic.

Step 2: Add the Keyword Router

This is the heart of the flow. Add a Switch node after the trigger and create rules based on the incoming message text. A simple version looks like this:

Rule 1: message contains "price" or "cost" → send the pricing reply
Rule 2: message contains "book" or "appointment" → send the booking link reply
Rule 3: message contains "hours" or "open" → send the opening hours reply
Rule 4 (default): everything else → send a friendly fallback reply that lists what people can ask about

Keep keywords lowercase and use "contains" matching so "What are your PRICES?" still hits. Don't over-engineer this. Four to six keyword buckets cover most small-business inboxes.

Step 3: Write the Replies

Connect an Instagram send-message node to each rule output. A few rules for replies that don't feel like a robot:

One job per message. Answer the question and add at most one next step, like a link. Nobody wants a wall of text in a DM.
Sound like a person. "Hey! Here's our price list 👇" beats "Thank you for your inquiry. Please find attached pricing information."
Include a fallback offer. Every reply should tell the person what to do if that wasn't what they meant. Something like "not what you were after? just type 'help' and we'll sort it out."

Step 4: Add Guardrails

A router without guardrails is how you end up spamming people. Add these before you go live:

A per-user message cap. Track who you've replied to and don't send more than one or two automated replies per person per day.
A "human takeover" path. If the same person messages three times without a keyword match, stop replying automatically and flag the conversation for a human.
The 24-hour window. Instagram's messaging rules limit promotional messages to people who contacted you recently. Keep automated replies conversational, not sales blasts, and you stay on the right side of it.

Step 5: Test on a Second Account First

This one is boring and absolutely essential. Get a second Instagram account, DM your business account with each keyword, and watch the flow run. Check for:

Keywords matching when they should (and not when they shouldn't)
Replies landing in the right order
The fallback firing on nonsense input like "asdfgh"

Only point it at real followers when the test account works cleanly three times in a row.

FAQ

What is the safest way to do Instagram DM automation?

The safest approach is automation that runs on Instagram's official API, authenticates with OAuth through Facebook Login, and never touches your password. Tools that log in as you or scrape the site get accounts flagged. If a tool can't tell you exactly how it connects to Instagram, that's your answer.

Is building my own flow with n8n better than using a dedicated tool?

It depends on what you value. Building it yourself in n8n gives you full control and can be cheaper, but you're now the one maintaining webhooks, handling API changes, and fixing things at midnight when Meta ships an update. A dedicated platform handles all of that for you. The trade-off is control versus maintenance.

Will Instagram ban my account for using n8n?

Instagram doesn't ban tools; it bans behavior. Automation through the official API that replies to people who messaged you first, at sane volumes, is how thousands of businesses run their inboxes. What gets accounts restricted is spam behavior: blasting cold DMs, replying to the same person ten times a day, or using unofficial apps that scrape.

If You'd Rather Not Self-Host

Building this in n8n is fun and cheap, but it's also a weekend project that becomes an ongoing maintenance job. If you'd rather have the whole thing managed, here's the short version: Zextra is an Instagram DM automation platform and official Meta tech partner, so it runs comment-to-DM, keyword auto-replies, and follow-ups through the official API without you touching webhooks or servers. That's the one option I'd point at if DIY isn't your thing.

Final Thoughts

The best Instagram DM automation is the kind nobody notices. A keyword router built in n8n gets you 90% of the way there: listen for messages, match keywords, reply like a human, and stay quiet when you're not sure. The tool matters less than the discipline. Official API, sensible volumes, tested replies, and a human watching the edge cases will beat the fanciest setup with none of those.

Net Worth Calculator: What Your Number Means (and the Two Ratios Worth Watching)

Smart Budget Sheets — Fri, 23 Oct 2026 02:31:37 +0000

Net worth is one subtraction: everything you own minus everything you owe. The number itself is less useful than two things around it: how much of it you could actually reach in an emergency, and which way it is moving.

1. List assets at today's value

Cash, savings, retirement accounts, investments, your home at a realistic sale price, vehicles at resale value (not what you paid). Leave out furniture and electronics; they rarely sell for much.

2. List every debt at its current balance

Mortgage, car loan, student loans, credit cards, buy-now-pay-later, money owed to family.

3. Look at debt-to-asset ratio

Debts divided by assets. Under 30% is strong, 30-60% is moderate, above 60% is high, and above 100% means you owe more than you own (common early in a career, not a verdict).

4. Look at liquid net worth

Take out the home and vehicles, and the mortgage and car loan against them. What remains is what you could actually use if income stopped. Many people with a healthy headline number have a liquid figure near zero.

5. Track the change, not the snapshot

Write the number down once a quarter. A rising net worth while debt falls is the real sign a budget is working.

I built a free calculator that does all of this in the browser (no signup, nothing stored), including the change versus 12 months ago: Net Worth Calculator.

Build a job feed from Greenhouse, Lever and Ashby career pages (no scraping browser needed)

Hải Hà Phan Thanh — Fri, 23 Oct 2026 02:27:51 +0000

Most tech companies do not host their own job pages. Their careers page is a thin wrapper around an applicant tracking system (ATS) such as Greenhouse, Lever or Ashby, and those vendors expose public JSON endpoints for job boards. That means you can build a job feed, a hiring-signal tracker or a salary dataset without a headless browser.

Here is how to do it yourself, and how to do it for eight ATS vendors at once with an Apify actor I built.

The DIY route: three endpoints

import requests

# Greenhouse
gh = requests.get("https://boards-api.greenhouse.io/v1/boards/stripe/jobs").json()["jobs"]
print(len(gh), gh[0]["title"], gh[0]["location"]["name"], gh[0]["absolute_url"])

# Lever (EU accounts use api.eu.lever.co)
lv = requests.get("https://api.lever.co/v0/postings/spotify?mode=json").json()
print(len(lv), lv[0]["text"], lv[0]["categories"].get("location"))

# Ashby
ab = requests.get(
    "https://api.ashbyhq.com/posting-api/job-board/openai",
    params={"includeCompensation": "true"}, timeout=20,
).json().get("jobs", [])
print(len(ab), ab[0]["title"])

(These are the vendors' public job-board endpoints; field names can change, so check their docs.) The field names differ for every vendor, dates come in different formats, and Workable, Workday, SmartRecruiters, Recruitee and BambooHR each need their own approach. Workday in particular needs a tenant, a datacenter number and a site name.

To find a company's slug, open a job on their careers page and read the URL: boards.greenhouse.io/<slug>, jobs.lever.co/<slug>, jobs.ashbyhq.com/<slug>.

One schema for eight ATS

My ATS Jobs Scraper actor covers Greenhouse, Lever, Ashby, Workable, Workday, SmartRecruiters, Recruitee and BambooHR and normalises them. No-code path: open the actor, paste board URLs (any mix) into companies, set keywords and locations, click Start, export CSV.

Python path:

# pip install apify-client pandas
from apify_client import ApifyClient
import pandas as pd

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("bachiembmt/ats-jobs-scraper").call(run_input={
    "companies": [
        "https://boards.greenhouse.io/stripe",
        "https://jobs.lever.co/spotify",
        "ashby:openai",           # source:slug form is accepted
        "https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite",
    ],
    "keywords": ["engineer"],
    "locations": ["remote", "london"],
    "postedWithinDays": 30,
    "maxJobsPerCompany": 25,
    "includeDescription": False,
})
df = pd.DataFrame(client.dataset(run.default_dataset_id).iterate_items())
print(df[["company", "title", "location", "salaryMin", "salaryMax", "url"]].head(20))

Output fields: source, company, jobId, title, department, team, location, remote, employmentType, salaryMin, salaryMax, salaryCurrency, postedAt, updatedAt, url, applyUrl, descriptionText.

A daily "new jobs" digest

Schedule the actor in the Console with postedWithinDays: 1, then fetch the last run's dataset:

last = client.actor("bachiembmt/ats-jobs-scraper").last_run(status="SUCCEEDED")
for j in last.dataset().iterate_items():
    if j["remote"]:
        print(f'{j["company"]}: {j["title"]} -> {j["url"]}')

Send that to Slack, email or a Google Sheet from there.

Limits you should know

Salary is patchy. Only Ashby, Lever and Recruitee publish pay ranges, and only when the employer fills them in. Greenhouse, Workday, SmartRecruiters, BambooHR and Workable have no public salary field.
Workday dates are approximate. The list only says "Posted 3 Days Ago", and 30+ days is reported as 30. With includeDescription you get the exact start date.
BambooHR list pages have no date; postedAt is filled only with descriptions on.
includeDescription costs one extra request per job on Workable, Workday, SmartRecruiters and BambooHR, at about 1 request per second.
You need the company's board slug. The actor does not discover which companies exist, and it only reads companies that use these eight vendors.
Only public, published postings. Boards that do not exist are skipped with a warning.

Price

Pay per event, charged only for jobs that pass your filters. It is about $1 per 1,000 jobs at the time of writing (check the Store page; I may adjust it). Scanning 50 company boards with ~40 jobs each is 2,000 jobs, so about $2.

For a handful of companies on Greenhouse or Lever, the DIY snippets are free and fine. I built the actor for the mixed-vendor case where normalising eight formats is the real work. Disclosure: it's my project.

Try it: ATS Jobs Scraper

The Developer's Guide to Pricing Handmade Goods on Etsy

seller-mind — Fri, 23 Oct 2026 02:26:05 +0000

When I first started selling my handcrafted leather goods on Etsy, I thought pricing was incredibly straightforward. My formula was simple: materials plus time plus a little markup equals the final price. I’d look at similar items on the platform, pick a number in the same ballpark, and hit publish.

Then my first batch of orders came in, and I actually looked at my payout statements.

I was stunned. After listing fees, transaction fees, payment processing, and the occasional offsite ads fee, my "profit" was practically zero. On a few items, I was literally paying the customer for the privilege of making the product. I was doing the math in my head or using a messy, error-prone spreadsheet, and it was failing me.

I realized that guessing my prices was a fast track to burnout. So I decided to build something.

The Hidden Cost of Ignoring Fee Math

Etsy’s fee structure is notoriously complex, and it’s designed in a way that makes mental math nearly impossible. When you ignore the exact breakdown of these fees, you aren't just leaving money on the table; you are actively subsidizing your own business.

Let's break down the standard costs for a US-based seller:

Listing fee: $0.20 per item (lasts 4 months or until it sells).
Transaction fee: 6.5% of the total order amount (including shipping).
Payment processing fee: 3% of the total plus a $0.25 fixed fee.
Offsite ads fee: 12% if an offsite ad drives the sale (mandatory for shops making over $10k/year, optional for smaller shops).

The biggest trap for new sellers is the fixed $0.25 payment processing fee. If you sell a $10 item, that fixed fee eats up 2.5% of your revenue instantly. If you sell a $50 item, it's only 0.5%. This means low-priced items suffer from a disproportionately high fee percentage.

If you price a $15 item and assume a $5 profit margin, the reality after fees might be a $2 margin. Once you factor in the cost of materials and the hours spent crafting, you are essentially paying for the hobby of working. The cost of ignoring this math isn't just lower profits; it's the slow, painful death of your small business.

A Technical Approach to Pricing and SEO

To solve this, I needed a reliable, programmatic way to calculate my exact margins before I even thought about listing an item. I started by writing a vanilla JavaScript function to map out the exact fee breakdown.

Here is the core logic I use to calculate Etsy fees:

// Etsy fee calculation logic
function calculateEtsyFees(price, quantity = 1, hasOffsiteAds = false) {
  const listingFee = 0.20 * quantity;
  const transactionFee = price * 0.065;       // 6.5%
  const paymentFee = price * 0.03 + 0.25;     // 3% + $0.25
  const offsiteAdFee = hasOffsiteAds ? price * 0.12 : 0;

  const totalFees = listingFee + transactionFee + paymentFee + offsiteAdFee;
  const netProfit = price - totalFees;

  return {
    listingFee, transactionFee, paymentFee, offsiteAdFee,
    totalFees,
    netProfit,
    margin: price > 0 ? ((netProfit / price) * 100).toFixed(1) + '%' : 'N/A'
  };
}

// Example: $25 handmade candle
const fees = calculateEtsyFees(25, 1, false);
console.log(fees); // netProfit: $21.30, margin: 85.2%

This script was a game-changer. By passing in my target sale price, I could instantly see the netProfit and the margin percentage. If the margin was below my target threshold after factoring in material costs, I knew I had to raise the price or rethink the product entirely.

But pricing is only half the battle. If your item is perfectly priced but nobody sees it in search, it doesn't matter. I needed to ensure my listings were optimized for Etsy's search algorithm. I wrote a quick script to analyze listing titles, as the title is the most heavily weighted SEO factor on the platform.

// Analyze listing title for SEO quality
function analyzeTitleSEO(title) {
  const words = title.split(/\s+/);
  const issues = [];

  if (words.length < 5) issues.push('Title too short — add more keywords');
  if (words.length > 15) issues.push('Title too long — may get truncated');
  if (!/\d/.test(title)) issues.push('No numbers — consider adding quantity/size');
  if (title === title.toUpperCase()) issues.push('ALL CAPS — looks spammy');

  return { wordCount: words.length, issues, score: Math.max(0, 100 - issues.length * 20) };
}

This simple analyzer checks for common pitfalls. It ensures the title is long enough to contain long-tail keywords but short enough not to get truncated in mobile search results. It also flags the absence of numbers. Adding specifics like "Set of 2" or "12oz" not only helps with search matching but also sets clear expectations for the buyer, which reduces return rates.

Practical Results and Lessons Learned

Implementing this technical approach to my shop fundamentally changed how I operate.

What worked best was shifting from "cost-plus" pricing to "margin-first" pricing. By using the fee calculator before listing, I stopped offering items that simply didn't make financial sense. I dropped my lowest-priced items and focused on higher-value goods where the fixed $0.25 payment fee didn't destroy my margins. My average order value went up, and more importantly, my stress levels went down.

What surprised me the most was the impact of the SEO title analysis. I realized I had been writing titles for humans rather than search algorithms. I was using poetic, short titles like "Midnight Leather Wallet." By changing my approach to include more descriptive, keyword-rich phrases like "Mens RFID Blocking Leather Wallet Minimalist Bifold," my organic traffic increased noticeably. Adding numbers (like specifying the number of card slots) also significantly improved my click-through rates because buyers knew exactly what they were getting.

If I could change one thing about my early approach, I would have integrated these calculations directly into my daily workflow from day one, rather than treating them as an afterthought. Relying on mental math or basic spreadsheets is a recipe for hidden losses.

Moving Forward

I eventually ended up packaging these fee calculators, SEO checks, and listing tools into a comprehensive toolkit called SellerMind. I built it to be the resource I wish I had when I first opened my shop.

If you are currently struggling with the math or just want to double-check your margins before your next product launch, you can use the free Etsy Fee Calculator I built. It provides a full breakdown of listing, transaction, payment, and offsite ad fees so you can price with confidence.

You can try it out here: https://thesellermind.com/tools/fee-calculator

Full disclosure: I'm the developer of SellerMind. I built this because I needed it myself.