Fibtec · Services · Integrator
01 · Software Integration as a Service (SIaaS) · Live in alpha

Describe both ends.
Get back the code.

The Integrator turns a schema, an API description or a sample of your data into a Python ETL script, an API connector or a webhook handler — written by Claude, in seconds. Nothing you upload is ever stored.

Try the Integrator ↗ Talk to us
Built on
Claude
ANTHROPIC CLAUDE API
Live now · Alpha release
Free to try, and nothing you upload is stored
The free plan covers 10 small jobs a month. Larger jobs are paid per job from prepaid credit, and the price is shown before you run them. Hosted at etlgen.fibtec.co.uk.
0
Data retained
15
Input formats
Free
Entry plan
Alpha
Status
Capabilities

What the Integrator delivers

ETL & Schema Mapping
Maps one data shape to another — renamed fields, type coercions, nested structures — as a single Python script that reads JSON on stdin and writes JSON on stdout. Schemas come from XSD, JSON Schema, OpenAPI or SQL DDL, or are inferred from a CSV, JSON, XML, YAML or MongoDB sample, and an inferred schema can be reviewed first.
Test Generation
Optionally generates a pytest suite for the ETL script in the same call, at the same price, so there is something to run against your own sample data straight away.
REST & GraphQL Connectors
From an OpenAPI document or a GraphQL introspection result: a client with one function per operation, the declared auth scheme (API key, bearer, basic or OAuth2) and pagination written as a generator. Standard library only, with no HTTP dependency to install.
Webhook Handlers
Inbound webhook handlers from a declared set of events, with signature verification, idempotency-key handling and dead-letter-queue stubs for you to wire up.
SaaS Platform Hints
Curated notes for Salesforce, HubSpot, Jira, Linear, Slack, Notion and Stripe cover the conventions that trip up a generic connector — Salesforce's pagination, Notion's version header, Linear's raw authorization header.
Pull-Request Delivery
Connect a GitHub App once and an ETL script, with its tests if you asked for them, arrives as a pull request in the repository you choose. Connectors and webhook handlers are delivered as downloads.
Privacy

Nothing is stored, by construction

Your schemas, samples and generated code are never written to a database, a bucket or a log. That is enforced in three independent places, not left to discipline.

A logger that cannot log content
The only logging path takes a closed list of fields — ids, format names, sizes, latency, cost. There is no free-text message to put content in, and anything else fails before a byte is written.
A build that fails on a leak
A check in continuous integration fails the build if any code logs outside that wrapper, so the guarantee does not erode as the codebase grows.
A second look at every result
After generation, a separate model call checks the output for content copied from your sample. It answers with one fixed label, never free text, and it fails closed.

The only durable record of a job is 21 metadata fields: identifiers, format names, sizes, latency, counts and pricing. Never your schema, your sample or your code.

Process

How the Integrator works

01
Drop in a source and a destination
A schema (XSD, JSON Schema, OpenAPI, PostgreSQL, SQL Server, MySQL, Oracle, Snowflake) or a sample (CSV, JSON, XML, YAML, MongoDB documents). An inferred schema is shown back to you to correct before anything is generated.
02
See the price first
A deterministic scorer sizes the pair — field count, nesting, type mismatches — with no model call. Small jobs run on the free plan; larger ones show their price up front and are charged exactly that.
03
Claude writes the code
An ETL script, optionally with tests, or a connector or webhook handler. Fields Claude cannot resolve are flagged, with its reasoning in a comment, rather than guessed silently.
04
Download it, or get a pull request
Review it, run its tests against your own data and merge it when it is ready. The code is yours from the first line.
Sample output
# Illustrative: a customer record, JSON in, JSON out
import json, sys

def convert(rec):
    out = {
        "customer_id": rec["cust_id"],
        "email": rec["email_addr"],
        # a bare date becomes a date-time
        "created_at": rec["signup_dt"] + "T00:00:00Z",
        # best effort: derived from is_active
        "status": "active" if rec.get("is_active") else "inactive",
    }
    addr = rec.get("address") or {}
    out["address"] = {"city": addr["city"],
        "postal_code": addr.get("postcode"),
        "country": addr["country"]}
    return out

data = json.load(sys.stdin)
json.dump([convert(r) for r in data], sys.stdout)
# UNRESOLVED_FIELDS: marketing_opt_in

A shortened, hand-written example of the shape every generated script follows. Real output covers every field of your pair.

What's included
✓
An ETL script, with an optional pytest suite, or a connector or webhook handler
✓
A price shown before you run it, and a refund if no script is produced
✓
An Iron Triangle score for every job: cost and time against what a developer would plausibly take
Good to know
·
It works from the descriptions you provide. It does not read your repository or call your APIs.
·
We do not run what we generate. Run it, and its tests, on your own sample data.
·
Python output only, today.

Ready to run your first integration?

Free for small jobs. Larger jobs are paid per job, with the price shown before you run them.

Try the Integrator ↗ Talk to us about a pilot