Connect your software to the whole port community, once
You build software for ports — a TOS add-on, OCR, reefer monitoring, a booking tool, an ERP connector. DMS gives you one open API and one marketplace to reach every terminal and actor on the platform, instead of a separate integration for each.
The core is open source: 16 of 17 bricks you can read, audit and build on — 824 modules across 147 applications already in production (measured 18/10/2026). No new monopoly owns the data your tool needs.
DMS plugs into the systems & standards your software already speaks
One documented API, plus EDI, EIR and FTP, sits alongside the ERP, TOS and data sources your integration already talks to.
What DMS brings to software vendors
Six ways your product plugs into the port community — one API, one marketplace, open code and consent-based data, all built on tools already running in production.
Public API
App Store & integrations
DMS PCS, open source
EDI hub & standards
Multi-terminal gateway
Data sharing with consent
Pick the bricks you need — each one works on its own and plugs into the next
One API into every terminal
Integrate once
Every terminal, one endpoint
Drop your software onto one API and reach the whole port community: container status, appointments, gate moves and documents, in and out, over open standards.
Publish your tool to the community
Package once
Terminals switch it on
Reach every terminal and actor from a single listing — publish your app and let the community turn it on.
Build on bricks already in production
16 of 17 bricks open
No lock-in
The Port Community System is open source: 824 modules across 147 applications already run in production — start from a brick, not from zero.
One integration across many systems
One gateway, many TOS
Scale without rework
Put one gateway in front of many terminal systems; your product stays simple while the community grows around it.
Trust built into every read
Per-field permissions
Signed & auditable
A container belongs to nobody until somebody books it — the owner decides what your tool may read, and every access is on the record.
The standards your software already speaks
A community platform is worth the messages it understands. Each standard is tied to a brick, so your tool connects to a message it already knows — no bespoke adapter per terminal.
Why software vendors plug in
Reach the whole community
No lock-in, ever
Lower cost to integrate
Start from a brick
Trust is built in
Grow with the network
Build sustainability reporting into your integration
Every vessel call, discharge and gate-out your tool reads is already a scope-3 data point. Connect once and your software can surface the CO₂ of real port moves — reporting figures from the data, not a spreadsheet guess.
The ecosystem your tool plugs into
Platform scale, live in production — not a pilot.
API into the whole community
Modules already in production
Applications on the platform
Bricks that are open source
The shape of the gain
Mechanics, not promises — the numbers come from how the platform works, not from any one customer.
API — one integration reaches every terminal and actor, instead of one project per port
marketplace — publish your app once and the whole community can switch it on
bricks open — you read the code, audit it and build on it, with no lock-in
data without consent — per-field permissions and signed reads, every time
Integrate per terminal, or once on the platform
The same tool, two ways to reach the port — one that grows with every terminal you add, one that grows your backlog.
Your software, reaching the port
Reach
How many terminals one integration touches
Code to maintain
Adapters your team keeps alive
Standards
Who writes the message parsers
Distribution
How your tool reaches terminals
Data access
How you read what you need
Source
What you can see and run
How a vendor plugs in
From your code to the whole port community — one connected flow, five steps, integrate once instead of once per port.
Build your tool
A TOS add-on, OCR, reefer monitoring, a booking tool or an ERP connector — whatever your product does for ports.
Request keys & a sandbox
Create your company and get API keys with a sandbox the same day — test against bricks that already run.
Connect or publish
Integrate over the open API, or package your tool as an app and publish it to the port App Store.
Terminal switches it on
A terminal enables your app from the store — no new project, no bespoke adapter on their side.
Scale across the community
One integration, live for every terminal and actor on the platform — add more as the network grows.
We built DMS so a software vendor plugs into the whole port city once: open code, an open API, and a marketplace every tool can publish to — and the data stays shared by consent, never captured.
Questions a vendor asks
No. You integrate once against the platform API and reach every connected terminal and actor. See the App Store.
Yes — 16 of the 17 bricks are open source. You read it, audit it, and run it yourself. All our open-source projects.
The data owner, always. Access is granted field by field and every read is signed and visible to them.
UN/EDIFACT, DCSA, EMSWe and ISO 6346, each tied to a brick. Your software plugs into messages it already speaks. The open-source PCS.
Yes. The same installer runs on-premises, behind your VPN, and a sandbox is available to test before go-live.
Publish it in the port App Store and terminals switch it on without a new project. App Store.
Tell us about your product
A few words about your tool and the data it needs to read or write, and we set up a call (Zoom, Teams or Meet) to map the right bricks and keys.
Other actors we serve
Terminals · Carriers · Port authorities · Shipping lines · Shippers · Forwarders · Depots