DEV Community: Forgelab Africa

Forgelab Update

Forgelab Africa — Fri, 29 May 2026 09:02:26 +0000

Building Forgelab in Public #8 — 3 pending subscriptions, $20 MRR holding, Invoice API + PDF merge tutorials shipped this week

How to Merge Multiple PDFs with One API Call — Node.js, Python & curl

Forgelab Africa — Wed, 27 May 2026 09:01:55 +0000

Merging PDFs sounds simple — until you try to do it in production.

If you've reached for pdf-lib, pdfkit, or Puppeteer to merge PDFs in Node.js, you know the pain:

Conflicting dependencies that break on deploy
Memory spikes with large files
Complex page ordering logic
CI pipelines that randomly fail

There's a cleaner approach: offload it to an API and stay focused on your actual product.

The Forgelab PDF Merge API

The Forgelab PDF API accepts multiple PDF files and returns a single merged file. One endpoint. Standard HTTP. Works from any language.

Endpoint: POST https://www.forgelab.africa/api/pdf/merge

Auth: Pass your API key as the X-API-Key header.

Files are merged in the order they are uploaded. Upload order = page order.

curl

curl -X POST https://www.forgelab.africa/api/pdf/merge \
  -H "X-API-Key: YOUR_API_KEY" \
  -F "files=@document1.pdf" \
  -F "files=@document2.pdf" \
  -F "files=@document3.pdf" \
  --output merged.pdf

That's the whole thing. No install step.

Node.js

const fs = require('fs');
const FormData = require('form-data');
const fetch = require('node-fetch');

async function mergePDFs(filePaths, outputPath) {
  const form = new FormData();

  for (const filePath of filePaths) {
    form.append('files', fs.createReadStream(filePath));
  }

  const response = await fetch('https://www.forgelab.africa/api/pdf/merge', {
    method: 'POST',
    headers: {
      'X-API-Key': process.env.FORGELAB_API_KEY,
      ...form.getHeaders(),
    },
    body: form,
  });

  if (!response.ok) {
    const err = await response.json();
    throw new Error(`Merge failed: ${err.message}`);
  }

  const buffer = await response.buffer();
  fs.writeFileSync(outputPath, buffer);
  console.log(`Saved merged PDF to ${outputPath}`);
}

mergePDFs(
  ['invoice.pdf', 'receipt.pdf', 'contract.pdf'],
  'bundle.pdf'
);

Key points:

Always check response.ok before writing the file — a 429 or 401 response body is JSON, not a PDF.
Use form.getHeaders() so the Content-Type boundary is set correctly.
Store your API key in an environment variable, never hardcoded.

Python

import os
import requests

def merge_pdfs(file_paths: list[str], output_path: str) -> None:
    api_key = os.environ["FORGELAB_API_KEY"]

    files = [
        ("files", (path, open(path, "rb"), "application/pdf"))
        for path in file_paths
    ]

    response = requests.post(
        "https://www.forgelab.africa/api/pdf/merge",
        headers={"X-API-Key": api_key},
        files=files,
    )

    response.raise_for_status()

    with open(output_path, "wb") as f:
        f.write(response.content)

    print(f"Saved merged PDF to {output_path}")

merge_pdfs(
    ["invoice.pdf", "receipt.pdf", "contract.pdf"],
    "bundle.pdf"
)

raise_for_status() will raise an exception for 4xx/5xx responses, so you get clean error propagation without extra conditionals.

PHP

<?php

function mergePDFs(array $filePaths, string $outputPath): void
{
    $apiKey = getenv('FORGELAB_API_KEY');
    $curl   = curl_init();

    $postFields = [];
    foreach ($filePaths as $i => $path) {
        $postFields["files[$i]"] = new CURLFile($path, 'application/pdf');
    }

    curl_setopt_array($curl, [
        CURLOPT_URL            => 'https://www.forgelab.africa/api/pdf/merge',
        CURLOPT_POST           => true,
        CURLOPT_POSTFIELDS     => $postFields,
        CURLOPT_HTTPHEADER     => ["X-API-Key: $apiKey"],
        CURLOPT_RETURNTRANSFER => true,
    ]);

    $result   = curl_exec($curl);
    $httpCode = curl_getinfo($curl, CURLINFO_HTTP_CODE);
    curl_close($curl);

    if ($httpCode !== 200) {
        throw new \RuntimeException("PDF merge failed with HTTP $httpCode");
    }

    file_put_contents($outputPath, $result);
    echo "Saved merged PDF to $outputPath\n";
}

