إنجازيو

إنجازيو

نجهّز لك تجربة تعليمية ذكية

Injazio — Tableau pédagogique interactif

Langue de l’interface

Connexion

Injazio Board — Integration Guide

Connect any LMS, website or school system to the Injazio whiteboard: single sign-on, roles, lessons and boards. No code inside your platform is required for most paths.

Updated October 2026

Where do your users sign in today?

Pick one. The guide marks the sections you need and hides nothing.

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 platformRecommended pathCode on your side
Any website, no developer availableA · Managed accounts (import + invite links)None
Users sign in with Google Workspace or Microsoft 365B · OpenID ConnectNone — a few settings
Keycloak, Auth0, Okta, Azure AD B2C, WordPress with an OIDC plugin, any OIDC serverB · OpenID ConnectNone — register one app
Moodle, Canvas, Blackboard, Brightspace, Schoology, SakaiC · LTI 1.3None — register one tool
Custom site with a session cookie and a /me endpointD · Session SSOUsually none
You want boards created from your own lesson pagesE · Partner REST APIOne server call
You want to sync people and lessons automaticallyF · Webhook / iCalNo-code (Zapier, Make, n8n)

2. Quick start (15 minutes)

  1. Subscribe to an academy plan on injazio.com. You get an admin account.
  2. Add one DNS record: board → CNAME → board.injazio.com (section 4). HTTPS is issued automatically.
  3. Open https://board.example.com/admin/academy and sign in as admin.
  4. Choose your sign-in path under Academy → Integrations (sections 5–9).
  5. Set your role rules if your platform sends roles (section 10).
  6. Add lessons, or let them sync from your LMS / calendar / webhook (sections 11–12).
  7. 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…):

DNS
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.com with 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.

ColumnAccepted headersNotes
name *name, full name, الاسمRequired
emailemail, e-mail, البريدEither email or username is required
usernameusername, login, اسم المستخدمLetters, digits, _ . -
rolerole, type, الدورadmin · teacher · student (also معلم / طالب / مدير). Default: student
passwordpassword, كلمة المرورEmpty → a readable 8-character password is generated and shown once
phonephone, mobile, الجوالOptional
external_idexternal_id, id, المعرفYour platform's ID — lets a later SSO login find the same account
CSV
name,email,role,external_id
Sara Ali,sara@example.com,teacher,1042
Omar Khaled,omar@example.com,student,2210

Invite 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:

URL
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 (add groups or roles if you use them in role rules)
Grant
Authorization Code with PKCE (S256)

Values to enter in Academy → Integrations → OIDC

FieldGoogleMicrosoft Entra IDOther (Keycloak, Auth0, Okta…)
Issuerhttps://accounts.google.comhttps://login.microsoftonline.com/{tenant-id}/v2.0 (or common)Your issuer URL, e.g. https://sso.example.com/realms/school
Client IDFrom Google Cloud → CredentialsApplication (client) IDFrom your provider
Client secretFrom Google CloudCertificates & secretsFrom your provider
ID claimsubsub (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_modeBehaviour
existing (default)Only people who already have an account in your academy (matched by verified email or by a previous OIDC login). Safest.
domainsAnyone 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.
anyAny 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, aud and 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 groups claim 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 InjazioMoodleCanvasBlackboard Learn
IssuerYour Moodle URL, e.g. https://lms.example.comhttps://canvas.instructure.comhttps://blackboard.com
Client IDShown in *Tool configuration details*Developer Key IDApplication ID
Auth login URL…/mod/lti/auth.phphttps://sso.canvaslms.com/api/lti/authorize_redirecthttps://developer.blackboard.com/api/v1/gateway/oidcauth
Keyset URL…/mod/lti/certs.phphttps://sso.canvaslms.com/api/lti/security/jwkshttps://developer.blackboard.com/api/v1/management/applications/{id}/jwks.json
Access token URL…/mod/lti/token.phphttps://sso.canvaslms.com/login/oauth2/tokenhttps://developer.blackboard.com/api/v1/gateway/oauth2/jwttoken
Deployment IDShown by Moodle (optional — remembered on first launch)From the app's *Deployment ID*From the deployment

Moodle, step by step

  1. Site administration → Plugins → Activity modules → External tool → Manage tools → *configure a tool manually*.
  2. Tool name: *Injazio Board*. Tool URL: the launch URL above. LTI version: LTI 1.3.
  3. Public key type: Keyset URL → the JWKS URL above. Initiate login URL and Redirection URI(s): as above.
  4. Default launch container: New window. Privacy: share name and email: *Always*. Save.
  5. Click the list icon of the tool → copy *Platform ID, Client ID, Deployment ID* and the three endpoint URLs into Injazio → Add platform.
  6. In a course: Add an activity → External tool → *Injazio Board*. Open it as a teacher once: the board is created.

Canvas, step by step

  1. Admin → Developer Keys → + Developer Key → LTI Key. Method: *Enter URL* is not needed — choose *Manual Entry*.
  2. Redirect URIs: launch URL. Target Link URI: launch URL. OpenID Connect Initiation URL: login URL. JWK Method: *Public JWK URL* → JWKS URL.
  3. Placements: *Course Navigation* and/or *Link Selection*. Privacy level: Public. Save and switch the key ON.
  4. Admin → Settings → Apps → + App → *By Client ID* → paste the key ID. Copy the Deployment ID.
  5. 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, TeachingAssistant and Administrator → 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_id verified, 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

  1. Your session token is stored in a cookie on the parent domain: Domain=.example.com; Secure; SameSite=Lax (HttpOnly is fine). localStorage cannot work.
  2. An endpoint that returns the current user for Authorization: Bearer <token>, e.g. GEThttps://example.com/api/me.
  3. It returns 200 with JSON for a valid token, and 401/403 for an expired, invalid or suspended one — never 200 with an empty body.
  4. It responds in under 6 seconds and includes a stable ID field (id or uuid).
JSON
{
  "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.

JSON
{
  "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" } ]
}
opMatches when
equalsthe value at path equals value (case-insensitive)
inthe value at path is one of the value list
containsthe array (or string) at path contains value
truthythe value at path is true / non-empty
existsthe key at path is present
  • path uses 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:

