DEV Community: Leandro Marcos Moreira

How to get UK company data (Companies House) in a single API call

Leandro Marcos Moreira — Sat, 30 May 2026 21:55:05 +0000

If you've integrated the official UK Companies House API, you know the pain:
to build a useful picture of a company you need three separate calls — the
company profile, the officers/directors, and the persons with
significant control (PSC) — and then stitch and normalise them yourself.

For KYB, due diligence or lead enrichment, that's a lot of plumbing on every lookup.

The data you usually want

Profile: name, status, type, incorporation date, registered office, SIC codes
Officers/directors: who runs it (active and resigned)
PSC: who ultimately owns/controls it

Doing it directly (three calls)

BASE=https://api.company-information.service.gov.uk
curl -u "$CH_KEY:" $BASE/company/09446231
curl -u "$CH_KEY:" $BASE/company/09446231/officers
curl -u "$CH_KEY:" $BASE/company/09446231/persons-with-significant-control

Then you merge them, handle missing fields, add caching and rate limiting... per lookup.

Doing it in one call

I bundled these into a single endpoint that returns one normalised, cached JSON
response:

curl "https://api.firmfox.co.uk/v1/company/09446231" \
  -H "X-RapidAPI-Key: YOUR_KEY" \
  -H "X-RapidAPI-Host: api.firmfox.co.uk"

{
  "company_name": "MONZO BANK LIMITED",
  "company_status": "active",
  "date_of_creation": "2015-02-18",
  "registered_office_address": { "locality": "London", "postal_code": "EC2A 2AG" },
  "officers": { "active_count": 14, "total_count": 29, "items": [ /* ... */ ] },
  "persons_with_significant_control": { "total_count": 3, "items": [ /* ... */ ] }
}

Python

import requests

def get_company(number, key):
    r = requests.get(
        f"https://api.firmfox.co.uk/v1/company/{number}",
        headers={"X-RapidAPI-Key": key, "X-RapidAPI-Host": "api.firmfox.co.uk"},
    )
    r.raise_for_status()
    return r.json()

c = get_company("09446231", "YOUR_KEY")
print(c["company_name"], "-", c["officers"]["active_count"], "active directors")

Node.js

const res = await fetch("https://api.firmfox.co.uk/v1/company/09446231", {
  headers: {
    "X-RapidAPI-Key": process.env.RAPIDAPI_KEY,
    "X-RapidAPI-Host": "api.firmfox.co.uk",
  },
});
const c = await res.json();
console.log(c.company_name, c.officers.active_count, "active directors");

When this is handy

KYB / onboarding: verify a business and its controllers in one request.
Due diligence: pull officers + PSC for counterparty checks.
Lead enrichment: turn a company number into a full record in your CRM.

It's free to start on RapidAPI, and the data comes from UK Companies House
(Crown copyright, Open Government Licence). I built it because I was tired of the
three-call stitching — hope it saves someone else the same work.

👉 https://rapidapi.com/leandromarcosmoreira/api/uk-company-lookup-enrichment

Feedback welcome — what fields/filters would make this genuinely useful for you?
(Filing-change monitoring/alerts is on my list.)
Canonical/links

Why I Switched from Node.js to Bun for AI Backends (Benchmarks Inside)

Leandro Marcos Moreira — Mon, 30 Mar 2026 22:57:37 +0000

I run AI agents that make hundreds of API calls per minute. Node.js was the bottleneck. Then I tried Bun.

The Numbers

Metric	Node.js 22	Bun 1.3	Difference
Startup	200ms	12ms	16x faster
HTTP requests/sec	45,000	110,000	2.4x faster
SQLite reads	0.8ms	0.4ms	2x faster
Memory (idle)	45MB	22MB	2x less
npm install	12s	2s	6x faster

Why It Matters for AI

AI backends have a unique workload:

High HTTP throughput — proxying LLM API calls
SQLite for state — conversation history, CRM data
Fast startup — serverless/edge deployments
Low memory — running on constrained devices (Raspberry Pi)