mergePDFs(
    ['invoice.pdf', 'receipt.pdf', 'contract.pdf'],
    'bundle.pdf'
);

Error Reference

Status	Meaning
`200`	Success — response body is the merged PDF binary
`400`	Invalid input — check your files are valid PDFs
`401`	Missing or invalid API key
`429`	Rate limit exceeded — upgrade your plan
`500`	Server error — retry with exponential backoff

Pricing

Plan	Price	Calls/month
Free	$0	5 calls
Starter	$5/month	100 calls
Pro	$15/month	1,000 calls
Business	$30/month	10,000 calls

Start on the free tier — no card required.

Get your API key at forgelab.africa.

Questions? Drop them in the comments or email info@forgelab.africa.

Generate Professional PDF Invoices via REST API — JSON In, PDF Out

Forgelab Africa — Mon, 25 May 2026 09:02:11 +0000

Building invoicing into your app is painful. You spend days wrestling with PDF generation libraries, template engines, multi-currency formatting, and email delivery — then repeat it for every project.

The Forgelab Invoice API handles all of it in one API call. Send JSON, get back a professional PDF invoice.

What it does

JSON in → professional PDF invoice out
Multiple templates (professional, minimal, modern)
Multi-currency support (USD, EUR, GBP, and more)
White-label option for agencies
Hosted URL + base64 download
Free tier: 5 invoices/month, no card required

Quick start with curl

curl -X POST https://api.forgelab.africa/v1/invoice/generate \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "template": "professional",
    "currency": "USD",
    "from": {
      "name": "Acme Corp",
      "email": "billing@acme.com",
      "address": "123 Main St, New York, NY"
    },
    "to": {
      "name": "Jane Smith",
      "email": "jane@example.com"
    },
    "items": [
      { "description": "Web Development", "quantity": 1, "rate": 2500.00 },
      { "description": "Hosting (6 months)", "quantity": 6, "rate": 25.00 }
    ],
    "notes": "Payment due within 30 days."
  }'

Response:

{
  "success": true,
  "invoice_id": "inv_abc123",
  "pdf_url": "https://api.forgelab.africa/v1/invoice/inv_abc123/pdf",
  "total": 2650.00,
  "currency": "USD"
}

Node.js example

const res = await fetch("https://api.forgelab.africa/v1/invoice/generate", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.FORGELAB_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    template: "professional",
    currency: "USD",
    from: { name: "Acme Corp", email: "billing@acme.com" },
    to: { name: "Jane Smith", email: "jane@example.com" },
    items: [
      { description: "Web Development", quantity: 1, rate: 2500 },
    ],
  }),
});

const { pdf_url, total } = await res.json();
console.log(`Invoice ready: ${pdf_url} — Total: $${total}`);

Python example

import requests

response = requests.post(
    "https://api.forgelab.africa/v1/invoice/generate",
    headers={
        "Authorization": f"Bearer {api_key}",
        "Content-Type": "application/json",
    },
    json={
        "template": "professional",
        "currency": "USD",
        "from": {"name": "Acme Corp", "email": "billing@acme.com"},
        "to": {"name": "Jane Smith", "email": "jane@example.com"},
        "items": [
            {"description": "Consulting", "quantity": 10, "rate": 150},
        ],
    }
)

data = response.json()
print(f"Invoice URL: {data['pdf_url']}")

PHP example

$response = file_get_contents("https://api.forgelab.africa/v1/invoice/generate", false,
  stream_context_create(["http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer {$apiKey}\r\nContent-Type: application/json",
    "content" => json_encode([
      "template" => "professional",
      "currency" => "USD",
      "from" => ["name" => "Acme Corp", "email" => "billing@acme.com"],
      "to"   => ["name" => "Jane Smith", "email" => "jane@example.com"],
      "items" => [["description" => "Design", "quantity" => 1, "rate" => 800]],
    ]),
  ]])
);
$data = json_decode($response, true);
echo $data["pdf_url"];

When to use it

SaaS apps that need automated billing documents for customers
Freelance tools for client invoicing without building from scratch
E-commerce VAT invoices and order receipts
Agencies building white-label invoicing products

Pricing

Plan	Price	Invoices/month
Free	$0	5
Starter	$5/mo	100
Pro	$15/mo	1,000
Business	$30/mo	10,000

