You have an integration to build.

It starts as a script. A few calls. A quick win.

Then it spreads across teams. It becomes part of CI/CD. It powers dashboards. It gets depended on.

That's where most "Developer APIs" fall apart: not because they're missing endpoints, but because they don't hold up as a contract.

With CodeBots Platform 6.0.0, alongside the Marketplace, we shipped a new, contract-first surface: the V2 Developer API.

We're proud of it.

Not because it's flashy, but because it's disciplined: consistent conventions across resource families, version-aware workflows, and endpoints that map to how teams actually operate.

If you want to explore it directly, start here: CodeBots V2 API.

Why V2 exists

As CodeBots matured into a platform used across organisations, we needed an API that felt the same everywhere:

• Same patterns across bots, models, pipelines, repositories, and metamodels
• Predictable query parameters for scoping and search
• Versioning built into the surface, not bolted on later

The goal is simple: make integrations predictable. Repeatable. Easy to own.

What you can do today

The V2 surface is broad, and it's already practical.

Here are some of the capabilities that show up consistently across the API described in the CodeBots V2 API:

1. List and search core resources

Most top-level resources support:

• organisationId (optional) to scope results
• folderId (optional) to filter within a folder
• search (optional) to match by name or identifier

That pattern applies across bots, models, metamodels, pipelines, repositories, and related resources.

2. Organise everything with folders

You can:

• Fetch folder trees per resource type (for example, bot folders, pipeline folders, model folders)
• Move a resource into a folder
• Retrieve a resource's folder chain (useful for breadcrumbs and syncing external catalogues)

This matters more than it sounds. It turns "a list of things" into "a navigable system".

3. Work with versions (and dependencies)

Enterprise-grade automation needs version awareness.

In V2 you'll see dedicated endpoints for:

• Resource version lists (bots, models, metamodels, pipelines)
• Bot version dependency views
• Sharing bot versions (a key part of Marketplace-scale reuse)

4. Export structured formats for real workflows

V2 isn't just CRUD.

It supports exporting artefacts that matter in real engineering workflows:

• Models and pipelines can be exported as XMI
• Metamodels can be exported as EMFatic and Ecore
• Metamodel validation resources (for example, EVL) are first-class

That makes CodeBots easier to integrate into governance, review, and "source of truth" patterns.

5. Validate pipelines through the API

Pipelines are where automation becomes repeatable.

V2 includes pipeline validation endpoints (including version-specific validation), so you can validate changes as part of your normal workflow.

The next big improvement is the one everyone asks for: starting pipeline runs from the API.

That will make it possible to trigger pipelines directly from CI/CD and internal tooling, then track outcomes without needing to jump into the UI. Keep an eye on the CodeBots V2 API as the run endpoints land.

6. Automate Marketplace workflows

The Marketplace isn't just a UI concept.

V2 includes Marketplace endpoints for:

• Fetching Marketplace updates
• Browsing bots and versions
• Installing a bot into an organisation
• Creating/updating ratings

If you're building an internal platform, this is where self-serve starts to look real.

7. Make local pipeline execution easier

There are endpoints to generate Gradle files for running a pipeline locally (latest or version-specific).

That's a small feature with a big impact: it shortens the distance between "pipeline in the platform" and "pipeline in a local dev loop".

8. Manage repository integration safely

V2 includes endpoints for repository and repository credential management, including:

• Validating repository credentials
• Generating SSH key pairs for credentials
• Testing repository connectivity

This is the connective tissue between "automation" and "real artefacts that land in repos".

How it's designed (the part you feel)

The best developer experience is consistency.

Across resources you'll notice recurring shapes:

• Common query parameters (organisationId, folderId, search)
• Common sub-routes (/folders, /folder-chain, /versions)
• Version-aware endpoints where it matters (exporting, validating, dependency views)

This is what makes the surface enterprise-grade: not hype, but repeatable patterns that scale across teams.

Getting started

1. Open the CodeBots V2 API and pick one resource family (bots or pipelines are a good start).
2. Start read-only: list resources, scope with organisationId, and add search.
3. Then add one automation step: move a resource to a folder, validate a pipeline, or install a bot from the Marketplace.

Key takeaways

• The CodeBots V2 API is a contract-first surface built to scale across teams and organisations.
• It covers real workflows: versioning, validation, exports, Marketplace installation, and repository integration.
• The big win is consistency: shared conventions across every resource family.

If you're new to CodeBots, start with the platform itself: Sign up and follow the onboarding in the docs.