Bun wins on all 4.

My Stack

import { Hono } from "hono";
import { Database } from "bun:sqlite";

const app = new Hono();
const db = new Database("app.db");

// SQLite with WAL mode — 0.4ms reads
db.exec("PRAGMA journal_mode=WAL");
db.exec("PRAGMA cache_size=64000");

app.post("/chat", async (c) => {
  const { message } = await c.req.json();
  // Call Claude API
  const response = await fetch("https://api.anthropic.com/v1/messages", {
    method: "POST",
    headers: { "x-api-key": process.env.ANTHROPIC_API_KEY },
    body: JSON.stringify({ model: "claude-sonnet-4-20250514", messages: [{ role: "user", content: message }] })
  });
  return c.json(await response.json());
});

export default { port: 3000, fetch: app.fetch };

That's a complete AI backend in 15 lines.

The Gotchas

Not all npm packages work — native addons may need recompilation
Debugging — Node.js debugger is more mature
Production stability — Bun is stable but Node has 15 years of battle-testing

For AI backends specifically? Bun is the clear winner.

Full SaaS Template

I built a complete SaaS boilerplate with Bun + Hono + React: auth, billing, dashboard, AI agent.

WhatsApp AI Bot (Bun) - $79.99 | AI Agent Kit - $49.99

Are you using Bun in production? What's your experience?

5 Prompt Engineering Patterns That 10x Your AI Output

Leandro Marcos Moreira — Mon, 30 Mar 2026 22:57:31 +0000

After building AI agents for 6 months, I found 5 patterns that consistently produce better output than generic prompting.

1. Constraint-First Prompting

Don't start with what you want. Start with constraints.

BAD: Write a blog post about AI agents

GOOD: Write a blog post about AI agents.
Constraints:
- Max 800 words
- Include 2 code examples
- Target: senior developers
- Tone: practical, no hype
- End with actionable takeaway

The constraints force the model to think within boundaries, producing tighter output.

2. Output-First Design

Define the exact output format BEFORE the task.

Output format:
{
  "title": "...",
  "severity": "critical|high|medium|low",
  "root_cause": "...",
  "fix": "..."
}

Now analyze this error: [ERROR_LOG]

This eliminates the "wall of text" problem. You get structured, parseable output every time.

3. Persona Stacking

Don't use one persona. Stack them.

You are simultaneously:
1. A senior backend engineer (focus on performance)
2. A security auditor (focus on vulnerabilities)
3. A junior developer (identify confusing code)

Review this PR from all 3 perspectives.

Multiple viewpoints in one prompt catches more issues than any single perspective.

4. Negative Space Prompting

Tell the AI what NOT to do. It's more effective than positive instructions.

Write a cold email.
DO NOT:
- Use the word "just"
- Start with "I hope this finds you well"
- Include more than 1 link
- Exceed 80 words
- Use exclamation marks

Negative constraints eliminate common AI patterns that make output feel generic.

5. Chain-of-Verification

Make the AI verify its own output.

Step 1: Generate a SQL query for [TASK]
Step 2: Explain what each JOIN does
Step 3: Identify potential performance issues
Step 4: Rewrite if any issues found
Step 5: Output only the final query

Self-verification catches errors that a single-pass prompt would miss.

Get 50 Production Prompts

I packaged 50 battle-tested prompts using these patterns across 10 business categories.

50 AI Prompts Pack - $19.99

Also: AI Agent Starter Kit - $49.99

Which pattern do you use most? Comment below.

Turn WhatsApp Into a 24/7 AI Sales Machine (With Code)

Leandro Marcos Moreira — Mon, 30 Mar 2026 21:07:24 +0000

Your business gets WhatsApp messages at 3am. Nobody answers. Lead lost.

I built a bot that handles this automatically — qualifies leads, answers questions, and sends payment links. Here is the architecture.

The Stack

Baileys (WhatsApp Web protocol, no Meta API needed)
Claude API for intelligent responses
SQLite for CRM (contacts, lead scores, conversation history)
Zero external dependencies. Runs on a $5 VPS.