No credit card required for the free tier.

Get your API key at forgelab.africa — docs, free tier, and full endpoint reference included.

Building Forgelab in Public #7 — Shipped PDF Images API, chasing first revenue growth

Forgelab Africa — Fri, 22 May 2026 09:02:00 +0000

This is week 7 of building Forgelab in public — a lean developer API platform. Every Friday I post honest numbers: what shipped, what didn't, and what I'm thinking. No vanity metrics.

What shipped this week

PDF to Images API

The headline ship: any PDF can now be converted to PNG or JPEG via a single REST call. No Poppler setup. No Ghostscript. No server dependencies to manage.

curl -X POST https://forgelab.africa/api/pdf/to-images \
  -H "X-API-Key: your-key" \
  -F "file=@report.pdf" \
  -F "format=png" \
  -F "dpi=150"

Response is a JSON array with base64-encoded images, one per page. You can specify which pages to convert or do the whole document.

What this unlocks: document preview thumbnails, OCR pre-processing pipelines, image-based document workflows — without running a server-side PDF renderer yourself.

2 more blog articles

"New: Convert PDFs to Images via REST API — PNG, JPEG, Any Page" — the launch post with full curl, Node.js, and Python examples
"5 API Key Security Mistakes That Expose Your App (And How to Fix Them)" — practical security guide targeting developers searching for API security patterns

Blog is now 11 articles deep. These are written to rank for developer search queries, not as marketing filler.

Honest numbers

Metric	This week	Last week
MRR	$20	$20
Paying customers	2	2
Waitlist signups	15	15
APIs live	5	5
Blog articles	11	9
Services running	11 / 11	11 / 11
Errors (last 24h)	0	0

No new revenue this week. MRR flat at $20. Zero waitlist movement. I'm not going to spin this — the product is live and stable, but it's not growing yet.

What I'm watching

Disk usage jumped from 22% to 41%. That's log files, SQLite databases, and the free tools getting used. Not alarming yet but I'm keeping an eye on it. Cleanup script on the to-do list.

All 11 services running clean — web, PDF API, Image API, QR Code API, Invoice API, PDF-to-JSON API, social manager, customer manager, admin dashboard, customer dashboard, Stripe relay. Zero crashes, zero restarts needed this week.

The 5 APIs that are live

PDF API — merge, split, compress, convert, PDF→images
Image API — resize, compress, watermark, format convert
PDF to JSON API — extract structured text and metadata from any PDF
QR Code API — generate (PNG/SVG/base64) and decode QR codes
Invoice API — generate professional PDF invoices from JSON (15 currencies, 3 templates)

Free tier: 5 calls/month, no card required. forgelab.africa

What's next: Currency API

Next build in the pipeline is a Currency API — real-time global currency rates via REST. Clean, fast, reliable. Target users: developers building multi-currency invoicing tools, e-commerce sites, fintech apps, and dashboards.

The endpoint shape will be something like:

# Get latest rates
GET /api/currency/rates?base=USD

# Convert an amount
POST /api/currency/convert
{ "from": "USD", "to": "EUR", "amount": 100 }

After Currency API: OCR API (extract text from images and documents).

Honest reflection

There's a gap between "product is live and working" and "product is growing." I'm sitting squarely in that gap right now.

Five APIs running. Solid infra. Eleven blog posts. Two paying customers. $20 MRR.

The problem isn't product quality — it's reach. Not enough developers know Forgelab exists. The free tools bring some organic traffic but the conversion funnel isn't moving. I think the next lever is more direct outreach: clearer Reddit presence, getting into developer communities where the problem is being discussed, and tightening the docs so the "getting started in 5 minutes" promise is actually true.

Revenue goal is $25,000 in 6 months. I'm at $20 MRR with no clear timeline for when the curve bends. That's uncomfortable to write, but that's where we are.

Next Friday I'll have the Currency API shipped and hopefully a clearer picture on distribution.

Forgelab — forgelab.africa
PDF API · Image API · PDF to JSON · QR Code API · Invoice API
Free tier: 5 calls/month, no card required.

5 API Key Security Mistakes That Expose Your App (And How to Fix Them)

Forgelab Africa — Wed, 20 May 2026 09:01:36 +0000

If you've ever hardcoded an API key and pushed it to GitHub, you're not alone — and your key is already compromised.

API key security is one of those topics developers know they should care about but rarely prioritize until something goes wrong. Here's a practical checklist of the 5 most common mistakes, with real code examples and fixes.