SourceHowKey
DashboardAdmin or teacher creates it; optional weekly repeat (up to 52 weeks)—
SpreadsheetAcademy → Lessons → Import (title, teacher, starts_at, ends_at, students)row
LTIEach LMS activityiss + deployment + resource link
Webhooklesson.upsert eventyour lesson id
iCal feedCalendar subscription URL, synced hourlyevent UID (+ date for recurrences)
Partner APIPOST/partner/boards/resolvecontext_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):

URL
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
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"]
      } }
    ]
  }'
EventFieldsEffect
person.upsertexternal_id or email (one required), name, roleCreates or updates the person. Manual roles stay locked.
person.removeexternal_id or emailSuspends the account (content is kept). The owner is protected.
lesson.upsertid*, 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), cancelledCreates or updates the lesson keyed by your id.
lesson.cancelidMarks the lesson cancelled.
JSON
{ "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.
  • ORGANIZER email → teacher (if that teacher exists), otherwise the default teacher you choose.
  • ATTENDEE emails that match academy accounts → students.
  • Daily and weekly RRULE recurrences are expanded; STATUS:CANCELLED cancels 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) and subscription: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

HTTP
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 }
}
JSON
{
  "success": true,
  "data": {
    "uuid": "c67G7zwALS7",
    "url": "https://board.example.com/waraqa/c67G7zwALS7",
    "title": "Lecture 3 — Applied Grammar",
    "created": true,
    "owner_id": 5120
  }
}
FieldRequiredMeaning
context_typeyeslesson · course · consultation · live_class · session · workshop · assignment
context_idyesYour integer ID for the lesson/booking
owner_external_idyesThe teacher's ID on your platform — the same ID your SSO returns
owner_name, owner_emailnoUsed when the teacher's account is first created
title, descriptionnoBoard title (default: *Lesson board #id*)
student_permissionnoview (default) or edit
teacher_permissionnoedit (default) or view
metanoAny 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 & pathBody / queryPurpose
GET/partner/boards?context_type=&context_id=Does this lesson have a board? data: null if not. Never creates.
POST/partner/boards/accesscontext_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/accesscontext_type, context_id, viewer_external_idRevoke that student's access
PATCH/partner/boards/access-policycontext_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.

MethodPathPurpose
GET/admin/overviewCounts, seats, domain and integration status
GETPOST/admin/peopleList (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-passwordGenerate a new password
POST/admin/people/importMultipart file, dry_run=1 to preview
GETPOSTDELETE/admin/invites[/{id}]Invite links
GETPOST/admin/domainDomain status · add a domain
POST/admin/domain/{id}/verify · /primaryVerify DNS · make primary
GET/admin/loginAll sign-in settings (secrets never returned)
PUTPOST/admin/login/roles · /roles/previewSave role rules · test them on a sample profile
PUTPOST/admin/login/sso · /sso/probeSession SSO settings · probe with a token
PUTPOST/admin/login/oidc · /oidc/testOIDC settings · test discovery
POSTPUTDELETE/admin/login/lti[/{id}]LTI platforms
POSTDELETE/admin/login/webhookRotate · disable the webhook
PUTPOST/admin/login/ical · /ical/syncCalendar feed · sync now
POSTDELETE/admin/login/api-keys[/{id}]Issue · revoke partner API keys
POST/admin/lessons/importImport lessons from a file
GETPOST/lessonsLessons (admins: all, teachers: own, students: theirs) · create
PATCHDELETE/lessons/{id}Update · cancel
POST/lessons/{id}/openOpen 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.

CodeHTTPMeaning / fix
invalid_or_unscoped_key401API key wrong, revoked or missing the scope
invalid_webhook_token401Webhook URL rotated or disabled
boards_limit_reached409Board quota for the period is used up; data has limit, usage and renewal date
active_boards_limit_reached409Too many boards exist at once; archive old ones
teachers_limit_reached422All teacher seats are taken
email_taken · username_taken422Another account in the academy uses it
owner_protected422The academy owner cannot be demoted, suspended or removed
invite_not_found · invite_revoked · invite_expired · invite_full404/422Invite link no longer usable
domain_taken · domains_limit · invalid_domain · platform_domain422Domain already in use, max 3, malformed, or an Injazio host
oidc_not_configured · discovery_failed422Finish OIDC settings / issuer unreachable
invalid_state · nonce_mismatch403Login expired (10 min) or was replayed — start again
issuer_mismatch · audience_mismatch403Issuer or client ID in Injazio differ from the token
email_domain_not_allowed · not_registered_in_academy403Blocked by allow_mode
account_suspended403The account is suspended in the academy
platform_not_registered · deployment_not_registered403Add the LMS (issuer + client ID) in Injazio; check the deployment ID
replayed_launch · unsupported_lti_version · unsupported_message_type403Only fresh LTI 1.3 resource-link launches are accepted
not_a_participant403The student is not in this lesson
unknown_event · id_and_title_required · external_id_or_email_required200 (per event)Fix the event payload
ical_fetch_failed · ical_invalid422Feed unreachable or not a valid calendar
429429Rate 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

0 / 8Saved in this browser

Need help? Contact us at injazio.com/contact or WhatsApp +20 155 544 9654 with your academy domain and the error code.

Contents
دليل ربط سبورة إنجازيو للمطوّرين — Integration Guide | Injazio