How It Works

// Message comes in
sock.ev.on("messages.upsert", async ({ messages }) => {
  const msg = messages[0];
  const text = msg.message?.conversation || "";
  const from = msg.key.remoteJid;

  // Track in CRM
  crm.trackContact(from, text);

  // AI generates response with context
  const history = crm.getHistory(from, 20);
  const response = await claude.chat({
    system: salesPrompt,
    messages: history
  });

  // Send reply
  await sock.sendMessage(from, { text: response });

  // Auto-detect buying intent
  if (response.includes("payment")) {
    crm.updateStage(from, "closing");
  }
});

Built-in CRM

Every contact gets:

Lead score (0-100) based on buying signals
Sales stage: new → interested → qualified → closing → converted
Tags: auto-applied (lead, hot-lead, customer)
Full conversation history for AI context

CREATE TABLE contacts (
  phone TEXT PRIMARY KEY,
  name TEXT,
  lead_score INTEGER DEFAULT 0,
  stage TEXT DEFAULT "new",
  tags TEXT DEFAULT "",
  messages_count INTEGER DEFAULT 0,
  first_seen INTEGER,
  last_seen INTEGER
);

Sales Automation

The AI handles the full funnel:

Greeting — warm, asks about needs
Qualification — understands budget/timeline
Objection handling — addresses concerns naturally
Closing — sends payment link at the right moment
Follow-up — checks in after 24h silence

Not pushy. Not robotic. It builds genuine trust.

Deploy in 5 Minutes

npm install
cp .env.example .env  # add your Claude API key
npm start             # scan QR code, done

Or Docker:

docker compose up -d

Get the Full Template

14 files, 1450 lines of production code. CRM, sales automation, multi-language, Docker deployment.

WhatsApp AI Bot Template — $79.99

Also available:

What channels are you automating with AI?

How I Built an AI Agent That Actually Does Things (Not Just Chat)

Leandro Marcos Moreira — Mon, 30 Mar 2026 21:03:36 +0000

Most AI agents are just chatbot wrappers. Send a message, get a response. That is not an agent.

A real agent can read files, write code, run commands, and fix its own mistakes. Here is how.

The Tool-Calling Loop

User sends a message
LLM responds with a tool call (not text)
You execute the tool and send the result back
LLM continues reasoning
Repeat until done

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic();
const tools = [{
  name: "run_command",
  description: "Execute a shell command",
  input_schema: {
    type: "object",
    properties: { command: { type: "string" } },
    required: ["command"]
  }
}];

async function agent(task) {
  let messages = [{ role: "user", content: task }];
  while (true) {
    const resp = await client.messages.create({
      model: "claude-sonnet-4-20250514",
      max_tokens: 4096, tools, messages
    });
    if (resp.stop_reason === "end_turn")
      return resp.content[0].text;
    for (const block of resp.content) {
      if (block.type === "tool_use") {
        const { execSync } = await import("child_process");
        const result = execSync(block.input.command, { encoding: "utf-8" });
        messages.push({ role: "assistant", content: resp.content });
        messages.push({ role: "user", content: [{
          type: "tool_result", tool_use_id: block.id, content: result
        }]});
      }
    }
  }
}

const result = await agent("List all JS files and count lines");
console.log(result);

This 40-line agent can read files, run commands, chain steps, and self-correct.

Adding Memory

import { readFileSync, writeFileSync } from "fs";

class Memory {
  constructor(path = "./memory.json") {
    this.path = path;
    try { this.data = JSON.parse(readFileSync(path, "utf-8")); }
    catch { this.data = { decisions: [] }; }
  }
  remember(text) {
    this.data.decisions.push(text);
    writeFileSync(this.path, JSON.stringify(this.data, null, 2));
  }
}

Get the Full Kit

I packaged this into a production-ready framework with 6 tools, streaming, and 3 example agents:

What are you building with AI agents? Drop a comment.