Mistake 1: Hardcoding Keys in Source Code

This is the most common mistake, and it's catastrophic.

// NEVER do this
const response = await fetch('https://api.forgelab.africa/pdf/compress', {
  headers: {
    'Authorization': 'Bearer fl_live_abc123xyz456secret'
  }
});

GitHub's secret scanning catches this quickly, but by then it's too late. Bots scrape GitHub continuously looking for exposed credentials.

The fix: Environment variables

// Node.js — safe approach
import dotenv from 'dotenv';
dotenv.config();

const API_KEY = process.env.FORGELAB_API_KEY;
if (!API_KEY) throw new Error('FORGELAB_API_KEY is not set');

const response = await fetch('https://api.forgelab.africa/pdf/compress', {
  headers: { 'Authorization': `Bearer ${API_KEY}` }
});

# Python — safe approach
import os
api_key = os.environ.get('FORGELAB_API_KEY')
if not api_key:
    raise ValueError('FORGELAB_API_KEY is not set')

Mistake 2: Committing .env Files

You put the key in .env — good. Then you committed .env to git — not good.

The fix:

# Add to .gitignore before first commit
echo ".env" >> .gitignore
echo ".env.local" >> .gitignore
echo ".env.production" >> .gitignore

Commit an .env.example with placeholder values instead:

# .env.example (safe to commit)
FORGELAB_API_KEY=your_api_key_here
DATABASE_URL=your_database_url_here

If you already committed .env, rotating the key is mandatory — even if you deleted it in the next commit. Git history is permanent.

Mistake 3: Using the Same Key Everywhere

One API key for local, staging, and production is a single point of failure. One leak exposes everything.

The fix: One key per environment

Most API platforms (including Forgelab) let you create multiple API keys:

fl_test_... for development and testing
fl_live_... for production only

If your test key leaks, rotate it — production is unaffected. This also means rate limit quotas are isolated so a runaway test script won't eat your production quota.

Mistake 4: No Key Rotation Plan

"I'll rotate it when something goes wrong" is how you end up rotating keys at 2am during an incident.

The fix: Proactive rotation

Rotate all API keys every 90 days
Rotate immediately when a developer leaves the team
Rotate immediately after any suspected exposure
Never share keys in Slack, email, or chat

# Test the new key before deleting the old one
curl -X POST https://api.forgelab.africa/pdf/compress \
  -H "Authorization: Bearer $NEW_FORGELAB_KEY" \
  -F "file=@test.pdf" \
  -o test-output.pdf

# Only delete old key after confirming new one works

Mistake 5: Not Monitoring Key Usage

If someone steals your key and uses it slowly, you might not notice for weeks — until an unexpected bill arrives.

The fix: Monitor API usage

Check your API dashboard weekly for unusual spikes
Set up billing alerts before hitting tier limits
Review rate limit headers in responses

Forgelab's API returns clear usage headers on every response:

X-RateLimit-Limit: 100
X-RateLimit-Remaining: 87
X-RateLimit-Reset: 1716192000

Log these in your application. A sudden drop from 87 to 3 remaining between requests is a red flag worth investigating.

Quick Security Checklist

Before pushing any code that uses an API key:

[ ] Key is in an environment variable, not in source code
[ ] .env is in .gitignore
[ ] .env.example exists with placeholder values
[ ] Separate keys for dev and production
[ ] Know how to rotate the key in under 5 minutes

Forgelab API

If you're using the Forgelab PDF API or Image API, you can generate and manage API keys from your dashboard. The free tier includes 5 calls/month — no card required.

# Compress a PDF with the Forgelab API
curl -X POST https://api.forgelab.africa/pdf/compress \
  -H "Authorization: Bearer $FORGELAB_API_KEY" \
  -F "file=@document.pdf" \
  -o compressed.pdf

Any questions? info@forgelab.africa

New: Convert PDFs to Images via REST API — PNG, JPEG, Any Page

Forgelab Africa — Mon, 18 May 2026 09:01:43 +0000

Your users upload PDFs. They want to preview page 1 before downloading the full file.

Most solutions involve installing Poppler, Ghostscript, or some native binary on your server. That works until it does not: CI pipelines break, Alpine Linux builds fail, memory spikes kill your serverless function.

There is a cleaner path.

Forgelab PDF API now converts PDFs to images

