Production Certification¶
Certification is the lightweight review that moves your partner app from the beta (sandbox) environment to production. This page explains what's involved, what we look for, and how to prepare.
Environments at a Glance¶
| Beta (sandbox) | Production | |
|---|---|---|
| Base URL | https://beta.api.contio.ai | https://api.contio.ai |
| Access | Self-serve — email us or ask in your shared Slack channel | Requires certification (this page) |
| Credentials | Beta client ID/secret, API key, webhook secret | Separate production credentials |
| Availability | Best-effort — beta is intentionally small and carries no SLA | Covered by the production SLA |
| Purpose | Build and test your integration against real API behavior | Serve mutual users |
Each environment has its own partner app and its own credentials. Your beta app stays active after you go live — treat it as your permanent test environment for validating changes and adopting new API versions.
Why Certification Exists¶
The OAuth consent screen shows your app's name to our users, and production access means acting on their behalf. Certification is how we make sure that trust is well placed — for your users and ours.
It is deliberately lightweight:
- It is a working demo, a short verified checklist, and a written self-attestation about your QA and security practices.
- It is not a security audit, a penetration test, or a code review. We don't ask for test artifacts, source code, or certifications from third parties.
The Process¶
flowchart LR
A["1. Submit request<br/>(registration info +<br/>self-cert doc)"] --> B["2. Demo & review<br/>(~30 min call,<br/>verified checklist)"]
B --> C["3. Production<br/>credentials issued"] Step 1 — Submit Your Certification Request¶
Send the following to partner-support@contio.ai, or post it in the shared Slack channel if we set one up with you during development:
- The completed self-certification document — use the template below, or download it as Markdown. It covers your use cases, the API surface you use, and your QA, security, and operations posture. Section 6 of the template collects the registration details we need to provision your production app (production redirect URIs, webhook URL, contacts, and optional co-branding) — production values often differ from beta, so double-check them.
- A request for certification — a line saying you're ready to schedule the demo is fine.
Step 2 — Demo & Review¶
We read your document, then schedule a ~30 minute call where you walk us through your app's primary use cases live against the beta environment. During the demo we verify the checklist below — each item is pass/fail, and we'll tell you the result on the call.
If something doesn't pass, there's no penalty: fix it, and we re-demo just the failed items.
Step 3 — Production Credentials¶
Once the checklist passes, we provision your production partner app and issue a separate set of credentials (client ID/secret, API key, webhook secret). Swap your base URL to https://api.contio.ai and your beta credentials for the production ones — that's the whole migration.
The Demo Checklist¶
These are the only things we verify. Everything on this list exists because it has a direct impact on mutual users or on the platform.
| # | Requirement | What we look for |
|---|---|---|
| 1 | OAuth flow end-to-end | A user can connect their Contio account: correct state handling, successful code exchange, and a working token refresh |
| 2 | Scope minimality | Requested OAuth scopes match the use cases in your self-cert doc — nothing unused "just in case" |
| 3 | Webhook signature verification | Your endpoint accepts valid X-Contio-Signature payloads and rejects tampered ones |
| 4 | Revocation handling | A user.connection.revoked webhook disconnects the user cleanly |
| 5 | Error resilience | Sane behavior on API errors: backoff on 429, no retry storms, graceful handling of expired/invalid tokens |
| 6 | Production hygiene | HTTPS redirect URIs, secrets server-side only, and consent-screen branding that accurately identifies your app |
Prepare, don't memorize
The checklist is public on purpose. If your integration already handles these cases in beta, the demo is a formality — walk us through what you built.
The Self-Certification Template¶
Everything below is the template verbatim. Copy it into your own document tool, or download the Markdown file and fill it in directly — it's plain Markdown with [bracketed] placeholders and checkboxes, so it's equally easy for a person or an agent to complete.
Certification template (rendered)
Production Certification — [App Name]¶
How to use this template: replace every
[bracketed]placeholder, check each honest box by changing[ ]to[x](this document is an attestation), and delete the quoted guidance blocks before submitting. Send the completed document to partner-support@contio.ai or your shared Slack channel, together with a request for production certification.
Submitted by: [Name], [Title] — [Company Name] Contact: [primary-contact@company.com] Date: [YYYY-MM-DD] App version / release being certified: [e.g., v1.4.0, or "main @ abc123"]
1. App Overview¶
What does your app do, and what does the Contio integration add? This section sets the agenda for the certification demo — list the use cases you will walk through live.
[One-paragraph description of the application and its Contio integration.]
Primary use cases (these define the demo agenda):
- [e.g., A mutual user connects their Contio account and we import action items into Acme Tasks]
- [...]
- [...]
2. Integration Surface¶
Which parts of the Partner API does the app use?
OAuth scopes requested¶
| Scope | Why the app needs it |
|---|---|
[e.g., meetings:read] | [e.g., display upcoming meetings in the dashboard] |
Partner API endpoints used¶
[e.g., GET /v1/partner/user/meetings, POST /v1/partner/user/action-items]
Webhook events consumed¶
[e.g., action_item.created, meeting.completed — or "none"]
Admin API usage¶
[Does the app use the Admin API (automations, credential status, etc.)? Describe, or "none".]
3. Quality Assurance¶
How do you know the integration works, and how do you keep it working? Bullet points are fine.
- Automated testing: [e.g., unit + integration tests run in CI; the OAuth callback and webhook handlers are covered]
- Staging environment: [e.g., staging deployment points at beta.api.contio.ai for pre-release verification]
- OAuth flow coverage: [how the connect / callback / token refresh path is tested]
- Webhook coverage: [how signature verification and event handling are tested]
- Release process: [e.g., PR review + CI + staged rollout; hotfix path]
4. Security¶
Where do secrets and user data live? Be concrete — "secrets in AWS Secrets Manager, tokens encrypted at rest in Postgres" is the level of detail we need.
- Credential storage: [where the client secret, API key, and webhook secret are stored — e.g., a secrets manager, never in source or client bundles]
- User token storage: [how OAuth access/refresh tokens are stored at rest, and any encryption]
- Contio data handling: [what user data is stored, where, and for how long]
- Disconnect handling: [what happens to a user's data when they revoke the connection]
- Security/incident contact: [email or alias that reaches the team responsible]
5. Operations¶
- Support contact for mutual users: [email or URL]
- Monitoring: [how you detect webhook delivery failures, API error spikes, token expiry problems]
- Credential rotation: [how you would roll a rotated API key / client secret / webhook secret into production]
- API versioning: [how you track and adopt new Partner API versions — see the API Versioning guide]
6. Production App Registration¶
We use this to provision your production partner app. Production values may differ from beta — double-check redirect URIs and the webhook URL. The last column shows how each field is changed after go-live: self-serve via the Admin API, or Contio-managed via a request to the team.
| Field | Value | To change later |
|---|---|---|
| App name | [shown on the OAuth consent screen] | Self-serve: PATCH /v1/partner/admin/app |
| Description | [one line — what the app does] | Self-serve: PATCH /v1/partner/admin/app |
| Company name | Contact Contio | |
| Primary contact email | Contact Contio | |
| Support contact email | [optional] | Contact Contio |
| Redirect URI(s) | [production HTTPS URIs, one per line] | Contact Contio |
| Webhook URL | [production HTTPS endpoint, or "none"] | Self-serve: PATCH /v1/partner/admin/app |
| Co-brand name | [optional — display name for co-branded surfaces] | Contact Contio |
| Co-brand logo URL | [optional — HTTPS URL to a hosted logo] | Contact Contio |
| Preferred slug | [optional — lowercase, hyphenated, 3–63 chars] | Self-serve: PATCH /v1/partner/admin/app |
7. Attestation¶
- [ ] The information in this document is accurate as of the submission date.
- [ ] Each item on the published demo checklist works against the beta environment today.
- [ ] We will notify Contio before: requesting additional OAuth scopes, changing redirect URIs or co-branding, shipping a materially new use case, or adopting a new Partner API version.
Signed: [Name] — [Title] — [Date]
After Certification¶
Certification is one-time, and day-to-day app management is self-serve.
Manage your app yourself¶
These changes need no approval — apply them whenever you like with your API key:
| What | How |
|---|---|
| App name, description, slug | PATCH /v1/partner/admin/app |
| Webhook URL | PATCH /v1/partner/admin/app |
| Webhook delivery on/off and event filtering | PUT /v1/partner/admin/webhook-status · PUT|DELETE /v1/partner/admin/webhook-filter |
| Credential rotation (API key, client secret, webhook secret) | POST /v1/partner/admin/credentials/*/rotate — see Credential Management |
| IdP / SSO configuration | /v1/partner/admin/idp endpoints — see SSO Integration |
Changes we manage for you¶
A small set of fields is Contio-managed — reach out on your usual channel (email or shared Slack) to change them:
- Redirect URIs — they gate the OAuth callback. An unvetted URI is an open-redirect / code-interception risk, and a wrong one breaks the connect flow for every user.
- Company name and contact emails — used for support routing and our records.
- Co-branding (name + logo) — appears on Contio-facing consent surfaces.
- Workspace plan — set at provisioning time.
These should change rarely, which is the point of the split: fields where a misconfiguration could break mutual users or create a security issue go through us; everything operational stays in your hands.
Keep us in the loop¶
Beyond the managed fields above, tell us before you
- request additional OAuth scopes (they change what the consent screen promises users),
- ship a materially new use case, or
- adopt a new Partner API version.
FAQ¶
How long does certification take? The review of your document is asynchronous, and the demo is one ~30 minute call — the timeline is mostly scheduling. Submitting a complete template keeps it to one round-trip.
What if we fail a checklist item? We tell you what didn't pass and why. Fix it and we re-demo just that item — no full restart.
Does our beta app keep working after we go live? Yes, and we recommend keeping it that way. Use it to test changes and new API versions before they touch production users.
Do we re-certify when you release a new API version? No. Certification is one-time; adopting a new version just requires the heads-up described above.
Is there an automated conformance test suite? Not today. The checklist above is verified in the demo. We expect the process to mature as the program grows, and this page will always reflect the current requirements.
Next Steps¶
- Download the certification template
- Credential Management — rotating production credentials safely
- API Versioning — how Partner API versions and deprecations work
- Webhook Management — signature verification and delivery semantics