1. Overview
An academy on Injazio is your private copy of the platform. It runs on a sub-domain of your website (for example board.example.com), carries your name and logo, and has its own administrators, teachers, students, lessons and boards.
Your academy administrator manages everything from the dashboard on that sub-domain. Integration answers three questions only:
- Who is this person? — how users sign in (their existing account on your platform, Google, Microsoft, your LMS, or an Injazio account you create).
- What is their role? — academy admin, teacher or student, derived automatically from the data your platform already returns.
- Which lessons do they have? — so each lesson gets its own board, opened by its teacher and joined by its students.
| Your platform | Recommended path | Code on your side |
|---|---|---|
| Any website, no developer available | A · Managed accounts (import + invite links) | None |
| Users sign in with Google Workspace or Microsoft 365 | B · OpenID Connect | None — a few settings |
| Keycloak, Auth0, Okta, Azure AD B2C, WordPress with an OIDC plugin, any OIDC server | B · OpenID Connect | None — register one app |
| Moodle, Canvas, Blackboard, Brightspace, Schoology, Sakai | C · LTI 1.3 | None — register one tool |
Custom site with a session cookie and a /me endpoint | D · Session SSO | Usually none |
| You want boards created from your own lesson pages | E · Partner REST API | One server call |
| You want to sync people and lessons automatically | F · Webhook / iCal | No-code (Zapier, Make, n8n) |
2. Quick start (15 minutes)
- Subscribe to an academy plan on injazio.com. You get an admin account.
- Add one DNS record:
board→ CNAME →board.injazio.com(section 4). HTTPS is issued automatically. - Open
https://board.example.com/admin/academyand sign in as admin. - Choose your sign-in path under Academy → Integrations (sections 5–9).
- Set your role rules if your platform sends roles (section 10).
- Add lessons, or let them sync from your LMS / calendar / webhook (sections 11–12).
- Run the go-live checklist (section 16).
3. Core concepts
- Academy (tenant)
- Your isolated space. Data never crosses between academies.
- Academy domain
- Your sub-domain, e.g.
board.example.com. All sign-in URLs live on it. - Academy admin
- Manages people, lessons, domain and integrations. Never becomes an Injazio platform admin.
- Teacher
- Owns boards and has every teaching tool: drawing, curricula, games, quizzes, recording, certificates. Teachers consume teacher seats from your plan.
- Student
- Joins the boards they are invited to. Sees their lessons and boards under My lessons.
- External ID
- The stable identifier of a user on your platform (
sub,id,uuid…). It must never change for the life of the account. Email is not an identifier. - Lesson
- A scheduled session with a teacher and students. Its board is created lazily when the teacher first opens it, so unopened lessons cost no board quota.
Role precedence. A role set manually by the admin is locked and never overwritten by sync. Otherwise your role rules (section 10) decide; if no rule matches, a built-in mapping applies (admin → academy admin, teacher/instructor/trainer → teacher, anything else → student). The academy owner is always an admin.
Teacher seats. When your plan's teacher seats are full, manual promotions are refused with teachers_limit_reached; users arriving by SSO as teachers are admitted as students and shown a notice, until a seat frees up.
4. Step 1 — Connect your domain
In Academy → Domain, enter the sub-domain you want (e.g. board.example.com), then create this record at your DNS provider (Cloudflare, GoDaddy, Namecheap, Route 53…):
board.example.com. CNAME board.injazio.com.- If your provider does not allow CNAME on that name, use the A record shown in the dashboard.
- Cloudflare: set the record to DNS only (grey cloud) until the certificate is issued.
- Can't point the name yet? Prove ownership with a TXT record —
_injazio-verify.board.example.comwith the value shown in the dashboard — then switch the CNAME later. - Click Verify. The status moves
waiting_dns→ready. The HTTPS certificate is issued and renewed automatically. - Once the certificate is issued you may mark the domain Primary. Up to 3 domains per academy.
5. Path A — Managed accounts (no code)
The admin creates accounts in Academy → People: one by one, by importing a file, or by sharing an invite link. Ideal when your platform has no SSO, or to start today.
Import a spreadsheet
Upload .xlsx or .csv (UTF-8 or UTF-16, comma, semicolon or tab). Up to 5,000 rows. Headers are recognised in English or Arabic. Always run Preview first: it reports every row without writing anything.
| Column | Accepted headers | Notes |
|---|---|---|
| name * | name, full name, الاسم | Required |
| email, e-mail, البريد | Either email or username is required | |
| username | username, login, اسم المستخدم | Letters, digits, _ . - |
| role | role, type, الدور | admin · teacher · student (also معلم / طالب / مدير). Default: student |
| password | password, كلمة المرور | Empty → a readable 8-character password is generated and shown once |
| phone | phone, mobile, الجوال | Optional |
| external_id | external_id, id, المعرف | Your platform's ID — lets a later SSO login find the same account |
name,email,role,external_id
Sara Ali,sara@example.com,teacher,1042
Omar Khaled,omar@example.com,student,2210Invite links
Create a link for a role, with an optional label, expiry and maximum uses. Anyone who opens it creates their own account with that role:
https://board.example.com/join/inv_8fJ2kQ…(32 characters)- Links can be revoked at any time; used, expired and revoked links stop working immediately.
- Teacher invites respect teacher seats.
- Only a hash of the token is stored — copy the link when you create it.
6. Path B — OpenID Connect (Google, Microsoft, any OIDC provider)
A Sign in with … button appears on your academy's login page. The user authenticates at their identity provider; Injazio verifies the signed ID token and signs them in. Works with every standard OIDC provider.
Values to register at your provider
- Application type
- Web application (confidential client)
- Redirect URI
https://board.example.com/sso/oidc/callback- Scopes
openid email profile(addgroupsorrolesif you use them in role rules)- Grant
- Authorization Code with PKCE (S256)
Values to enter in Academy → Integrations → OIDC
| Field | Microsoft Entra ID | Other (Keycloak, Auth0, Okta…) | |
|---|---|---|---|
| Issuer | https://accounts.google.com | https://login.microsoftonline.com/{tenant-id}/v2.0 (or common) | Your issuer URL, e.g. https://sso.example.com/realms/school |
| Client ID | From Google Cloud → Credentials | Application (client) ID | From your provider |
| Client secret | From Google Cloud | Certificates & secrets | From your provider |
| ID claim | sub | sub (or oid) | sub unless you prefer another stable claim |
Click Test: Injazio fetches /.well-known/openid-configuration and confirms the provider is reachable.
Who may sign in
| allow_mode | Behaviour |
|---|---|
existing (default) | Only people who already have an account in your academy (matched by verified email or by a previous OIDC login). Safest. |
domains | Anyone with a verified email in the listed domains, e.g. school.edu, staff.school.edu. New users are created as students unless a role rule says otherwise. |
any | Any account at the provider. Use only with a private provider (your own Keycloak/Entra tenant). |
- Accounts are linked by verified email the first time, then by the provider's stable subject.
- Suspended accounts are refused (
account_suspended). - Secrets are encrypted at rest and never returned by the API.
- Security: state, nonce and PKCE on every login; signature verified against the provider's JWKS (RS*/ES* only);
iss,audand expiry checked.
Provider notes
- Google Workspace — Google Cloud Console → APIs & Services → Credentials → OAuth client ID → Web. Add the redirect URI. Set the consent screen to *Internal* to restrict to your organisation.
- Microsoft 365 / Entra ID — Entra admin center → App registrations → New → Web → redirect URI. Add a client secret. Use your tenant ID in the issuer to restrict to your organisation. Add the
groupsclaim under *Token configuration* if you map roles from groups. - Keycloak — Clients → Create → OpenID Connect, *Client authentication ON*, valid redirect URI as above. Add a *realm roles* mapper to the ID token to use roles.
- WordPress — install an OpenID Connect server plugin (e.g. *OpenID Connect Server* or *miniOrange OAuth Server*), register Injazio as a client with the redirect URI above.
- Auth0 / Okta / OneLogin / Cognito — create a *Regular Web Application* and copy issuer, client ID and secret.
7. Path C — LTI 1.3 (Moodle, Canvas, Blackboard, Brightspace…)
Add the Injazio Board as an external tool in your LMS. Teachers add it as an activity inside a course; clicking it signs the user in, assigns the right role and opens the board of that activity — the same board every time. Learners in the course join it automatically.
Tool values (copy them from Academy → Integrations → LTI)
- LTI version
- LTI 1.3
- Tool URL / Target link URI
https://board.example.com/lti/launch- Initiate login URL (OIDC login)
https://board.example.com/lti/login- Redirect URI(s)
https://board.example.com/lti/launch- Public keyset (JWKS) URL
https://api.injazio.com/api/lti/jwks- Public key
- Also shown as PEM in the dashboard, for LMSs that ask for a key instead of a URL
- Launch container
- New window (recommended — browsers restrict cookies inside iframes)
- Messages
LtiResourceLinkRequest- Privacy
- Share the user's name and email
Then register your LMS in Injazio
After saving the tool, your LMS shows its own values. Enter them under Add platform:
| Field in Injazio | Moodle | Canvas | Blackboard Learn |
|---|---|---|---|
| Issuer | Your Moodle URL, e.g. https://lms.example.com | https://canvas.instructure.com | https://blackboard.com |
| Client ID | Shown in *Tool configuration details* | Developer Key ID | Application ID |
| Auth login URL | …/mod/lti/auth.php | https://sso.canvaslms.com/api/lti/authorize_redirect | https://developer.blackboard.com/api/v1/gateway/oidcauth |
| Keyset URL | …/mod/lti/certs.php | https://sso.canvaslms.com/api/lti/security/jwks | https://developer.blackboard.com/api/v1/management/applications/{id}/jwks.json |
| Access token URL | …/mod/lti/token.php | https://sso.canvaslms.com/login/oauth2/token | https://developer.blackboard.com/api/v1/gateway/oauth2/jwttoken |
| Deployment ID | Shown by Moodle (optional — remembered on first launch) | From the app's *Deployment ID* | From the deployment |
Moodle, step by step
- Site administration → Plugins → Activity modules → External tool → Manage tools → *configure a tool manually*.
- Tool name: *Injazio Board*. Tool URL: the launch URL above. LTI version: LTI 1.3.
- Public key type: Keyset URL → the JWKS URL above. Initiate login URL and Redirection URI(s): as above.
- Default launch container: New window. Privacy: share name and email: *Always*. Save.
- Click the list icon of the tool → copy *Platform ID, Client ID, Deployment ID* and the three endpoint URLs into Injazio → Add platform.
- In a course: Add an activity → External tool → *Injazio Board*. Open it as a teacher once: the board is created.
Canvas, step by step
- Admin → Developer Keys → + Developer Key → LTI Key. Method: *Enter URL* is not needed — choose *Manual Entry*.
- Redirect URIs: launch URL. Target Link URI: launch URL. OpenID Connect Initiation URL: login URL. JWK Method: *Public JWK URL* → JWKS URL.
- Placements: *Course Navigation* and/or *Link Selection*. Privacy level: Public. Save and switch the key ON.
- Admin → Settings → Apps → + App → *By Client ID* → paste the key ID. Copy the Deployment ID.
- In Injazio → Add platform: issuer
https://canvas.instructure.com, client ID = developer key ID, plus the Canvas URLs in the table.
What happens on launch
- Roles:
Instructor,ContentDeveloper,Mentor,TeachingAssistantandAdministrator→ teacher; everything else → student (your role rules take priority). - Users are keyed by
iss + sub, so the same person in two courses is one account. - Each resource link (activity) maps to one lesson and one board. The first instructor becomes the owner; other instructors join as co-teachers.
- Learners who launch become participants. If the teacher has not opened the board yet, the student sees a *waiting* screen.
- Security: state + nonce (single use), signature checked against the platform keyset,
iss/aud/azp/deployment_idverified, replayed launches rejected.
8. Path D — Session SSO (your own website)
For custom websites. Because the board lives on a sub-domain of your site, the browser already sends your session cookie to it. Our server reads that cookie and asks your API who the user is. We never receive your signing key or user passwords.
Requirements
- Your session token is stored in a cookie on the parent domain:
Domain=.example.com; Secure; SameSite=Lax(HttpOnly is fine).localStoragecannot work. - An endpoint that returns the current user for
Authorization: Bearer <token>, e.g. GEThttps://example.com/api/me. - It returns
200with JSON for a valid token, and401/403for an expired, invalid or suspended one — never200with an empty body. - It responds in under 6 seconds and includes a stable ID field (
idoruuid).
{
"id": 2481,
"name": "Sara Ali",
"email": "sara@example.com",
"role": "trainer",
"capabilities": { "trainer": true, "admin": false }
}In Academy → Integrations → Session SSO, set the cookie name, the /me URL, the JSON paths for ID, name, email and role, and who may enter. Probe with a real token shows the parsed profile and the role it would get. If nothing is configured, nobody is admitted (fail-closed).
Logging out of your site removes the cookie; suspending a user makes /me fail — both take effect on their next navigation in the board. Full contract: docs/sso-partner-integration.md.
9. Role rules
Rules turn whatever your platform returns (an OIDC ID token, a /me response, LTI claims) into an academy role. They are evaluated in order admin → teacher → student; the first matching condition wins.
{
"admin": [ { "path": "groups", "op": "contains", "value": "academy-admins" } ],
"teacher": [ { "path": "role", "op": "in", "value": ["teacher", "trainer", "instructor"] },
{ "path": "capabilities.trainer", "op": "truthy" } ],
"student": [ { "path": "role", "op": "equals", "value": "learner" } ]
}| op | Matches when |
|---|---|
equals | the value at path equals value (case-insensitive) |
in | the value at path is one of the value list |
contains | the array (or string) at path contains value |
truthy | the value at path is true / non-empty |
exists | the key at path is present |
pathuses dots for nesting:user.profile.type,https://example.com/claims.roles. Up to 20 conditions per role.- Use Preview in the dashboard: paste a sample response and see which rule matches.
- A role set manually by the admin is locked and wins over rules. Unlock it to let sync decide again.
10. Lessons and boards
Every lesson has a teacher, optional schedule, students and a student permission (view or edit). Lessons come from any of these sources, and you can mix them:
| Source | How | Key |
|---|---|---|
| Dashboard | Admin or teacher creates it; optional weekly repeat (up to 52 weeks) | — |
| Spreadsheet | Academy → Lessons → Import (title, teacher, starts_at, ends_at, students) | row |
| LTI | Each LMS activity | iss + deployment + resource link |
| Webhook | lesson.upsert event | your lesson id |
| iCal feed | Calendar subscription URL, synced hourly | event UID (+ date for recurrences) |
| Partner API | POST/partner/boards/resolve | context_type + context_id |
- The board is created when the teacher first opens the lesson — never before. This protects your board quota.
- Students see their lessons in My lessons and enter with one click; until the teacher opens it they see *waiting for the teacher*.
- Inside the board the teacher has the full toolset: curricula, games, quizzes, homework, recording, certificates, participant control.
- Cancelling a lesson hides it from students; existing boards and their content are kept.
11. Path F — Automations: Webhook and iCal
Inbound webhook (Zapier, Make, n8n, Power Automate, your server)
In Academy → Integrations → Webhook, click Generate. You get a secret URL (shown once):
POST https://api.injazio.com/api/hooks/academy/injwh_{academy-id}_{40 characters}Or send the token in a header to POST/hooks/academy with X-Injazio-Webhook-Token. Body: one event {event, data} or a batch {events: [...]} of up to 100.
curl -X POST "https://api.injazio.com/api/hooks/academy/injwh_124_…" \
-H "Content-Type: application/json" \
-d '{
"events": [
{ "event": "person.upsert", "data": { "external_id": "1042", "name": "Sara Ali", "email": "sara@example.com", "role": "teacher" } },
{ "event": "person.upsert", "data": { "external_id": "2210", "name": "Omar Khaled", "email": "omar@example.com", "role": "student" } },
{ "event": "lesson.upsert", "data": {
"id": "L-5531", "title": "Algebra — Week 3",
"starts_at": "2026-11-02T16:00:00+03:00", "ends_at": "2026-11-02T17:00:00+03:00",
"teacher_external_id": "1042",
"students": ["2210", "lina@example.com"]
} }
]
}'| Event | Fields | Effect |
|---|---|---|
person.upsert | external_id or email (one required), name, role | Creates or updates the person. Manual roles stay locked. |
person.remove | external_id or email | Suspends the account (content is kept). The owner is protected. |
lesson.upsert | id*, title*, starts_at, ends_at, teacher_external_id or teacher_email, students (array of IDs / emails / {external_id|email}, or a comma-separated string), replace_students (default true), cancelled | Creates or updates the lesson keyed by your id. |
lesson.cancel | id | Marks the lesson cancelled. |
{ "success": true, "data": { "results": [
{ "event": "person.upsert", "ok": true, "user_id": 812 },
{ "event": "person.upsert", "ok": true, "user_id": 813, "created": true },
{ "event": "lesson.upsert", "ok": true, "lesson_id": 77, "students": 2, "teacher_found": true }
] } }- Each event reports its own
ok/reason, so one bad row never blocks the batch. Send people before the lessons that reference them. - Idempotent: replaying the same payload produces the same state.
- Rotate the URL at any time; the old one stops working immediately. Disable it to turn the webhook off.
- Zapier: trigger from your app (e.g. *New row in Google Sheets*) → action *Webhooks by Zapier → POST* → URL above, payload type JSON. Make: HTTP → *Make a request*, method POST, body type raw JSON.
Calendar feed (iCal / ICS)
Paste a calendar subscription URL (Google Calendar *secret address in iCal format*, Outlook *published calendar ICS*, or your LMS export). webcal:// is accepted. Injazio syncs every hour and on demand, covering 7 days back to 120 days ahead.
- Event
SUMMARY→ lesson title;DTSTART/DTEND(time-zones honoured) → schedule;UID→ identity. ORGANIZERemail → teacher (if that teacher exists), otherwise the default teacher you choose.ATTENDEEemails that match academy accounts → students.- Daily and weekly
RRULErecurrences are expanded;STATUS:CANCELLEDcancels the lesson.
12. Path E — Partner REST API
For platforms that keep their own lesson pages and want a “Open board” button. Your server calls one endpoint with your lesson ID and teacher ID; it returns the board URL — creating it the first time and returning the same board afterwards.
Authentication
- Base URL:
https://api.injazio.com/api - Header:
X-Api-Key: injk_{academy-id}_{48 characters}— issued in Academy → Integrations → API keys. - Scopes:
boards:write(create boards, manage access) andsubscription:read(read plan and usage). Use separate keys. - Server-side only. No CORS headers are sent; never put a key in browser code or in a
NEXT_PUBLIC_*variable. - Rate limits: 30/min for
resolve, 120/min for access grants, 60/min for everything else.
Create or open a board — POST /partner/boards/resolve
POST /api/partner/boards/resolve
Host: api.injazio.com
X-Api-Key: injk_124_…
Content-Type: application/json
{
"context_type": "lesson",
"context_id": 4821,
"owner_external_id": "77",
"owner_name": "Dr. Mohamed Ahmed",
"owner_email": "m@example.com",
"title": "Lecture 3 — Applied Grammar",
"student_permission": "view",
"teacher_permission": "edit",
"meta": { "course_id": 310 }
}{
"success": true,
"data": {
"uuid": "c67G7zwALS7",
"url": "https://board.example.com/waraqa/c67G7zwALS7",
"title": "Lecture 3 — Applied Grammar",
"created": true,
"owner_id": 5120
}
}| Field | Required | Meaning |
|---|---|---|
context_type | yes | lesson · course · consultation · live_class · session · workshop · assignment |
context_id | yes | Your integer ID for the lesson/booking |
owner_external_id | yes | The teacher's ID on your platform — the same ID your SSO returns |
owner_name, owner_email | no | Used when the teacher's account is first created |
title, description | no | Board title (default: *Lesson board #id*) |
student_permission | no | view (default) or edit |
teacher_permission | no | edit (default) or view |
meta | no | Any JSON you want stored with the board |
created: true means a board was just created and counted against your quota; false means it already existed. Call this from the Open board button, not when the lesson is saved.
Other endpoints
| Method & path | Body / query | Purpose |
|---|---|---|
GET/partner/boards | ?context_type=&context_id= | Does this lesson have a board? data: null if not. Never creates. |
POST/partner/boards/access | context_type, context_id, viewer_external_id, viewer_name?, viewer_email?, viewer_role?, permission? (view|edit) | Grant a student access to the board |
DELETE/partner/boards/access | context_type, context_id, viewer_external_id | Revoke that student's access |
PATCH/partner/boards/access-policy | context_type, context_id, participant_permission (view|edit) | Change permission for all participants at once |
GET/partner/subscription | — | Plan, limits and current usage (subscription:read key) |
Examples
// Laravel
$res = Http::timeout(10)
->withHeaders(['X-Api-Key' => config('services.injazio.board_key')])
->acceptJson()
->post('https://api.injazio.com/api/partner/boards/resolve', [
'context_type' => 'lesson',
'context_id' => $lesson->id,
'owner_external_id' => (string) $lesson->teacher_id,
'owner_name' => $lesson->teacher->name,
'title' => $lesson->title,
]);
if ($res->status() === 409) {
return back()->with('error', 'Board quota reached for this period.');
}
$lesson->update(['board_url' => $res->json('data.url')]);
return redirect()->away($res->json('data.url'));13. Admin REST API (automate the dashboard)
Everything in the academy dashboard is available as JSON. Authenticate as an academy admin (Authorization: Bearer <access_token>) and identify the academy with X-Tenant-Domain: board.example.com. Base: https://api.injazio.com/api/tenant.
| Method | Path | Purpose |
|---|---|---|
| GET | /admin/overview | Counts, seats, domain and integration status |
| GETPOST | /admin/people | List (filters: role, status, search, per_page) · create a person |
| PATCHDELETE | /admin/people/{id} | Update (name, email, role, status, role_locked) · remove |
| POST | /admin/people/{id}/reset-password | Generate a new password |
| POST | /admin/people/import | Multipart file, dry_run=1 to preview |
| GETPOSTDELETE | /admin/invites[/{id}] | Invite links |
| GETPOST | /admin/domain | Domain status · add a domain |
| POST | /admin/domain/{id}/verify · /primary | Verify DNS · make primary |
| GET | /admin/login | All sign-in settings (secrets never returned) |
| PUTPOST | /admin/login/roles · /roles/preview | Save role rules · test them on a sample profile |
| PUTPOST | /admin/login/sso · /sso/probe | Session SSO settings · probe with a token |
| PUTPOST | /admin/login/oidc · /oidc/test | OIDC settings · test discovery |
| POSTPUTDELETE | /admin/login/lti[/{id}] | LTI platforms |
| POSTDELETE | /admin/login/webhook | Rotate · disable the webhook |
| PUTPOST | /admin/login/ical · /ical/sync | Calendar feed · sync now |
| POSTDELETE | /admin/login/api-keys[/{id}] | Issue · revoke partner API keys |
| POST | /admin/lessons/import | Import lessons from a file |
| GETPOST | /lessons | Lessons (admins: all, teachers: own, students: theirs) · create |
| PATCHDELETE | /lessons/{id} | Update · cancel |
| POST | /lessons/{id}/open | Open the lesson's board → { url } or { waiting: true } |
14. Error reference
Errors are JSON: { "success": false, "message": "<code>" }. Validation errors (422) also include an errors object per field.
| Code | HTTP | Meaning / fix |
|---|---|---|
invalid_or_unscoped_key | 401 | API key wrong, revoked or missing the scope |
invalid_webhook_token | 401 | Webhook URL rotated or disabled |
boards_limit_reached | 409 | Board quota for the period is used up; data has limit, usage and renewal date |
active_boards_limit_reached | 409 | Too many boards exist at once; archive old ones |
teachers_limit_reached | 422 | All teacher seats are taken |
email_taken · username_taken | 422 | Another account in the academy uses it |
owner_protected | 422 | The academy owner cannot be demoted, suspended or removed |
invite_not_found · invite_revoked · invite_expired · invite_full | 404/422 | Invite link no longer usable |
domain_taken · domains_limit · invalid_domain · platform_domain | 422 | Domain already in use, max 3, malformed, or an Injazio host |
oidc_not_configured · discovery_failed | 422 | Finish OIDC settings / issuer unreachable |
invalid_state · nonce_mismatch | 403 | Login expired (10 min) or was replayed — start again |
issuer_mismatch · audience_mismatch | 403 | Issuer or client ID in Injazio differ from the token |
email_domain_not_allowed · not_registered_in_academy | 403 | Blocked by allow_mode |
account_suspended | 403 | The account is suspended in the academy |
platform_not_registered · deployment_not_registered | 403 | Add the LMS (issuer + client ID) in Injazio; check the deployment ID |
replayed_launch · unsupported_lti_version · unsupported_message_type | 403 | Only fresh LTI 1.3 resource-link launches are accepted |
not_a_participant | 403 | The student is not in this lesson |
unknown_event · id_and_title_required · external_id_or_email_required | 200 (per event) | Fix the event payload |
ical_fetch_failed · ical_invalid | 422 | Feed unreachable or not a valid calendar |
429 | 429 | Rate limit — back off and retry |
15. Security and privacy
- Isolation — every request is scoped to one academy by its domain; academy admins can never act on another academy or on the platform.
- No shared secrets you'd regret — we never ask for your JWT signing key, database access or user passwords. OIDC/LTI use public-key signatures.
- Fail-closed defaults — OIDC admits existing accounts only; Session SSO admits nobody until rules are set.
- Secrets at rest — OIDC client secrets are encrypted; API keys, webhook tokens and invite tokens are stored as SHA-256 hashes and shown once.
- Outbound requests — calls to your
/me, JWKS, discovery and iCal URLs are HTTPS-only and refuse private/internal addresses (SSRF protection). - Token hygiene — state, nonce and PKCE on every OIDC login; LTI nonces are single-use; session tokens are set as cookies by our server, never put in URLs.
- Revocation — rotate a webhook, revoke a key or an invite, suspend a person: effective immediately.
- Data — we store name, email, role and your external ID. Removing a person suspends them and keeps their boards; deletion requests: injazio.com/data-deletion.
16. Go-live checklist
Need help? Contact us at injazio.com/contact or WhatsApp +20 155 544 9654 with your academy domain and the error code.