Send a PDF, get back PNG or JPEG images — one per page, or just the pages you need.

Quick start

# Convert the first page to PNG
curl -X POST https://www.forgelab.africa/api/pdf/to-images \
  -H "X-API-Key: your_key" \
  -F "file=@document.pdf" \
  -F "page=1" \
  --output page1.png

Node.js example

import FormData from 'form-data';
import fs from 'fs';
import fetch from 'node-fetch';

const form = new FormData();
form.append('file', fs.createReadStream('document.pdf'));
form.append('page', '1');
form.append('format', 'png');

const res = await fetch('https://www.forgelab.africa/api/pdf/to-images', {
  method: 'POST',
  headers: {
    'X-API-Key': process.env.FORGELAB_API_KEY,
    ...form.getHeaders(),
  },
  body: form,
});

const buffer = await res.arrayBuffer();
fs.writeFileSync('page1.png', Buffer.from(buffer));

Python example

import requests

with open('document.pdf', 'rb') as f:
    res = requests.post(
        'https://www.forgelab.africa/api/pdf/to-images',
        headers={'X-API-Key': 'your_key'},
        files={'file': f},
        data={'page': '1', 'format': 'jpeg'},
    )

with open('page1.jpg', 'wb') as out:
    out.write(res.content)

What this solves

Typical use cases:

Document preview — show page 1 as a thumbnail before users download the full file
Viewer apps — render pages on demand instead of loading the entire PDF in the browser
Thumbnail generation — auto-generate cover images for uploaded documents
E-signature flows — render pages as images for annotation layers

No binary dependencies on your server

The entire conversion runs server-side at Forgelab. Your app stays lean:

No Poppler
No Ghostscript
No ImageMagick
No temp file management
No memory spikes from in-process rendering

Works from any language that can make an HTTP request.

Pricing

Tier	Price	Calls/month
Free	$0	5 calls
Starter	$5/month	100 calls
Pro	$15/month	1,000 calls
Business	$30/month	10,000 calls

No credit card required for the free tier.

Get your API key at forgelab.africa — the PDF API also handles merge, split, compress, and convert, all on the same key.

Forgelab Week 6: $20 MRR, 5 APIs, and the Week I Fixed What You Cannot See

Forgelab Africa — Fri, 15 May 2026 09:02:46 +0000

Week 6 — Friday build in public update

Honest one this week: no new revenue. Still at $20 MRR with 2 paying customers.

But I shipped something important that you cannot see — and that is the point.

What happened this week

Fixed a critical Stripe webhook bug

The webhook secret in .env was pointing to the wrong key — a test-mode vs live-mode mismatch introduced during setup. Every webhook Stripe fired was failing signature verification silently. Payments were processing, but downstream usage tracking was unreliable. Found it, fixed it, confirmed it working.

This is exactly the kind of invisible bug that breaks your product for paying customers without anyone raising a hand.

Turned on the firewall

UFW was installed on the server but inactive. I ran a security audit and found it. Now active, locked to ports 22, 80, and 443 only. This should have been day-one infrastructure. It was not.

Security audit: 0 npm vulnerabilities

Ran npm audit across all 11 services. Clean. No critical or high issues.

Built and launched the customer dashboard

Users now have a place to log in and manage their API keys. Simple, fast, and live on port 3010.

11/11 services stable

No crashes. No memory leaks. Automated morning health check running daily at 7am via cron.

What is live right now

API	What it does
PDF API	merge, split, compress, convert
Image API	resize, compress, watermark, convert
PDF to JSON API	extract structured data from any PDF
QR Code API	generate PNG/SVG/base64, decode from image
Invoice API	generate PDF invoices from JSON — 3 templates, 15 currencies

Pricing starts at $5/month for 100 calls. Free tier: 5 calls/month, no card required.

→ forgelab.africa

The honest tension

Revenue is not growing because I have not started marketing properly. I have been heads-down building — 5 APIs in 6 weeks. That is real progress. But code does not sell itself.

This is the classic solo-builder trap: you keep building because building is comfortable, and selling is uncomfortable.

Next week I am stopping new API work and focusing only on:

Outreach — get 3 external signups from real developers (not test accounts)
One SEO blog post targeting a real developer search query
Wire up the free browser tools (merge-pdf, compress-pdf) to capture organic traffic

Numbers this week

Metric	Value
MRR	$20
Paying customers	2
Waitlist signups	15
APIs live	5
Services running	11 / 11
Blog articles	7
npm vulnerabilities	0
Uptime	100%

