TABLE OF CONTENTS

• SchedEx Compliant API Connector
  • In a nutshell
  • When you need it
  • The problem it solves
  • The idea: speak one standard, reach them all
  • What can be exchanged
  • How it works — both directions
  • One connector, many systems
  • A real-world example
  • What it is — and what it isn't
  • The benefits
  • How to enable it

SchedEx Compliant API Connector

Bring your own custom planning system into SchedEx — so it can exchange schedule data, both ways, with Primavera P6, Safran, SAP and Microsoft Project.

Who this is for: planners, project-controls leads, and decision-makers who want to understand what the SchedEx Compliant API Connector is, when it's needed, and how it works. No technical knowledge is required.

In a nutshell

SchedEx already connects to the major scheduling systems — Primavera P6, Safran, SAP and Microsoft Project — out of the box.

But many organisations also run their own custom or in-house planning system, which SchedEx has no ready-made connector for. The Generic REST API Connector is the standard that lets such a custom system join SchedEx. Once your custom system is made "compliant," you can use SchedEx Data Exchange to send its schedule data to those supported systems — or pull their data back into your custom system — automatically, and in both directions.

You build that bridge once; after that, exchanging with any of the supported systems is just a matter of choosing who to exchange with.

When you need it

Use the Generic REST API Connector when:

• Your schedule data lives in a custom, in-house or otherwise unsupported planning system, and
• You want that system to exchange schedules with the systems SchedEx already supports (P6, Safran, SAP, Microsoft Project) or with other organizations on SchedEx.

It is not for moving data between the systems SchedEx already supports — for example P6 ↔︎ Safran, or SAP ↔︎ Microsoft Project. SchedEx handles those natively, with no compliant connector required. This article is specifically about connecting your own system into that capability.

The problem it solves

• Your custom planning system holds valuable schedule data, but it has no off-the-shelf SchedEx connector.
• Partners and stakeholders work in established tools (P6, Safran, SAP, Microsoft Project).
• Without a standard, sharing means manual exports, spreadsheets and re-keying — slow and error-prone.
• Building a separate, bespoke integration from your system to each of those tools would be costly to build and maintain.

The idea: speak one standard, reach them all

Rather than teaching your custom system to talk to P6, and Safran, and SAP, and Microsoft Project separately, you teach it to speak one standard — the Generic REST API contract. SchedEx then acts as the hub and translator between your system and the systems it already supports.

        Your custom planning system
                 ⇅        ← made "compliant" (Generic REST API Compliant)
          SchedEx        (hub / translator)
                 ⇅        ← SchedEx's built-in connectors
   Primavera P6 · Safran · SAP · Microsoft Project

Because everyone meets at the same standard, your system connects to all of them through one bridge.

What can be exchanged

The connector moves the meaningful parts of a schedule — in everyday terms:

• Projects / schedules — the overall plan, with its start, finish and progress.
• Activities — the individual tasks and milestones, their dates, durations and progress.
• Dependencies — which activities must happen before or after others.
• Resources — the people, equipment and materials, and when they're available.
• Resource assignments — who or what is working on each activity.
• Calendars — working days, working hours and holidays.
• Custom fields — any additional attributes your organisation tracks.

How it works — both directions

The exchange is two-way. The same connection lets data flow either way between your custom system and a supported system, through SchedEx:

Sending out (your custom system → a supported system) Your schedule is read from your custom system, carried through SchedEx, and delivered into the target tool — for example, your monthly program lands in a client's Primavera P6.

Bringing in (a supported system → your custom system) A schedule is read from the supported tool, carried through SchedEx, and written into your custom system — for example, an owner's approved baseline from P6 arrives in your in-house planner.

        Sending out                              Bringing in
   Your system ──► SchedEx ──► P6            P6 ──► SchedEx ──► Your system

Transfers are repeatable and governed — they can run on a schedule (e.g. weekly) rather than as one-off manual exports, so both sides stay in sync with far less effort.

One connector, many systems

This is the key advantage. You make your custom system compliant once, and from then on it can exchange with everything SchedEx connects to — Primavera P6, Safran, SAP, Microsoft Project — using the same bridge.

                                                                 ┌─ Primavera P6
   Your custom              ┌──────────┐   ├─ Safran
   planning system ──►│     SchedEx      │─┼─ SAP
                           ◄──│                       │  └─ Microsoft Project
                                   └──────────┘     (and back again)

No separate, per-tool integration to build and maintain.

A real-world example

An EPC contractor plans in their own in-house scheduling tool, which SchedEx doesn't support out of the box. Their client (the project owner) works in Primavera P6.

1. The contractor makes their in-house system compliant to the Generic REST API standard.
2. The two organizations set up an agreement in SchedEx defining what is shared and how often.
3. Each week, the contractor's updated program is delivered automatically into the owner's P6.
4. The owner's approved baseline flows back into the contractor's in-house system.

No manual exports, no spreadsheets, no re-keying — and if the owner later switches from P6 to Safran or SAP, the contractor changes nothing.

What it is — and what it isn't

It is:

• A way to connect a custom or unsupported planning system to SchedEx.
• A two-way, repeatable, automated exchange with the systems SchedEx already supports.
• A "build once, connect to many" approach.

It isn't:

• A replacement for your planning tool — you keep using what you have.
• A tool for moving data between systems SchedEx already supports (P6 ↔︎ Safran, etc.) — SchedEx does that natively.
• A one-off manual export, or a separate integration per tool.

The benefits

• Reach — your custom system can exchange with P6, Safran, SAP and Microsoft Project through one bridge.
• Less manual effort & fewer errors — automated, scheduled transfers instead of hand-offs.
• Keep your investment — your custom system stays; the connector sits in front of it.
• Flexibility — the other party can change tools without breaking your exchange.
• Reuse — one standard connection serves all current and future exchanges.

How to enable it

1. Make your system compliant — your development team implements the standard interface once (covered in the technical Implementation Guide).
2. Register the connector — an SchedEx administrator sets it up and tests the connection.
3. Start exchanging — set up an agreement and let scheduled transfers keep both sides in sync.

From that point on, exchanging schedules between your custom system and Primavera P6, Safran, SAP or Microsoft Project is simply a matter of choosing who to exchange with.