Building slow. Building honest.

I post weekly build-in-public updates every Friday. This is week 6.

Stack: Node.js 20, Express, SQLite, Stripe, Nginx — no VC, no team, no shortcuts.

PDF API is live on Forgelab

Forgelab Africa — Mon, 11 May 2026 10:00:02 +0000

We just shipped the Forgelab PDF API — a fast, affordable REST API for developers who need to handle PDF files without the hassle.

What it does:

Merge multiple PDFs into one
Split PDFs by page ranges
Compress PDFs to reduce file size
Convert PDFs to images (PNG/JPEG)

Pricing: Starts at $5/month for 100 calls/month. No hidden fees.

Quick start:

curl -X POST https://www.forgelab.africa/api/pdf/merge \
  -H "X-API-Key: your_key" \
  -F "files=@doc1.pdf" -F "files=@doc2.pdf"

Build in public #5 — Shipped 3 APIs this week: Invoice, QR Code, PDF-to-JSON | $20 MRR

Forgelab Africa — Fri, 08 May 2026 09:02:00 +0000

Forgelab — Build in Public: Week of May 8, 2026

Three APIs shipped this week. Here's what's live, what the numbers look like, and what's coming next.

What shipped this week

1. Invoice Generator API

Turn JSON into a professional PDF invoice in one POST request. Supports 3 templates (modern, classic, minimal), 15 currencies, and line item calculations with tax.

curl -X POST https://forgelab.africa/api/invoice/generate \
  -H "X-API-Key: fliv_your_key" \
  -H "Content-Type: application/json" \
  -d '{"company":"Acme Corp","client":"Big Client","currency":"USD","items":[{"description":"API Integration","quantity":1,"price":1200.00}]}'

Response: a ready-to-send PDF invoice.

Templates: modern, classic, minimal. Currencies: USD, EUR, GBP, NGN, KES, INR, BRL, JPY, and 7 more.

2. QR Code API

Generate QR codes in PNG, SVG, or base64. Decode QR codes from uploaded images.

# Generate
curl -X POST https://forgelab.africa/api/qr/generate \
  -H "X-API-Key: flqr_your_key" \
  -H "Content-Type: application/json" \
  -d '{"data":"https://forgelab.africa","format":"png"}'

# Decode
curl -X POST https://forgelab.africa/api/qr/decode \
  -H "X-API-Key: flqr_your_key" \
  -F "file=@qrcode.png"

Useful for event tickets, product labels, app deep links.

3. PDF-to-JSON API

Extract structured text from any PDF. Returns pages array, text content, word count, and document metadata.

curl -X POST https://forgelab.africa/api/pdf-json/extract \
  -H "X-API-Key: flpj_your_key" \
  -F "file=@invoice.pdf"

Useful for parsing invoices automatically, reading bank statements, or turning any document into structured data.

By the numbers (honest)

Metric	Today
APIs live	5
Paying customers	2
MRR	$20/month
Waitlist signups	15
API keys issued	4

MRR is small. But both customers are paying — not on a free trial, not me testing my own product. That distinction matters at week 3.

Goal: $25,000 in 6 months.

Stack

Node.js 20 + Express + SQLite on a single Linux server behind Nginx. Stripe handles billing via webhooks. No Kubernetes. No managed cloud. SQLite handles 5 APIs fine at this scale — when we hit 10k users the plan is PostgreSQL. Until then, near-zero ops overhead is a feature.

All 5 APIs live

PDF API — merge, split, compress, convert
Image API — resize, compress, watermark, convert
PDF-to-JSON API — extract structured data from PDFs
QR Code API — generate and decode QR codes
Invoice API — generate PDF invoices from JSON

One account, one API key format, same pricing tiers across all products at forgelab.africa.

Free browser tools (SEO strategy)

Three free browser tools:

Merge PDF — forgelab.africa/merge-pdf
Compress PDF — forgelab.africa/compress-pdf
Split PDF — forgelab.africa/split-pdf

5 free uses per month, no card required. They run on the Forgelab PDF API internally. Free tools drive Google traffic — API drives revenue. Zero ad spend.

Pricing

Plan	Price	API Calls
Free	$0	5/month
Starter	$5/month	100
Pro	$15/month	1,000
Business	$30/month	10,000

Building next

Currency API — real-time exchange rates, historical data, conversion
OCR API — extract text from images (scanned docs, receipt photos)

Building in public. If you have questions about the stack or are building something similar, drop a comment.

forgelab.africa

I built a PDF + Image + Invoice API platform — free tier, no card required

Forgelab Africa — Wed, 06 May 2026 18:39:40 +0000

What I built

Forgelab is a developer API platform that handles the boring document and image work so you can ship faster.

Right now it does four things:

PDF API — merge, split, compress, convert
Image API — resize, compress, convert, watermark
Invoice API — generate professional PDF invoices from JSON
QR Code API — generate and decode QR codes

The problem it solves

Every SaaS app eventually needs to generate invoices, resize images, or process PDFs. You either spend a week building it yourself, or you pay $99/month for a service that does one thing.

Forgelab bundles all of it under one API key.

How it works

# Generate an invoice in one API call
curl -X POST https://api.forgelab.africa/api/invoice/generate \
  -H "X-API-Key: YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "client": { "name": "Acme Corp", "email": "billing@acme.com" },
    "items": [{ "description": "Web development", "quantity": 10, "unit_price": 150 }],
    "currency": "USD",
    "template": "modern"
  }' \
  --output invoice.pdf

Pricing

Free: 5 calls/month, no card
Starter: $5/month — 100 calls
Pro: $15/month — 1,000 calls
Business: $30/month — 10,000 calls

One subscription works across all APIs.

Try it

https://forgelab.africa

I built this to scratch my own itch. Would love feedback from anyone who has dealt with invoice generation or PDF handling in their apps.

How to Compress PDFs via REST API — curl, Node.js & Python Examples

Forgelab Africa — Wed, 06 May 2026 09:02:23 +0000

If your app needs to compress PDFs, you have two paths:

Install pdf-lib, ghostscript, or puppeteer — and inherit binary dependencies, config complexity, and memory overhead.
Make one HTTP POST and let a dedicated API handle it.

Here's how the second option works with the Forgelab PDF API.

The endpoint

POST https://www.forgelab.africa/api/pdf/compress

Headers: X-API-Key: your_api_key

Body (multipart/form-data): file — the PDF to compress

Response: compressed PDF as a binary download.

curl

curl -X POST https://www.forgelab.africa/api/pdf/compress \
  -H "X-API-Key: $FORGELAB_API_KEY" \
  -F "file=@report.pdf" \
  --output compressed.pdf

A 10 MB PDF typically comes back under 2 MB.

Node.js

import fs from 'fs';
import fetch from 'node-fetch';
import FormData from 'form-data';

async function compressPdf(inputPath, outputPath) {
  const form = new FormData();
  form.append('file', fs.createReadStream(inputPath));

  const res = await fetch('https://www.forgelab.africa/api/pdf/compress', {
    method: 'POST',
    headers: {
      'X-API-Key': process.env.FORGELAB_API_KEY,
      ...form.getHeaders(),
    },
    body: form,
  });

  if (!res.ok) throw new Error(`Compress failed: ${res.status}`);

  const buffer = await res.buffer();
  fs.writeFileSync(outputPath, buffer);
  console.log(`Saved: ${outputPath}`);
}

compressPdf('invoice.pdf', 'invoice-compressed.pdf');

Python

import os
import requests

def compress_pdf(input_path: str, output_path: str) -> None:
    with open(input_path, "rb") as f:
        res = requests.post(
            "https://www.forgelab.africa/api/pdf/compress",
            headers={"X-API-Key": os.environ["FORGELAB_API_KEY"]},
            files={"file": f},
        )
    res.raise_for_status()
    with open(output_path, "wb") as out:
        out.write(res.content)
    print(f"Compressed PDF saved to {output_path}")

compress_pdf("report.pdf", "report-compressed.pdf")

Why use an API instead of a library?

Concern	Library (pdf-lib, ghostscript)	Forgelab API
Setup	Install + configure	HTTP call only
Binary deps	ghostscript, etc.	None
Memory usage	Spikes on large files	Server-side
Works in serverless	Sometimes	Always
Language	Library-specific	Any language

Offloading PDF processing to an API keeps your app lightweight and your deploys clean.

Pricing

Tier	Price	Calls/month
Free	$0	5 calls
Starter	$5/mo	100 calls
Pro	$15/mo	1,000 calls
Business	$30/mo	10,000 calls

No credit card required for the free tier.

Get your API key at forgelab.africa