API Documentation

Generated at 2026-06-04T18:03:17+08:00 • base https://staging.learnest.my

Api

Endpoint
Controller
App\Http\Controllers\API\AccountController@show
Middleware
api auth:sanctum account.status.api
Auth
Required
Request
Path params
None
Query params
None
Body fields
None
Responses
Status
200 
{
    "example": {
        "status": "<boolean>",
        "data": "<object>"
    }
}
cURL Example
curl -X GET "{{BASE_URL}}/api/account-settings" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\AccountController@update
Middleware
api auth:sanctum account.status.api
Auth
Required
Request
Path params
None
Query params
email: string first_name: string last_name: string
Body fields
Field Type Required Rules
profile_image file No nullable|image|mimes:jpg,jpeg,png|max:2048
first_name string No nullable|string|max:255
last_name string No nullable|string|max:255
phone string No nullable|string|max:20
email email No nullable|email|max:255
address string No nullable|string|max:255
country string No nullable|string|max:255
dob date No nullable|date
bio string No nullable|string
Content type: multipart/form-data
Responses
Status
200 
{
    "example": {
        "status": "<boolean>",
        "message": "<string>",
        "data": "<object>"
    }
}
Status
422 
{
    "message": "The given data was invalid.",
    "errors": {
        "field": [
            "validation_rule_failed"
        ]
    }
}
cURL Example
curl -X POST "{{BASE_URL}}/api/account-settings" \
+  -H "Authorization: Bearer <API_TOKEN>" \
+  -F "profile_image=@/path/to/profile_image.bin" \
+  -F "first_name=<value>" \
+  -F "last_name=<value>" \
+  -F "phone=<value>" \
+  -F "email=<value>" \
+  -F "address=<value>" \
+  -F "country=<value>" \
+  -F "dob=<value>" \
+  -F "bio=<value>"

Endpoint
Controller
App\Http\Controllers\API\Admin\CaptionSettingsController@index
Middleware
api auth:sanctum account.status.api role.api:admin
Auth
Required
Request
Path params
None
Query params
None
Body fields
None
Responses
Status
200 
{
    "example": {
        "settings": "<object>"
    }
}
cURL Example
curl -X GET "{{BASE_URL}}/api/admin/captions/settings" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\Admin\CaptionSettingsController@update
Middleware
api auth:sanctum account.status.api role.api:admin
Auth
Required
Request
Path params
None
Query params
None
Body fields
None
Responses
Status
200 
{
    "example": {
        "ok": "<boolean>",
        "updated_keys": "<object>"
    }
}
cURL Example
curl -X PATCH "{{BASE_URL}}/api/admin/captions/settings" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\Backend\ChapterController@store
Middleware
api auth:sanctum account.status.api role.api:admin auth permission:create-chapter
Auth
Required
Request
Path params
None
Query params
None
Body fields
Field Type Required Rules
course_id string Yes required|exists:courses,id
title string Yes required|string|max:255
order integer Yes required|integer|min:1
Content type: application/json
Responses
Status
201 
{
    "example": {
        "status": "<boolean>",
        "message": "<string>",
        "data": "<object>"
    }
}
Status
500 
{
    "example": {
        "status": "<boolean>",
        "message": "<string>",
        "error": "<object>"
    }
}
Status
422 
{
    "message": "The given data was invalid.",
    "errors": {
        "field": [
            "validation_rule_failed"
        ]
    }
}
cURL Example
curl -X POST "{{BASE_URL}}/api/admin/chapters" \
  -H "Authorization: Bearer <API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"course_id":"<value>","title":"<value>","order":0}'

Endpoint
Controller
App\Http\Controllers\Backend\ChapterController@create
Middleware
api auth:sanctum account.status.api role.api:admin auth permission:create-chapter
Auth
Required
Request
Path params
courseId: string
Query params
None
Body fields
None
Responses
Status
404 
{
    "success": false,
    "message": "The requested resource was not found."
}
cURL Example
curl -X GET "{{BASE_URL}}/api/admin/chapters/course/{courseId}/create" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\Backend\ChapterController@reorder
Middleware
api auth:sanctum account.status.api role.api:admin auth permission:reorder-chapter
Auth
Required
Request
Path params
None
Query params
None
Body fields
Field Type Required Rules
items array Yes required|array
items[].id string Yes required|exists:chapters,id
items[].order integer Yes required|integer|min:1
Content type: application/json
Responses
Status
200 
{
    "example": {
        "status": "<boolean>",
        "message": "<string>"
    }
}
Status
422 
{
    "message": "The given data was invalid.",
    "errors": {
        "field": [
            "validation_rule_failed"
        ]
    }
}
cURL Example
curl -X POST "{{BASE_URL}}/api/admin/chapters/reorder" \
  -H "Authorization: Bearer <API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"items":[{"id":"<value>","order":0}]}'

Endpoint
Controller
App\Http\Controllers\Backend\ChapterController@deleteChapter
Middleware
api auth:sanctum account.status.api role.api:admin auth permission:delete-chapter
Auth
Required
Request
Path params
id: string
Query params
None
Body fields
None
Responses
Status
200 
{
    "example": {
        "status": "<boolean>",
        "message": "<string>"
    }
}
Status
500 
{
    "example": {
        "status": "<boolean>",
        "message": "<string>",
        "error": "<object>"
    }
}
Status
404 
{
    "success": false,
    "message": "The requested resource was not found."
}
cURL Example
curl -X DELETE "{{BASE_URL}}/api/admin/chapters/{id}" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\Backend\ChapterController@update
Middleware
api auth:sanctum account.status.api role.api:admin auth permission:edit-chapter
Auth
Required
Request
Path params
id: string
Query params
None
Body fields
Field Type Required Rules
title string Yes required|string|max:255
order integer Yes required|integer|min:1
Content type: application/json
Responses
Status
200 
{
    "example": {
        "status": "<boolean>",
        "message": "<string>",
        "data": "<object>"
    }
}
Status
422 
{
    "message": "The given data was invalid.",
    "errors": {
        "field": [
            "validation_rule_failed"
        ]
    }
}
Status
404 
{
    "success": false,
    "message": "The requested resource was not found."
}
cURL Example
curl -X PUT "{{BASE_URL}}/api/admin/chapters/{id}" \
  -H "Authorization: Bearer <API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"title":"<value>","order":0}'

Endpoint
Controller
App\Http\Controllers\Backend\CourseController@index
Middleware
api auth:sanctum account.status.api role.api:admin auth permission:create-course|edit-course|delete-course
Auth
Required
Request
Path params
None
Query params
search: string subject: string level: string status: string
Body fields
None
Responses
Status
200 
{
    "example": {
        "status": "<boolean>",
        "data": "<object>"
    }
}
cURL Example
curl -X GET "{{BASE_URL}}/api/admin/courses?search=%3Cvalue%3E&subject=%3Cvalue%3E&level=%3Cvalue%3E&status=%3Cvalue%3E" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\Backend\CourseController@store
Middleware
api auth:sanctum account.status.api role.api:admin auth permission:create-course
Auth
Required
Request
Path params
None
Query params
None
Body fields
Field Type Required Rules
title string Yes required|string|max:255
description string No nullable|string
subject_id string Yes required|exists:subjects,id
user_id string Yes required|exists:users,id
level_id string Yes required|exists:levels,id
thumbnail_url file No nullable|image|max:2048
Content type: multipart/form-data
Responses
Status
201 
{
    "example": {
        "status": "<boolean>",
        "message": "<string>",
        "data": "<object>"
    }
}
Status
500 
{
    "example": {
        "status": "<boolean>",
        "message": "<string>",
        "error": "<object>"
    }
}
Status
422 
{
    "message": "The given data was invalid.",
    "errors": {
        "field": [
            "validation_rule_failed"
        ]
    }
}
cURL Example
curl -X POST "{{BASE_URL}}/api/admin/courses" \
+  -H "Authorization: Bearer <API_TOKEN>" \
+  -F "title=<value>" \
+  -F "description=<value>" \
+  -F "subject_id=<value>" \
+  -F "user_id=<value>" \
+  -F "level_id=<value>" \
+  -F "thumbnail_url=@/path/to/thumbnail_url.bin"

Endpoint
Controller
App\Http\Controllers\Backend\CourseController@destroy
Middleware
api auth:sanctum account.status.api role.api:admin auth permission:delete-course
Auth
Required
Request
Path params
course: string
Query params
None
Body fields
None
Responses
Status
422 
{
    "example": {
        "status": "<boolean>",
        "message": "<string>"
    }
}
Status
200 
{
    "example": {
        "status": "<boolean>",
        "message": "<string>"
    }
}
cURL Example
curl -X DELETE "{{BASE_URL}}/api/admin/courses/{course}" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\Backend\CourseController@show
Middleware
api auth:sanctum account.status.api role.api:admin auth permission:create-course|edit-course|delete-course
Auth
Required
Request
Path params
course: string
Query params
None
Body fields
None
Responses
No explicit responses found in source code.
cURL Example
curl -X GET "{{BASE_URL}}/api/admin/courses/{course}" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\Backend\CourseController@update
Middleware
api auth:sanctum account.status.api role.api:admin auth permission:edit-course
Auth
Required
Request
Path params
course: string
Query params
None
Body fields
Field Type Required Rules
title string Yes required|string|max:255
user_id string Yes required|exists:users,id
description string No nullable|string
subject_id string Yes required|exists:subjects,id
level_id string Yes required|exists:levels,id
thumbnail_url file No nullable|image|max:2048
Content type: multipart/form-data
Responses
Status
200 
{
    "example": {
        "status": "<boolean>",
        "message": "<string>",
        "data": "<object>"
    }
}
Status
500 
{
    "example": {
        "status": "<boolean>",
        "message": "<string>",
        "error": "<object>"
    }
}
Status
422 
{
    "message": "The given data was invalid.",
    "errors": {
        "field": [
            "validation_rule_failed"
        ]
    }
}
cURL Example
curl -X PUT "{{BASE_URL}}/api/admin/courses/{course}" \
+  -H "Authorization: Bearer <API_TOKEN>" \
+  -F "title=<value>" \
+  -F "user_id=<value>" \
+  -F "description=<value>" \
+  -F "subject_id=<value>" \
+  -F "level_id=<value>" \
+  -F "thumbnail_url=@/path/to/thumbnail_url.bin"

Endpoint
Controller
App\Http\Controllers\Backend\CourseController@publish
Middleware
api auth:sanctum account.status.api role.api:admin auth
Auth
Required
Request
Path params
course: string
Query params
None
Body fields
None
Responses
Status
422 
{
    "example": {
        "status": "<boolean>",
        "message": "<string>"
    }
}
Status
200 
{
    "example": {
        "status": "<boolean>",
        "message": "<string>"
    }
}
cURL Example
curl -X POST "{{BASE_URL}}/api/admin/courses/{course}/publish" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\Backend\CourseController@unpublish
Middleware
api auth:sanctum account.status.api role.api:admin auth
Auth
Required
Request
Path params
course: string
Query params
None
Body fields
None
Responses
Status
422 
{
    "example": {
        "status": "<boolean>",
        "message": "<string>"
    }
}
Status
200 
{
    "example": {
        "status": "<boolean>",
        "message": "<string>"
    }
}
cURL Example
curl -X POST "{{BASE_URL}}/api/admin/courses/{course}/unpublish" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\DeviceController@fcmAccessToken
Middleware
api auth:sanctum account.status.api role.api:admin throttle:10,1
Auth
Required
Request
Path params
None
Query params
None
Body fields
None
Responses
Status
500 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>",
        "error": "<object>"
    }
}
Status
200 
{
    "example": {
        "success": "<boolean>",
        "data": "<array>",
        "usage_example": "<string>"
    }
}
cURL Example
curl -X GET "{{BASE_URL}}/api/admin/firebase/access-token" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\Backend\LessonController@store
Middleware
api auth:sanctum account.status.api role.api:admin auth permission:create-lesson
Auth
Required
Request
Path params
None
Query params
None
Body fields
Field Type Required Rules
chapter_id string Yes required|exists:chapters,id
title string Yes required|string|max:255
description string No nullable|string
video file Yes required_without:video_key|nullable|file|mimes:mp4,mov,avi|max:2048000
video_key string Yes required_without:video|nullable|string|regex:/^lessons\/videos\//
video_duration integer No nullable|integer
resource file No nullable|file|mimes:pdf|max:10240
resource_key string No nullable|string|regex:/^lessons\/resources\//
Content type: multipart/form-data
Responses
Status
201 
{
    "status": true,
    "message": "string",
    "data": "object"
}
Status
500 
{
    "status": false,
    "message": "string"
}
Status
422 
{
    "message": "The given data was invalid.",
    "errors": {
        "field": [
            "validation_rule_failed"
        ]
    }
}
cURL Example
curl -X POST "{{BASE_URL}}/api/admin/lessons" \
+  -H "Authorization: Bearer <API_TOKEN>" \
+  -F "chapter_id=<value>" \
+  -F "title=<value>" \
+  -F "description=<value>" \
+  -F "video=@/path/to/video.bin" \
+  -F "video_key=<value>" \
+  -F "video_duration=<value>" \
+  -F "resource=@/path/to/resource.bin" \
+  -F "resource_key=<value>"

Endpoint
Controller
App\Http\Controllers\Backend\LessonController@destroy
Middleware
api auth:sanctum account.status.api role.api:admin auth permission:delete-lesson
Auth
Required
Request
Path params
id: string
Query params
None
Body fields
None
Responses
Status
200 
{
    "status": true,
    "message": "string",
    "data": "object"
}
Status
500 
{
    "status": false,
    "message": "string"
}
Status
404 
{
    "success": false,
    "message": "The requested resource was not found."
}
cURL Example
curl -X DELETE "{{BASE_URL}}/api/admin/lessons/{id}" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\Backend\LessonController@update
Middleware
api auth:sanctum account.status.api role.api:admin auth permission:edit-lesson
Auth
Required
Request
Path params
id: string
Query params
None
Body fields
Field Type Required Rules
chapter_id string Yes required|exists:chapters,id
title string Yes required|string|max:255
description string No nullable|string
video file No nullable|file|mimes:mp4,mov,avi|max:2048000
video_key string No nullable|string|regex:/^lessons\/videos\//
resource file No nullable|file|mimes:pdf|max:10240
resource_key string No nullable|string|regex:/^lessons\/resources\//
Content type: multipart/form-data
Responses
Status
200 
{
    "status": true,
    "message": "string",
    "data": "object"
}
Status
500 
{
    "status": false,
    "message": "string"
}
Status
422 
{
    "message": "The given data was invalid.",
    "errors": {
        "field": [
            "validation_rule_failed"
        ]
    }
}
Status
404 
{
    "success": false,
    "message": "The requested resource was not found."
}
cURL Example
curl -X PUT "{{BASE_URL}}/api/admin/lessons/{id}" \
+  -H "Authorization: Bearer <API_TOKEN>" \
+  -F "chapter_id=<value>" \
+  -F "title=<value>" \
+  -F "description=<value>" \
+  -F "video=@/path/to/video.bin" \
+  -F "video_key=<value>" \
+  -F "resource=@/path/to/resource.bin" \
+  -F "resource_key=<value>"

Endpoint
Controller
App\Http\Controllers\Backend\LessonController@publishLesson
Middleware
api auth:sanctum account.status.api role.api:admin auth
Auth
Required
Request
Path params
id: string
Query params
None
Body fields
None
Responses
Status
200 
{
    "status": true,
    "message": "string",
    "data": "object"
}
cURL Example
curl -X POST "{{BASE_URL}}/api/admin/lessons/{id}/publish" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\Backend\LessonController@requestForUpdate
Middleware
api auth:sanctum account.status.api role.api:admin auth
Auth
Required
Request
Path params
id: string
Query params
None
Body fields
None
Responses
Status
200 
{
    "status": true,
    "message": "string",
    "data": "object"
}
Status
500 
{
    "status": false,
    "message": "string"
}
Status
404 
{
    "success": false,
    "message": "The requested resource was not found."
}
cURL Example
curl -X POST "{{BASE_URL}}/api/admin/lessons/{id}/request-update" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\Admin\TopicController@index
Middleware
api auth:sanctum account.status.api role.api:admin
Auth
Required
Request
Path params
None
Query params
subject_id: string status: string
Body fields
None
Responses
Status
200 
{
    "example": {
        "data": "<object>"
    }
}
cURL Example
curl -X GET "{{BASE_URL}}/api/admin/topics?subject_id=%3Cvalue%3E&status=%3Cvalue%3E" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\Admin\TopicController@store
Middleware
api auth:sanctum account.status.api role.api:admin
Auth
Required
Request
Path params
None
Query params
None
Body fields
Field Type Required Rules
name string Yes required|string|max:120
parent_id integer No nullable|integer|Rule::exists('topics|id')
subject_id integer No nullable|integer|Rule::exists('subjects|id')
sort_order integer No nullable|integer|min:0
Content type: application/json
Responses
Status
422 
{
    "example": {
        "message": "<string>",
        "errors": "<array>"
    }
}
Status
201 
{
    "example": {
        "data": "<object>"
    }
}
cURL Example
curl -X POST "{{BASE_URL}}/api/admin/topics" \
  -H "Authorization: Bearer <API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"name":"<value>","parent_id":0,"subject_id":0,"sort_order":0}'

Endpoint
Controller
App\Http\Controllers\API\Admin\TopicController@destroy
Middleware
api auth:sanctum account.status.api role.api:admin
Auth
Required
Request
Path params
id: string
Query params
None
Body fields
None
Responses
Status
409 
{
    "example": {
        "message": "<string>",
        "in_use_by": "<array>"
    }
}
Status
200 
{
    "example": {
        "data": "<array>"
    }
}
Status
404 
{
    "success": false,
    "message": "The requested resource was not found."
}
cURL Example
curl -X DELETE "{{BASE_URL}}/api/admin/topics/{id}" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\Admin\TopicController@update
Middleware
api auth:sanctum account.status.api role.api:admin
Auth
Required
Request
Path params
id: string
Query params
None
Body fields
Field Type Required Rules
name string No sometimes|string|max:120
parent_id integer No sometimes|nullable|integer|Rule::exists('topics|id')
status string No sometimes|Rule::in([Topic::STATUS_APPROVED|Topic::STATUS_PROPOSED|Topic::STATUS_REJECTED
sort_order integer No sometimes|integer|min:0
Content type: application/json
Responses
Status
200 
{
    "example": {
        "data": "<object>"
    }
}
Status
422 
{
    "success": false,
    "message": "Move would exceed MAX_DEPTH (D2)"
}
Status
404 
{
    "success": false,
    "message": "The requested resource was not found."
}
cURL Example
curl -X PATCH "{{BASE_URL}}/api/admin/topics/{id}" \
  -H "Authorization: Bearer <API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"name":"<value>","parent_id":0,"status":"<value>","sort_order":0}'

Endpoint
Controller
App\Http\Controllers\Backend\TutorVerificationController@index
Middleware
api auth:sanctum account.status.api role.api:admin
Auth
Required
Request
Path params
None
Query params
status: string search: string
Body fields
None
Responses
Status
200 
{
    "example": {
        "success": "<boolean>",
        "data": "<object>"
    }
}
cURL Example
curl -X GET "{{BASE_URL}}/api/admin/tutor-verifications?status=%3Cvalue%3E&search=%3Cvalue%3E" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\Backend\TutorVerificationController@destroy
Middleware
api auth:sanctum account.status.api role.api:admin
Auth
Required
Request
Path params
id: string
Query params
None
Body fields
None
Responses
Status
200 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>"
    }
}
Status
404 
{
    "success": false,
    "message": "The requested resource was not found."
}
cURL Example
curl -X DELETE "{{BASE_URL}}/api/admin/tutor-verifications/{id}" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\Backend\TutorVerificationController@show
Middleware
api auth:sanctum account.status.api role.api:admin
Auth
Required
Request
Path params
id: string
Query params
None
Body fields
None
Responses
Status
200 
{
    "example": {
        "success": "<boolean>",
        "data": "<object>"
    }
}
Status
404 
{
    "success": false,
    "message": "The requested resource was not found."
}
cURL Example
curl -X GET "{{BASE_URL}}/api/admin/tutor-verifications/{id}" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\Backend\TutorVerificationController@approve
Middleware
api auth:sanctum account.status.api role.api:admin
Auth
Required
Request
Path params
id: string
Query params
None
Body fields
None
Responses
Status
400 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>"
    }
}
Status
200 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>",
        "data": "<object>"
    }
}
Status
404 
{
    "success": false,
    "message": "The requested resource was not found."
}
cURL Example
curl -X POST "{{BASE_URL}}/api/admin/tutor-verifications/{id}/approve" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\Backend\TutorVerificationController@reject
Middleware
api auth:sanctum account.status.api role.api:admin
Auth
Required
Request
Path params
id: string
Query params
None
Body fields
Field Type Required Rules
rejection_reason string Yes required|string|max:1000
Content type: application/json
Responses
Status
400 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>"
    }
}
Status
200 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>",
        "data": "<object>"
    }
}
Status
422 
{
    "message": "The given data was invalid.",
    "errors": {
        "field": [
            "validation_rule_failed"
        ]
    }
}
Status
404 
{
    "success": false,
    "message": "The requested resource was not found."
}
cURL Example
curl -X POST "{{BASE_URL}}/api/admin/tutor-verifications/{id}/reject" \
  -H "Authorization: Bearer <API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"rejection_reason":"<value>"}'

Endpoint
Controller
App\Http\Controllers\Backend\TutorVerificationController@requestResubmit
Middleware
api auth:sanctum account.status.api role.api:admin
Auth
Required
Request
Path params
id: string
Query params
None
Body fields
Field Type Required Rules
rejection_reason string Yes required|string|max:1000
Content type: application/json
Responses
Status
200 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>",
        "data": "<object>"
    }
}
Status
422 
{
    "message": "The given data was invalid.",
    "errors": {
        "field": [
            "validation_rule_failed"
        ]
    }
}
Status
404 
{
    "success": false,
    "message": "The requested resource was not found."
}
cURL Example
curl -X POST "{{BASE_URL}}/api/admin/tutor-verifications/{id}/resubmit" \
  -H "Authorization: Bearer <API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"rejection_reason":"<value>"}'

Endpoint
Controller
App\Http\Controllers\Backend\TutorVerificationController@index
Middleware
api auth:sanctum account.status.api role.api:admin
Auth
Required
Request
Path params
None
Query params
status: string search: string
Body fields
None
Responses
Status
200 
{
    "example": {
        "success": "<boolean>",
        "data": "<object>"
    }
}
cURL Example
curl -X GET "{{BASE_URL}}/api/admin/verifications?status=%3Cvalue%3E&search=%3Cvalue%3E" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\Backend\TutorVerificationController@destroy
Middleware
api auth:sanctum account.status.api role.api:admin
Auth
Required
Request
Path params
id: string
Query params
None
Body fields
None
Responses
Status
200 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>"
    }
}
Status
404 
{
    "success": false,
    "message": "The requested resource was not found."
}
cURL Example
curl -X DELETE "{{BASE_URL}}/api/admin/verifications/{id}" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\Backend\TutorVerificationController@show
Middleware
api auth:sanctum account.status.api role.api:admin
Auth
Required
Request
Path params
id: string
Query params
None
Body fields
None
Responses
Status
200 
{
    "example": {
        "success": "<boolean>",
        "data": "<object>"
    }
}
Status
404 
{
    "success": false,
    "message": "The requested resource was not found."
}
cURL Example
curl -X GET "{{BASE_URL}}/api/admin/verifications/{id}" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\Backend\TutorVerificationController@approve
Middleware
api auth:sanctum account.status.api role.api:admin
Auth
Required
Request
Path params
id: string
Query params
None
Body fields
None
Responses
Status
400 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>"
    }
}
Status
200 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>",
        "data": "<object>"
    }
}
Status
404 
{
    "success": false,
    "message": "The requested resource was not found."
}
cURL Example
curl -X POST "{{BASE_URL}}/api/admin/verifications/{id}/approve" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\Backend\TutorVerificationController@reject
Middleware
api auth:sanctum account.status.api role.api:admin
Auth
Required
Request
Path params
id: string
Query params
None
Body fields
Field Type Required Rules
rejection_reason string Yes required|string|max:1000
Content type: application/json
Responses
Status
400 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>"
    }
}
Status
200 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>",
        "data": "<object>"
    }
}
Status
422 
{
    "message": "The given data was invalid.",
    "errors": {
        "field": [
            "validation_rule_failed"
        ]
    }
}
Status
404 
{
    "success": false,
    "message": "The requested resource was not found."
}
cURL Example
curl -X POST "{{BASE_URL}}/api/admin/verifications/{id}/reject" \
  -H "Authorization: Bearer <API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"rejection_reason":"<value>"}'

Endpoint
Controller
App\Http\Controllers\Backend\TutorVerificationController@requestResubmit
Middleware
api auth:sanctum account.status.api role.api:admin
Auth
Required
Request
Path params
id: string
Query params
None
Body fields
Field Type Required Rules
rejection_reason string Yes required|string|max:1000
Content type: application/json
Responses
Status
200 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>",
        "data": "<object>"
    }
}
Status
422 
{
    "message": "The given data was invalid.",
    "errors": {
        "field": [
            "validation_rule_failed"
        ]
    }
}
Status
404 
{
    "success": false,
    "message": "The requested resource was not found."
}
cURL Example
curl -X POST "{{BASE_URL}}/api/admin/verifications/{id}/resubmit" \
  -H "Authorization: Bearer <API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"rejection_reason":"<value>"}'

Endpoint
Controller
App\Http\Controllers\API\Admin\XpSettingsController@index
Middleware
api auth:sanctum account.status.api role.api:admin
Auth
Required
Request
Path params
None
Query params
None
Body fields
None
Responses
Status
200 
{
    "example": {
        "settings": "<object>"
    }
}
cURL Example
curl -X GET "{{BASE_URL}}/api/admin/xp/settings" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\Admin\XpSettingsController@update
Middleware
api auth:sanctum account.status.api role.api:admin
Auth
Required
Request
Path params
None
Query params
None
Body fields
None
Responses
Status
200 
{
    "example": {
        "ok": "<boolean>",
        "updated_keys": "<object>"
    }
}
cURL Example
curl -X PATCH "{{BASE_URL}}/api/admin/xp/settings" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\Backend\BBBWebhookController@handle
Middleware
api
Auth
Not required
Request
Path params
None
Query params
None
Body fields
None
Responses
Status
400 
{
    "example": {
        "message": "<string>"
    }
}
Status
200 
{
    "example": {
        "status": "<string>"
    }
}
cURL Example
curl -X POST "{{BASE_URL}}/api/bbb/webhook"

Endpoint
Controller
App\Http\Controllers\API\AccountController@changePassword
Middleware
api auth:sanctum account.status.api
Auth
Required
Request
Path params
None
Query params
None
Body fields
Field Type Required Rules
old_password string Yes required
new_password string Yes required|string|confirmed|Password::min(8)->mixedCase()->numbers()->symbols()
Content type: application/json
Responses
Status
422 
{
    "example": {
        "status": "<boolean>",
        "message": "<string>"
    }
}
Status
200 
{
    "example": {
        "status": "<boolean>",
        "message": "<string>"
    }
}
cURL Example
curl -X POST "{{BASE_URL}}/api/change-password" \
  -H "Authorization: Bearer <API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"old_password":"<value>","new_password":"<value>"}'

Endpoint
Controller
App\Http\Controllers\API\ClientLogController@store
Middleware
api throttle:client-log
Auth
Not required
Request
Path params
None
Query params
None
Body fields
None
Responses
Status
201 
{
    "example": {
        "logged": "<boolean>"
    }
}
cURL Example
curl -X POST "{{BASE_URL}}/api/client-log"

Endpoint
Controller
Closure
Middleware
api
Auth
Not required
Request
Path params
None
Query params
None
Body fields
None
Responses
No explicit responses found in source code.
cURL Example
curl -X GET "{{BASE_URL}}/api/config/quiz-defaults"

Endpoint
Controller
App\Http\Controllers\API\ConfigController@whatsappTemplates
Middleware
api
Auth
Not required
Request
Path params
None
Query params
None
Body fields
None
Responses
No explicit responses found in source code.
cURL Example
curl -X GET "{{BASE_URL}}/api/config/whatsapp-templates"

Endpoint
Controller
App\Http\Controllers\API\APIController@getCoursesWithChapters
Middleware
api auth:sanctum account.status.api
Auth
Required
Request
Path params
None
Query params
None
Body fields
None
Responses
Status
200 
{
    "example": {
        "status": "<boolean>",
        "message": "<string>"
    }
}
cURL Example
curl -X GET "{{BASE_URL}}/api/courses-with-chapters" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
Closure
Middleware
api
Auth
Not required
Request
Path params
course: string
Query params
None
Body fields
None
Responses
No explicit responses found in source code.
cURL Example
curl -X GET "{{BASE_URL}}/api/courses/{course}/chapters"

Endpoint
Controller
App\Http\Controllers\API\CurlecWebhookController@handle
Middleware
api
Auth
Not required
Request
Path params
None
Query params
None
Body fields
None
Responses
No explicit responses found in source code.
cURL Example
curl -X POST "{{BASE_URL}}/api/curlec/webhook"

Endpoint
Controller
App\Http\Controllers\API\DeviceController@showPreferences
Middleware
api auth:sanctum account.status.api
Auth
Required
Request
Path params
None
Query params
None
Body fields
None
Responses
Status
200 
{
    "example": {
        "success": "<boolean>",
        "data": "<array>"
    }
}
cURL Example
curl -X GET "{{BASE_URL}}/api/devices/preferences" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\DeviceController@updatePreferences
Middleware
api auth:sanctum account.status.api
Auth
Required
Request
Path params
None
Query params
None
Body fields
Field Type Required Rules
push_enabled boolean No sometimes|boolean
categories array No sometimes|array
Content type: application/json
Responses
Status
200 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>",
        "data": "<array>"
    }
}
Status
422 
{
    "message": "The given data was invalid.",
    "errors": {
        "field": [
            "validation_rule_failed"
        ]
    }
}
cURL Example
curl -X POST "{{BASE_URL}}/api/devices/preferences" \
  -H "Authorization: Bearer <API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"push_enabled":true,"categories":"<value>"}'

Endpoint
Controller
App\Http\Controllers\API\DeviceController@refresh
Middleware
api auth:sanctum account.status.api
Auth
Required
Request
Path params
None
Query params
None
Body fields
Field Type Required Rules
old_token string Yes required|string|max:512
new_token string Yes required|string|max:512|different:old_token
Content type: application/json
Responses
Status
200 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>",
        "data": "<array>"
    }
}
Status
422 
{
    "message": "The given data was invalid.",
    "errors": {
        "field": [
            "validation_rule_failed"
        ]
    }
}
cURL Example
curl -X POST "{{BASE_URL}}/api/devices/refresh" \
  -H "Authorization: Bearer <API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"old_token":"<value>","new_token":"<value>"}'

Endpoint
Controller
App\Http\Controllers\API\DeviceController@register
Middleware
api auth:sanctum account.status.api
Auth
Required
Request
Path params
None
Query params
None
Body fields
Field Type Required Rules
token string Yes required|string|max:512
platform string Yes required|Rule::in(['android|ios|web
app_version string No nullable|string|max:32
device_name string No nullable|string|max:128
Content type: application/json
Responses
Status
200 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>",
        "data": "<array>"
    }
}
Status
422 
{
    "message": "The given data was invalid.",
    "errors": {
        "field": [
            "validation_rule_failed"
        ]
    }
}
cURL Example
curl -X POST "{{BASE_URL}}/api/devices/register" \
  -H "Authorization: Bearer <API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"token":"<value>","platform":"<value>","app_version":"<value>","device_name":"<value>"}'

Endpoint
Controller
App\Http\Controllers\API\DeviceController@unregister
Middleware
api auth:sanctum account.status.api
Auth
Required
Request
Path params
None
Query params
None
Body fields
Field Type Required Rules
token string Yes required|string|max:512
Content type: application/json
Responses
Status
200 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>"
    }
}
Status
422 
{
    "message": "The given data was invalid.",
    "errors": {
        "field": [
            "validation_rule_failed"
        ]
    }
}
cURL Example
curl -X DELETE "{{BASE_URL}}/api/devices/unregister" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
Closure
Middleware
api
Auth
Not required
Request
Path params
None
Query params
None
Body fields
None
Responses
No explicit responses found in source code.
cURL Example
curl -X POST "{{BASE_URL}}/api/email/resend"

Endpoint
Controller
Closure
Middleware
api throttle:3,1
Auth
Not required
Request
Path params
None
Query params
None
Body fields
None
Responses
No explicit responses found in source code.
cURL Example
curl -X POST "{{BASE_URL}}/api/email/verification-notification"

Endpoint
Controller
Closure
Middleware
api signed
Auth
Not required
Request
Path params
id: string hash: string
Query params
None
Body fields
None
Responses
No explicit responses found in source code.
cURL Example
curl -X GET "{{BASE_URL}}/api/email/verify/{id}/{hash}"

Endpoint
Controller
App\Http\Controllers\API\AccountController@exportMyData
Middleware
api auth:sanctum account.status.api
Auth
Required
Request
Path params
None
Query params
None
Body fields
None
Responses
Status
200 
{
    "example": {
        "_value": "<response expression>"
    }
}
cURL Example
curl -X GET "{{BASE_URL}}/api/export-my-data" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
Closure
Middleware
api throttle:5,1
Auth
Not required
Request
Path params
None
Query params
None
Body fields
None
Responses
No explicit responses found in source code.
cURL Example
curl -X POST "{{BASE_URL}}/api/forgot-password"

Endpoint
Controller
Closure
Middleware
api
Auth
Not required
Request
Path params
None
Query params
None
Body fields
None
Responses
No explicit responses found in source code.
cURL Example
curl -X GET "{{BASE_URL}}/api/health"

Endpoint
Controller
Closure
Middleware
api
Auth
Not required
Request
Path params
None
Query params
None
Body fields
None
Responses
No explicit responses found in source code.
cURL Example
curl -X GET "{{BASE_URL}}/api/i18n/ui"

Endpoint
Controller
App\Http\Controllers\API\APIController@getLevels
Middleware
api
Auth
Not required
Request
Path params
None
Query params
None
Body fields
None
Responses
Status
200 
{
    "example": {
        "levels": "<object>"
    }
}
cURL Example
curl -X GET "{{BASE_URL}}/api/levels"

Endpoint
Controller
App\Http\Controllers\API\AuthController@login
Middleware
api throttle:5,1
Auth
Not required
Request
Path params
None
Query params
None
Body fields
Field Type Required Rules
email email Yes required|email
password string Yes required
Content type: application/json
Responses
Status
401 
{
    "example": {
        "message": "<string>"
    }
}
Status
403 
{
    "example": {
        "message": "<string>"
    }
}
Status
200 
{
    "example": {
        "message": "<string>",
        "user": "<object>",
        "token": "<object>"
    }
}
Status
422 
{
    "message": "The given data was invalid.",
    "errors": {
        "field": [
            "validation_rule_failed"
        ]
    }
}
cURL Example
curl -X POST "{{BASE_URL}}/api/login" \
  -H "Content-Type: application/json" \
  -d '{"email":"<value>","password":"<value>"}'

Endpoint
Controller
App\Http\Controllers\API\AuthController@logout
Middleware
api auth:sanctum
Auth
Required
Request
Path params
None
Query params
None
Body fields
None
Responses
Status
200 
{
    "example": {
        "message": "<string>"
    }
}
cURL Example
curl -X POST "{{BASE_URL}}/api/logout" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\AuthController@me
Middleware
api auth:sanctum
Auth
Required
Request
Path params
None
Query params
None
Body fields
None
Responses
Status
200 
{
    "example": {
        "user": "<object>"
    }
}
cURL Example
curl -X GET "{{BASE_URL}}/api/me" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
Closure
Middleware
api auth:sanctum
Auth
Required
Request
Path params
None
Query params
None
Body fields
None
Responses
No explicit responses found in source code.
cURL Example
curl -X GET "{{BASE_URL}}/api/me/email-verification-status" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\NotificationController@index
Middleware
api auth:sanctum account.status.api
Auth
Required
Request
Path params
None
Query params
type: string unread_only: string
Body fields
None
Responses
Status
200 
{
    "example": {
        "status": "<boolean>",
        "unread_count": "<value>",
        "notifications": "<object>"
    }
}
cURL Example
curl -X GET "{{BASE_URL}}/api/notifications?type=%3Cvalue%3E&unread_only=%3Cvalue%3E" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\NotificationController@markAllRead
Middleware
api auth:sanctum account.status.api
Auth
Required
Request
Path params
None
Query params
None
Body fields
None
Responses
Status
200 
{
    "example": {
        "status": "<boolean>",
        "message": "<string>"
    }
}
cURL Example
curl -X POST "{{BASE_URL}}/api/notifications/mark-all-read" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\NotificationController@unreadCount
Middleware
api auth:sanctum account.status.api
Auth
Required
Request
Path params
None
Query params
None
Body fields
None
Responses
Status
200 
{
    "example": {
        "status": "<boolean>",
        "unread_count": "<object>"
    }
}
cURL Example
curl -X GET "{{BASE_URL}}/api/notifications/unread-count" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\NotificationController@destroy
Middleware
api auth:sanctum account.status.api
Auth
Required
Request
Path params
id: string
Query params
None
Body fields
None
Responses
Status
200 
{
    "example": {
        "status": "<boolean>",
        "message": "<string>"
    }
}
Status
404 
{
    "success": false,
    "message": "The requested resource was not found."
}
cURL Example
curl -X DELETE "{{BASE_URL}}/api/notifications/{id}" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\NotificationController@markAsRead
Middleware
api auth:sanctum account.status.api
Auth
Required
Request
Path params
id: string
Query params
None
Body fields
None
Responses
Status
200 
{
    "example": {
        "status": "<boolean>",
        "message": "<string>",
        "redirect_url": "<object>",
        "data": "<object>"
    }
}
Status
404 
{
    "success": false,
    "message": "The requested resource was not found."
}
cURL Example
curl -X POST "{{BASE_URL}}/api/notifications/{id}/read" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\OpenLookupController@banks
Middleware
api open.api
Auth
Not required
Request
Path params
None
Query params
None
Body fields
None
Responses
No explicit responses found in source code.
cURL Example
curl -X GET "{{BASE_URL}}/api/open/banks"

Endpoint
Controller
App\Http\Controllers\API\OpenLookupController@cities
Middleware
api open.api
Auth
Not required
Request
Path params
None
Query params
None
Body fields
None
Responses
No explicit responses found in source code.
cURL Example
curl -X GET "{{BASE_URL}}/api/open/cities"

Endpoint
Controller
App\Http\Controllers\API\OpenLookupController@citiesByState
Middleware
api open.api
Auth
Not required
Request
Path params
state_id: string
Query params
None
Body fields
None
Responses
No explicit responses found in source code.
cURL Example
curl -X GET "{{BASE_URL}}/api/open/cities/{state_id}"

Endpoint
Controller
App\Http\Controllers\API\OpenLookupController@educationLevels
Middleware
api open.api
Auth
Not required
Request
Path params
None
Query params
None
Body fields
None
Responses
No explicit responses found in source code.
cURL Example
curl -X GET "{{BASE_URL}}/api/open/education-levels"

Endpoint
Controller
App\Http\Controllers\API\OpenLookupController@levels
Middleware
api open.api
Auth
Not required
Request
Path params
None
Query params
None
Body fields
None
Responses
No explicit responses found in source code.
cURL Example
curl -X GET "{{BASE_URL}}/api/open/levels"

Endpoint
Controller
App\Http\Controllers\API\OpenLookupController@preferableLocations
Middleware
api open.api
Auth
Not required
Request
Path params
None
Query params
None
Body fields
None
Responses
No explicit responses found in source code.
cURL Example
curl -X GET "{{BASE_URL}}/api/open/preferable-locations"

Endpoint
Controller
App\Http\Controllers\API\OpenLookupController@relationships
Middleware
api open.api
Auth
Not required
Request
Path params
None
Query params
None
Body fields
None
Responses
No explicit responses found in source code.
cURL Example
curl -X GET "{{BASE_URL}}/api/open/relationships"

Endpoint
Controller
App\Http\Controllers\API\OpenLookupController@states
Middleware
api open.api
Auth
Not required
Request
Path params
None
Query params
None
Body fields
None
Responses
No explicit responses found in source code.
cURL Example
curl -X GET "{{BASE_URL}}/api/open/states"

Endpoint
Controller
App\Http\Controllers\API\OpenLookupController@subjects
Middleware
api open.api
Auth
Not required
Request
Path params
None
Query params
None
Body fields
None
Responses
No explicit responses found in source code.
cURL Example
curl -X GET "{{BASE_URL}}/api/open/subjects"

Endpoint
Controller
App\Http\Controllers\API\OpenLookupController@tutoringModes
Middleware
api open.api
Auth
Not required
Request
Path params
None
Query params
None
Body fields
None
Responses
No explicit responses found in source code.
cURL Example
curl -X GET "{{BASE_URL}}/api/open/tutoring-modes"

Endpoint
Controller
App\Http\Controllers\API\ParentDashboardController@dashboard
Middleware
api
Auth
Not required
Request
Path params
token: string
Query params
None
Body fields
None
Responses
Status
404 
{
    "example": {
        "status": "<boolean>",
        "message": "<string>"
    }
}
Status
200 
{
    "example": {
        "status": "<boolean>",
        "data": "<array>"
    }
}
cURL Example
curl -X GET "{{BASE_URL}}/api/parent-access/{token}"

Endpoint
Controller
App\Http\Controllers\API\PaymentController@cancelSubscription
Middleware
api auth:sanctum account.status.api
Auth
Required
Request
Path params
None
Query params
None
Body fields
Field Type Required Rules
cancel_type string Yes required|in:immediate,end_of_period
Content type: application/json
Responses
Status
404 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>"
    }
}
Status
200 
{
    "example": {
        "success": "<boolean>",
        "message": "<object>",
        "subscription": "<array>"
    }
}
Status
422 
{
    "message": "The given data was invalid.",
    "errors": {
        "field": [
            "validation_rule_failed"
        ]
    }
}
cURL Example
curl -X POST "{{BASE_URL}}/api/payment/cancel-subscription" \
  -H "Authorization: Bearer <API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"cancel_type":"<value>"}'

Endpoint
Controller
App\Http\Controllers\API\PaymentController@createOrder
Middleware
api auth:sanctum account.status.api
Auth
Required
Request
Path params
None
Query params
None
Body fields
Field Type Required Rules
plan string Yes required|in:monthly
Content type: application/json
Responses
Status
200 
{
    "example": {
        "success": "<boolean>",
        "order_id": "<object>",
        "amount": "<object>",
        "currency": "<object>",
        "key": "<value>",
        "user": "<array>"
    }
}
Status
500 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>"
    }
}
Status
422 
{
    "message": "The given data was invalid.",
    "errors": {
        "field": [
            "validation_rule_failed"
        ]
    }
}
cURL Example
curl -X POST "{{BASE_URL}}/api/payment/create-order" \
  -H "Authorization: Bearer <API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"plan":"<value>"}'

Endpoint
Controller
App\Http\Controllers\API\PaymentController@history
Middleware
api auth:sanctum account.status.api
Auth
Required
Request
Path params
None
Query params
None
Body fields
None
Responses
Status
200 
{
    "example": {
        "success": "<boolean>",
        "data": "<object>"
    }
}
cURL Example
curl -X GET "{{BASE_URL}}/api/payment/history" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\PaymentController@invoices
Middleware
api auth:sanctum account.status.api
Auth
Required
Request
Path params
None
Query params
None
Body fields
None
Responses
Status
200 
{
    "example": {
        "success": "<boolean>",
        "data": "<object>"
    }
}
cURL Example
curl -X GET "{{BASE_URL}}/api/payment/invoices" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\PaymentController@showInvoice
Middleware
api auth:sanctum account.status.api
Auth
Required
Request
Path params
id: string
Query params
None
Body fields
None
Responses
Status
404 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>"
    }
}
Status
200 
{
    "example": {
        "success": "<boolean>",
        "data": "<object>"
    }
}
cURL Example
curl -X GET "{{BASE_URL}}/api/payment/invoices/{id}" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\PaymentController@downloadInvoiceUrl
Middleware
api auth:sanctum account.status.api
Auth
Required
Request
Path params
id: string
Query params
None
Body fields
None
Responses
Status
404 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>"
    }
}
Status
200 
{
    "example": {
        "success": "<boolean>",
        "download_url": "<object>",
        "expires_in": "<number>"
    }
}
cURL Example
curl -X GET "{{BASE_URL}}/api/payment/invoices/{id}/download-url" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\PaymentController@plans
Middleware
api auth:sanctum account.status.api
Auth
Required
Request
Path params
None
Query params
None
Body fields
None
Responses
Status
200 
{
    "example": {
        "success": "<boolean>",
        "plans": "<array>"
    }
}
cURL Example
curl -X GET "{{BASE_URL}}/api/payment/plans" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\PaymentController@status
Middleware
api auth:sanctum account.status.api
Auth
Required
Request
Path params
None
Query params
None
Body fields
None
Responses
Status
200 
{
    "example": {
        "success": "<boolean>",
        "is_premium": "<value>",
        "subscription": "<object>",
        "last_payment": "<object>"
    }
}
cURL Example
curl -X GET "{{BASE_URL}}/api/payment/status" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\PaymentController@verifyPayment
Middleware
api auth:sanctum account.status.api
Auth
Required
Request
Path params
None
Query params
None
Body fields
Field Type Required Rules
razorpay_order_id string Yes required|string
razorpay_payment_id string Yes required|string
razorpay_signature string Yes required|string
Content type: application/json
Responses
Status
200 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>",
        "idempotent": "<boolean>"
    }
}
Status
400 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>"
    }
}
Status
500 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>"
    }
}
Status
422 
{
    "message": "The given data was invalid.",
    "errors": {
        "field": [
            "validation_rule_failed"
        ]
    }
}
cURL Example
curl -X POST "{{BASE_URL}}/api/payment/verify" \
  -H "Authorization: Bearer <API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"razorpay_order_id":"<value>","razorpay_payment_id":"<value>","razorpay_signature":"<value>"}'

Endpoint
Controller
App\Http\Controllers\API\AuthController@refreshToken
Middleware
api auth:sanctum
Auth
Required
Request
Path params
None
Query params
None
Body fields
None
Responses
Status
200 
{
    "example": {
        "message": "<string>",
        "token": "<object>"
    }
}
cURL Example
curl -X POST "{{BASE_URL}}/api/refresh-token" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\AuthController@register
Middleware
api throttle:5,1
Auth
Not required
Request
Path params
None
Query params
None
Body fields
Field Type Required Rules
name string Yes required|string|max:255
email email Yes required|email|max:255|unique:users
password string Yes required|string|min:8|confirmed|regex:/[A-Z]/|regex:/[0-9]/
pdpa_terms boolean No accepted
pdpa_privacy boolean No accepted
pdpa_consent boolean No accepted
user_type string Yes required|in:student,tutor,parent
children[] array No required|array|min:1 (when user_type=parent)
children[].name string Yes required|string|max:255 (when user_type=parent)
children[].form_level string Yes required|in:primary,secondary,college (when user_type=parent)
children[].email email No nullable|email|max:255 (when provided, unique:users,email)
form_level string No required|string|max:255 (when user_type=student)
Content type: application/json
Responses
Status
422 
{
    "example": {
        "status": "<string>",
        "message": "<object>",
        "errors": "<object>"
    }
}
Status
201 
{
    "example": {
        "status": "<string>",
        "message": "<string>",
        "parent": "<array>",
        "children": "<object>",
        "user_full": "<object>",
        "token": "<object>"
    }
}
cURL Example
curl -X POST "{{BASE_URL}}/api/register" \
  -H "Content-Type: application/json" \
  -d '{"name":"<value>","email":"<value>","password":"<value>","pdpa_terms":true,"pdpa_privacy":true,"pdpa_consent":true,"user_type":"<value>","form_level":"<value>","children":["<value>"]}'

Endpoint
Controller
App\Http\Controllers\API\AuthController@registerSims
Middleware
api throttle:5,1
Auth
Not required
Request
Path params
None
Query params
None
Body fields
None
Responses
Status
422 
{
    "example": {
        "status": "<string>",
        "message": "<object>",
        "errors": "<object>"
    }
}
Status
409 
{
    "example": {
        "status": "<string>",
        "message": "<string>"
    }
}
Status
201 
{
    "example": {
        "status": "<string>",
        "message": "<string>",
        "user": "<array>",
        "token": "<object>"
    }
}
cURL Example
curl -X POST "{{BASE_URL}}/api/register/sims"

Endpoint
Controller
Closure
Middleware
api throttle:5,1
Auth
Not required
Request
Path params
None
Query params
None
Body fields
None
Responses
No explicit responses found in source code.
cURL Example
curl -X POST "{{BASE_URL}}/api/reset-password"

Endpoint
Controller
App\Http\Controllers\API\APIController@getSubjects
Middleware
api
Auth
Not required
Request
Path params
None
Query params
None
Body fields
None
Responses
Status
200 
{
    "example": {
        "subjects": "<object>"
    }
}
cURL Example
curl -X GET "{{BASE_URL}}/api/subjects"

Endpoint
Controller
App\Http\Controllers\API\Tutor\LessonTopicTaggingController@update
Middleware
api auth:sanctum account.status.api
Auth
Required
Request
Path params
lesson: string
Query params
None
Body fields
Field Type Required Rules
topic_ids array No present|array
topic_ids[] integer No integer|Rule::exists('topics|id')->where('status|Topic::STATUS_APPROVED)
Content type: application/json
Responses
Status
422 
{
    "example": {
        "message": "<string>",
        "errors": "<array>"
    }
}
Status
200 
{
    "example": {
        "data": "<array>"
    }
}
Status
401 
{
    "success": false,
    "message": "Authentication required."
}
Status
403 
{
    "view": "backend.errors.403",
    "message": "Tutor or admin role required."
}
Status
404 
{
    "success": false,
    "message": "The requested resource was not found."
}
cURL Example
curl -X POST "{{BASE_URL}}/api/tutor/lessons/{lesson}/topics" \
  -H "Authorization: Bearer <API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"topic_ids":[0]}'

Endpoint
Controller
App\Http\Controllers\API\Tutor\QuestionTopicTaggingController@update
Middleware
api auth:sanctum account.status.api
Auth
Required
Request
Path params
question: string
Query params
None
Body fields
Field Type Required Rules
topic_id integer Yes required|integer|Rule::exists('topics|id')->where('status|Topic::STATUS_APPROVED)
Content type: application/json
Responses
Status
200 
{
    "example": {
        "data": "<array>"
    }
}
Status
401 
{
    "success": false,
    "message": "Authentication required."
}
Status
403 
{
    "view": "backend.errors.403",
    "message": "Tutor or admin role required."
}
Status
422 
{
    "message": "The given data was invalid.",
    "errors": {
        "field": [
            "validation_rule_failed"
        ]
    }
}
Status
404 
{
    "success": false,
    "message": "The requested resource was not found."
}
cURL Example
curl -X PATCH "{{BASE_URL}}/api/tutor/quiz-questions/{question}/topic" \
  -H "Authorization: Bearer <API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"topic_id":0}'

Parent API

Endpoint
Controller
App\Http\Controllers\API\ParentDashboardController@childQuizResults
Middleware
api auth:sanctum account.status.api role.api:parent
Auth
Required
Request
Path params
id: string
Query params
None
Body fields
None
Responses
Status
200 
{
    "example": {
        "success": "<boolean>",
        "data": "<object>"
    }
}
cURL Example
curl -X GET "{{BASE_URL}}/api/parent/children/{id}/quiz-results" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\ParentDashboardController@childReport
Middleware
api auth:sanctum account.status.api role.api:parent
Auth
Required
Request
Path params
id: string
Query params
None
Body fields
None
Responses
Status
200 
{
    "example": {
        "success": "<boolean>",
        "data": "<array>"
    }
}
cURL Example
curl -X GET "{{BASE_URL}}/api/parent/children/{id}/report" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\ParentDashboardController@myDashboard
Middleware
api auth:sanctum account.status.api role.api:parent
Auth
Required
Request
Path params
None
Query params
None
Body fields
None
Responses
Status
403 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>"
    }
}
Status
200 
{
    "example": {
        "success": "<boolean>",
        "data": "<array>"
    }
}
cURL Example
curl -X GET "{{BASE_URL}}/api/parent/dashboard" \
  -H "Authorization: Bearer <API_TOKEN>"

Student API

Endpoint
Controller
App\Http\Controllers\Backend\AiChatController@ask
Middleware
api auth:sanctum account.status.api role.api:student ai.quota
Auth
Required
Request
Path params
None
Query params
chat_id: string lesson_context: string
Body fields
None
Responses
Status
503 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>"
    }
}
Status
200 
{
    "example": {
        "chat_id": "<object>",
        "chat_name": "<object>",
        "is_new_chat": "<object>",
        "answer": "<object>"
    }
}
Status
422 
{
    "message": "The given data was invalid.",
    "errors": {
        "field": [
            "validation_rule_failed"
        ]
    }
}
cURL Example
curl -X POST "{{BASE_URL}}/api/ai/ask" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\APIController@ai_chats
Middleware
api auth:sanctum account.status.api role.api:student
Auth
Required
Request
Path params
None
Query params
None
Body fields
None
Responses
Status
200 
{
    "example": {
        "data": "<object>",
        "meta": "<array>"
    }
}
cURL Example
curl -X GET "{{BASE_URL}}/api/ai/get/chats" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\APIController@getBadges
Middleware
api auth:sanctum account.status.api role.api:student
Auth
Required
Request
Path params
None
Query params
None
Body fields
None
Responses
Status
200 
{
    "example": {
        "status": "<boolean>",
        "data": "<object>"
    }
}
cURL Example
curl -X GET "{{BASE_URL}}/api/badges" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\APIStudentCourseController@browseCourses
Middleware
api auth:sanctum account.status.api role.api:student
Auth
Required
Request
Path params
None
Query params
search: string subject: string level: string tutor: string
Body fields
None
Responses
Status
200 
{
    "example": {
        "success": "<boolean>",
        "data": "<object>",
        "filters": "<array>"
    }
}
cURL Example
curl -X GET "{{BASE_URL}}/api/browse/courses?search=%3Cvalue%3E&subject=%3Cvalue%3E&level=%3Cvalue%3E&tutor=%3Cvalue%3E" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\APIStudentCourseController@browseLiveClasses
Middleware
api auth:sanctum account.status.api role.api:student
Auth
Required
Request
Path params
None
Query params
upcoming_days: string
Body fields
None
Responses
Status
200 
{
    "example": {
        "success": "<boolean>",
        "data": "<array>",
        "filters": "<array>"
    }
}
cURL Example
curl -X GET "{{BASE_URL}}/api/browse/live-classes?upcoming_days=%3Cvalue%3E" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\APIStudentCourseController@overallProgress
Middleware
api auth:sanctum account.status.api role.api:student
Auth
Required
Request
Path params
course: string
Query params
None
Body fields
None
Responses
Status
403 
{
    "example": {
        "status": "<boolean>",
        "message": "<string>"
    }
}
Status
200 
{
    "example": {
        "status": "<boolean>",
        "data": "<array>"
    }
}
cURL Example
curl -X GET "{{BASE_URL}}/api/courses/{course}/overall-progress" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\APIStudentCourseController@show
Middleware
api auth:sanctum account.status.api role.api:student
Auth
Required
Request
Path params
slug: string
Query params
None
Body fields
None
Responses
Status
404 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>"
    }
}
Status
403 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>",
        "code": "<string>",
        "payment_required": "<boolean>",
        "is_premium": "<boolean>",
        "is_enrolled": "<boolean>"
    }
}
Status
200 
{
    "example": {
        "success": "<boolean>",
        "course": "<array>"
    }
}
cURL Example
curl -X GET "{{BASE_URL}}/api/courses/{slug}" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\APIStudentCourseController@acknowledgeCompletion
Middleware
api auth:sanctum account.status.api role.api:student
Auth
Required
Request
Path params
slug: string
Query params
None
Body fields
None
Responses
Status
404 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>"
    }
}
Status
403 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>"
    }
}
Status
422 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>"
    }
}
Status
200 
{
    "example": {
        "success": "<boolean>",
        "data": "<array>"
    }
}
cURL Example
curl -X POST "{{BASE_URL}}/api/courses/{slug}/completion-acknowledged" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\APIStudentCourseController@enrollNow
Middleware
api auth:sanctum account.status.api role.api:student
Auth
Required
Request
Path params
slug: string
Query params
None
Body fields
None
Responses
Status
403 
{
    "example": {
        "message": "<string>"
    }
}
Status
404 
{
    "example": {
        "message": "<string>"
    }
}
Status
409 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>",
        "is_enrolled": "<boolean>",
        "already_enrolled": "<boolean>",
        "code": "<string>"
    }
}
Status
201 
{
    "example": {
        "message": "<string>",
        "data": "<array>"
    }
}
cURL Example
curl -X POST "{{BASE_URL}}/api/courses/{slug}/enroll" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\APIStudentCourseController@reportCourse
Middleware
api auth:sanctum account.status.api role.api:student
Auth
Required
Request
Path params
slug: string
Query params
None
Body fields
Field Type Required Rules
reason string Yes required|string|max:1000
Content type: application/json
Responses
Status
404 
{
    "example": {
        "message": "<string>"
    }
}
Status
409 
{
    "example": {
        "message": "<string>"
    }
}
Status
201 
{
    "example": {
        "message": "<string>",
        "data": "<array>"
    }
}
Status
422 
{
    "message": "The given data was invalid.",
    "errors": {
        "field": [
            "validation_rule_failed"
        ]
    }
}
cURL Example
curl -X POST "{{BASE_URL}}/api/courses/{slug}/report" \
  -H "Authorization: Bearer <API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"reason":"<value>"}'

Endpoint
Controller
App\Http\Controllers\API\APIStudentCourseController@unEnroll
Middleware
api auth:sanctum account.status.api role.api:student
Auth
Required
Request
Path params
slug: string
Query params
None
Body fields
None
Responses
Status
403 
{
    "example": {
        "message": "<string>"
    }
}
Status
404 
{
    "example": {
        "message": "<string>"
    }
}
Status
200 
{
    "example": {
        "message": "<string>"
    }
}
cURL Example
curl -X DELETE "{{BASE_URL}}/api/courses/{slug}/unenroll" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\APIStudentCourseController@removeFromWishlist
Middleware
api auth:sanctum account.status.api role.api:student
Auth
Required
Request
Path params
slug: string
Query params
None
Body fields
None
Responses
Status
403 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>"
    }
}
Status
404 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>"
    }
}
Status
200 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>",
        "is_saved": "<boolean>",
        "data": "<array>"
    }
}
cURL Example
curl -X DELETE "{{BASE_URL}}/api/courses/{slug}/wishlist" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\APIStudentCourseController@addToWishlist
Middleware
api auth:sanctum account.status.api role.api:student
Auth
Required
Request
Path params
slug: string
Query params
None
Body fields
None
Responses
Status
403 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>"
    }
}
Status
404 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>"
    }
}
Status
200 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>",
        "is_saved": "<boolean>",
        "data": "<array>"
    }
}
cURL Example
curl -X POST "{{BASE_URL}}/api/courses/{slug}/wishlist" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\APIStudentCourseController@deleteVideoBookmark
Middleware
api auth:sanctum account.status.api role.api:student
Auth
Required
Request
Path params
id: string
Query params
None
Body fields
None
Responses
Status
422 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>"
    }
}
Status
404 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>"
    }
}
Status
403 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>"
    }
}
Status
200 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>"
    }
}
cURL Example
curl -X DELETE "{{BASE_URL}}/api/lesson/{id}/bookmark" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\APIStudentCourseController@videoBookmark
Middleware
api auth:sanctum account.status.api role.api:student
Auth
Required
Request
Path params
id: string
Query params
None
Body fields
Field Type Required Rules
timestamp integer Yes required|integer|min:0
note string No nullable|string|max:1000
Content type: application/json
Responses
Status
404 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>"
    }
}
Status
403 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>"
    }
}
Status
201 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>",
        "data": "<array>"
    }
}
Status
422 
{
    "message": "The given data was invalid.",
    "errors": {
        "field": [
            "validation_rule_failed"
        ]
    }
}
cURL Example
curl -X POST "{{BASE_URL}}/api/lesson/{id}/bookmark" \
  -H "Authorization: Bearer <API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"timestamp":0,"note":"<value>"}'

Endpoint
Controller
App\Http\Controllers\API\APIStudentCourseController@deleteVideoBookmark
Middleware
api auth:sanctum account.status.api role.api:student
Auth
Required
Request
Path params
id: string bookmarkId: string
Query params
None
Body fields
None
Responses
Status
422 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>"
    }
}
Status
404 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>"
    }
}
Status
403 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>"
    }
}
Status
200 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>"
    }
}
cURL Example
curl -X DELETE "{{BASE_URL}}/api/lesson/{id}/bookmark/{bookmarkId}" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\APIStudentCourseController@updateVideoProgress
Middleware
api auth:sanctum account.status.api role.api:student
Auth
Required
Request
Path params
lesson: string
Query params
None
Body fields
Field Type Required Rules
last_position integer Yes required|integer|min:0
duration_delta integer Yes required|integer|min:1|max:10
Content type: application/json
Responses
Status
400 
{
    "example": {
        "status": "<boolean>",
        "message": "<string>"
    }
}
Status
200 
{
    "example": {
        "status": "<boolean>",
        "data": "<array>"
    }
}
Status
422 
{
    "message": "The given data was invalid.",
    "errors": {
        "field": [
            "validation_rule_failed"
        ]
    }
}
Status
404 
{
    "success": false,
    "message": "The requested resource was not found."
}
cURL Example
curl -X POST "{{BASE_URL}}/api/lessons/{lesson}/video-progress" \
  -H "Authorization: Bearer <API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"last_position":0,"duration_delta":0}'

Endpoint
Controller
App\Http\Controllers\Backend\LiveClassController@join
Middleware
api auth:sanctum account.status.api role.api:student
Auth
Required
Request
Path params
liveClass: string
Query params
None
Body fields
None
Responses
Status
400 
{
    "example": {
        "status": "<boolean>",
        "message": "<object>"
    }
}
Status
200 
{
    "example": {
        "status": "<boolean>",
        "message": "<string>",
        "data": "<array>"
    }
}
Status
500 
{
    "example": {
        "status": "<boolean>",
        "message": "<object>",
        "error": "<object>"
    }
}
cURL Example
curl -X POST "{{BASE_URL}}/api/live-classes/{liveClass}/join" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\APIStudentCourseController@myCourses
Middleware
api auth:sanctum account.status.api role.api:student
Auth
Required
Request
Path params
None
Query params
search: string subject: string level: string tutor: string
Body fields
None
Responses
Status
200 
{
    "example": {
        "success": "<boolean>",
        "data": "<array>",
        "filters": "<array>"
    }
}
cURL Example
curl -X GET "{{BASE_URL}}/api/my-courses?search=%3Cvalue%3E&subject=%3Cvalue%3E&level=%3Cvalue%3E&tutor=%3Cvalue%3E" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\APIStudentCourseController@show
Middleware
api auth:sanctum account.status.api role.api:student
Auth
Required
Request
Path params
slug: string
Query params
None
Body fields
None
Responses
Status
404 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>"
    }
}
Status
403 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>",
        "code": "<string>",
        "payment_required": "<boolean>",
        "is_premium": "<boolean>",
        "is_enrolled": "<boolean>"
    }
}
Status
200 
{
    "example": {
        "success": "<boolean>",
        "course": "<array>"
    }
}
cURL Example
curl -X GET "{{BASE_URL}}/api/my-courses/{slug}" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\APIController@show
Middleware
api auth:sanctum account.status.api role.api:student
Auth
Required
Request
Path params
None
Query params
None
Body fields
None
Responses
Status
200 
{
    "example": {
        "status": "<boolean>",
        "message": "<string>"
    }
}
cURL Example
curl -X GET "{{BASE_URL}}/api/parent-access" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\APIController@generate
Middleware
api auth:sanctum account.status.api role.api:student
Auth
Required
Request
Path params
None
Query params
None
Body fields
None
Responses
Status
400 
{
    "example": {
        "status": "<boolean>",
        "message": "<string>"
    }
}
Status
200 
{
    "example": {
        "status": "<boolean>",
        "message": "<string>",
        "data": "<array>"
    }
}
cURL Example
curl -X POST "{{BASE_URL}}/api/parent-access/generate" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\APIController@regenerate
Middleware
api auth:sanctum account.status.api role.api:student
Auth
Required
Request
Path params
None
Query params
None
Body fields
None
Responses
Status
200 
{
    "example": {
        "status": "<boolean>",
        "message": "<string>",
        "data": "<array>"
    }
}
cURL Example
curl -X POST "{{BASE_URL}}/api/parent-access/regenerate" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\APIController@revoke
Middleware
api auth:sanctum account.status.api role.api:student
Auth
Required
Request
Path params
None
Query params
None
Body fields
None
Responses
Status
200 
{
    "example": {
        "status": "<boolean>",
        "message": "<string>"
    }
}
cURL Example
curl -X POST "{{BASE_URL}}/api/parent-access/revoke" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\APIStudentQuizController@questions
Middleware
api auth:sanctum account.status.api role.api:student
Auth
Required
Request
Path params
attempt: string
Query params
None
Body fields
None
Responses
Status
403 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>"
    }
}
Status
200 
{
    "example": {
        "attempt_id": "<object>",
        "total_questions": "<object>",
        "time_remaining": "<object>",
        "questions": "<object>"
    }
}
cURL Example
curl -X GET "{{BASE_URL}}/api/quiz-attempts/{attempt}/questions" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\APIStudentQuizController@review
Middleware
api auth:sanctum account.status.api role.api:student
Auth
Required
Request
Path params
attempt: string
Query params
None
Body fields
None
Responses
Status
404 
{
    "example": {
        "message": "<string>"
    }
}
Status
403 
{
    "example": {
        "message": "<string>"
    }
}
Status
200 
{
    "example": {
        "message": "<string>",
        "data": "<array>"
    }
}
cURL Example
curl -X GET "{{BASE_URL}}/api/quiz-attempts/{attempt}/review" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\APIStudentQuizController@submit
Middleware
api auth:sanctum account.status.api role.api:student
Auth
Required
Request
Path params
attempt: string
Query params
answers: string
Body fields
None
Responses
Status
403 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>"
    }
}
Status
200 
{
    "example": {
        "score": "<object>",
        "total_questions": "<object>",
        "correct_answers": "<object>",
        "wrong_answers": "<object>",
        "percentage": "<object>",
        "passed": "<object>",
        "feedback": "<object>",
        "show_results": "<object>"
    }
}
cURL Example
curl -X POST "{{BASE_URL}}/api/quiz-attempts/{attempt}/submit" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\APIStudentQuizController@attempts
Middleware
api auth:sanctum account.status.api role.api:student
Auth
Required
Request
Path params
quiz: string
Query params
None
Body fields
None
Responses
No explicit responses found in source code.
cURL Example
curl -X GET "{{BASE_URL}}/api/quizzes/{quiz}/attempts" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\APIStudentQuizController@overview
Middleware
api auth:sanctum account.status.api role.api:student
Auth
Required
Request
Path params
quiz: string
Query params
None
Body fields
None
Responses
Status
403 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>"
    }
}
Status
200 
{
    "example": {
        "quiz": "<array>",
        "attempts": "<array>",
        "attempts_remaining": "<object>",
        "can_attempt": "<object>",
        "can_check_result": "<object>"
    }
}
cURL Example
curl -X GET "{{BASE_URL}}/api/quizzes/{quiz}/overview" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\APIStudentQuizController@start
Middleware
api auth:sanctum account.status.api role.api:student
Auth
Required
Request
Path params
quiz: string
Query params
None
Body fields
None
Responses
Status
403 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>"
    }
}
Status
200 
{
    "example": {
        "attempt_id": "<object>",
        "attempt_number": "<object>",
        "started_at": "<object>",
        "time_limit": "<object>"
    }
}
cURL Example
curl -X POST "{{BASE_URL}}/api/quizzes/{quiz}/start" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\CertificateController@index
Middleware
api auth:sanctum account.status.api role.api:student
Auth
Required
Request
Path params
None
Query params
None
Body fields
None
Responses
Status
200 
{
    "example": {
        "data": "<object>"
    }
}
cURL Example
curl -X GET "{{BASE_URL}}/api/student/certificates" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\CertificateController@show
Middleware
api auth:sanctum account.status.api role.api:student
Auth
Required
Request
Path params
uuid: string
Query params
None
Body fields
None
Responses
Status
200 
{
    "example": {
        "data": "<object>"
    }
}
Status
403 
{
    "view": "backend.errors.403",
    "message": null
}
Status
404 
{
    "success": false,
    "message": "The requested resource was not found."
}
cURL Example
curl -X GET "{{BASE_URL}}/api/student/certificates/{uuid}" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\CertificateController@download
Middleware
api auth:sanctum account.status.api role.api:student
Auth
Required
Request
Path params
uuid: string
Query params
None
Body fields
None
Responses
Status
403 
{
    "view": "backend.errors.403",
    "message": null
}
Status
404 
{
    "success": false,
    "message": "The requested resource was not found."
}
cURL Example
curl -X GET "{{BASE_URL}}/api/student/certificates/{uuid}/download" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\APIController@student_dashboard_analytics
Middleware
api auth:sanctum account.status.api role.api:student
Auth
Required
Request
Path params
None
Query params
None
Body fields
None
Responses
Status
200 
{
    "example": {
        "courses_enrolled": "<array>",
        "videos_watched": "<array>",
        "quiz_average": "<array>",
        "learning_time": "<array>"
    }
}
cURL Example
curl -X GET "{{BASE_URL}}/api/student/dashboard-analytics" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\Student\CaptionController@streamVtt
Middleware
api auth:sanctum account.status.api role.api:student
Auth
Required
Request
Path params
lesson: string
Query params
None
Body fields
None
Responses
Status
404 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>"
    }
}
cURL Example
curl -X GET "{{BASE_URL}}/api/student/lessons/{lesson}/captions.vtt" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\Student\CaptionController@signedUrl
Middleware
api auth:sanctum account.status.api role.api:student
Auth
Required
Request
Path params
lesson: string
Query params
None
Body fields
None
Responses
Status
200 
{
    "example": {
        "url": "<object>",
        "expires_at": "<object>"
    }
}
cURL Example
curl -X GET "{{BASE_URL}}/api/student/lessons/{lesson}/captions/signed-url" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\Student\CaptionController@transcript
Middleware
api auth:sanctum account.status.api role.api:student
Auth
Required
Request
Path params
lesson: string
Query params
None
Body fields
None
Responses
Status
200 
{
    "example": {
        "success": "<boolean>",
        "language": "<object>",
        "duration_seconds": "<value>",
        "segments": "<object>"
    }
}
cURL Example
curl -X GET "{{BASE_URL}}/api/student/lessons/{lesson}/transcript" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\Student\MasteryController@topics
Middleware
api auth:sanctum account.status.api role.api:student
Auth
Required
Request
Path params
None
Query params
None
Body fields
None
Responses
No explicit responses found in source code.
cURL Example
curl -X GET "{{BASE_URL}}/api/student/mastery/topics" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\Student\MasteryController@weakAreas
Middleware
api auth:sanctum account.status.api role.api:student
Auth
Required
Request
Path params
None
Query params
None
Body fields
None
Responses
No explicit responses found in source code.
cURL Example
curl -X GET "{{BASE_URL}}/api/student/mastery/weak-areas" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\Student\XpController@events
Middleware
api auth:sanctum account.status.api role.api:student
Auth
Required
Request
Path params
None
Query params
None
Body fields
None
Responses
Status
200 
{
    "example": {
        "_value": "<response expression>"
    }
}
cURL Example
curl -X GET "{{BASE_URL}}/api/student/xp/events" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\Student\XpController@markMilestoneSeen
Middleware
api auth:sanctum account.status.api role.api:student
Auth
Required
Request
Path params
None
Query params
badge: string
Body fields
Field Type Required Rules
badge string Yes required|string|in:' . implode(||self::STREAK_BADGES)
Content type: application/json
Responses
Status
200 
{
    "example": {
        "ok": "<boolean>"
    }
}
Status
422 
{
    "message": "The given data was invalid.",
    "errors": {
        "field": [
            "validation_rule_failed"
        ]
    }
}
cURL Example
curl -X POST "{{BASE_URL}}/api/student/xp/milestone-seen" \
  -H "Authorization: Bearer <API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"badge":"<value>"}'

Endpoint
Controller
App\Http\Controllers\API\Student\XpController@streakCalendar
Middleware
api auth:sanctum account.status.api role.api:student
Auth
Required
Request
Path params
None
Query params
None
Body fields
None
Responses
Status
200 
{
    "example": {
        "_value": "<response expression>"
    }
}
cURL Example
curl -X GET "{{BASE_URL}}/api/student/xp/streak-calendar" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\Student\XpController@summary
Middleware
api auth:sanctum account.status.api role.api:student
Auth
Required
Request
Path params
None
Query params
None
Body fields
None
Responses
No explicit responses found in source code.
cURL Example
curl -X GET "{{BASE_URL}}/api/student/xp/summary" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\APIStudentVideoQAController@index
Middleware
api auth:sanctum account.status.api role.api:student
Auth
Required
Request
Path params
None
Query params
filter: string
Body fields
Field Type Required Rules
lesson_id string Yes required|exists:lessons,id
Content type: application/json
Responses
Status
200 
{
    "example": {
        "status": "<boolean>",
        "total_comments": "<object>",
        "data": "<object>"
    }
}
Status
422 
{
    "message": "The given data was invalid.",
    "errors": {
        "field": [
            "validation_rule_failed"
        ]
    }
}
cURL Example
curl -X GET "{{BASE_URL}}/api/video-qna?filter=%3Cvalue%3E" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\APIStudentVideoQAController@store
Middleware
api auth:sanctum account.status.api role.api:student
Auth
Required
Request
Path params
None
Query params
None
Body fields
Field Type Required Rules
lesson_id string Yes required|exists:lessons,id
question_text string Yes required|string
Content type: application/json
Responses
Status
403 
{
    "example": {
        "message": "<string>"
    }
}
Status
201 
{
    "example": {
        "status": "<boolean>",
        "message": "<string>"
    }
}
Status
422 
{
    "message": "The given data was invalid.",
    "errors": {
        "field": [
            "validation_rule_failed"
        ]
    }
}
cURL Example
curl -X POST "{{BASE_URL}}/api/video-qna" \
  -H "Authorization: Bearer <API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"lesson_id":"<value>","question_text":"<value>"}'

Endpoint
Controller
App\Http\Controllers\API\APIStudentVideoQAController@unflag
Middleware
api auth:sanctum account.status.api role.api:student
Auth
Required
Request
Path params
None
Query params
None
Body fields
Field Type Required Rules
flaggable_type string Yes required|in:video_question,video_answer
flaggable_id integer Yes required|integer
Content type: application/json
Responses
Status
404 
{
    "example": {
        "message": "<string>"
    }
}
Status
200 
{
    "example": {
        "message": "<string>"
    }
}
Status
422 
{
    "message": "The given data was invalid.",
    "errors": {
        "field": [
            "validation_rule_failed"
        ]
    }
}
cURL Example
curl -X DELETE "{{BASE_URL}}/api/video-qna/flag" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\APIStudentVideoQAController@flag
Middleware
api auth:sanctum account.status.api role.api:student
Auth
Required
Request
Path params
None
Query params
None
Body fields
Field Type Required Rules
flaggable_type string Yes required|in:video_question,video_answer
flaggable_id integer Yes required|integer
reason string No nullable|string|max:1000
Content type: application/json
Responses
Status
404 
{
    "example": {
        "message": "<string>"
    }
}
Status
201 
{
    "example": {
        "message": "<string>",
        "data": "<object>"
    }
}
Status
422 
{
    "message": "The given data was invalid.",
    "errors": {
        "field": [
            "validation_rule_failed"
        ]
    }
}
cURL Example
curl -X POST "{{BASE_URL}}/api/video-qna/flag" \
  -H "Authorization: Bearer <API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"flaggable_type":"<value>","flaggable_id":0,"reason":"<value>"}'

Endpoint
Controller
App\Http\Controllers\API\APIStudentVideoQAController@recentUserQA
Middleware
api auth:sanctum account.status.api role.api:student
Auth
Required
Request
Path params
None
Query params
None
Body fields
None
Responses
Status
401 
{
    "example": {
        "status": "<boolean>",
        "message": "<string>"
    }
}
Status
200 
{
    "example": {
        "status": "<boolean>",
        "total_comments": "<object>",
        "data": "<object>"
    }
}
cURL Example
curl -X GET "{{BASE_URL}}/api/video-qna/recent" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\APIStudentVideoQAController@show
Middleware
api auth:sanctum account.status.api role.api:student
Auth
Required
Request
Path params
question: string
Query params
None
Body fields
None
Responses
Status
200 
{
    "example": {
        "status": "<boolean>",
        "data": "<object>"
    }
}
cURL Example
curl -X GET "{{BASE_URL}}/api/video-qna/{question}" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\APIStudentVideoQAController@reply
Middleware
api auth:sanctum account.status.api role.api:student
Auth
Required
Request
Path params
question: string
Query params
None
Body fields
Field Type Required Rules
answer_text string Yes required|string
Content type: application/json
Responses
Status
201 
{
    "example": {
        "status": "<boolean>",
        "message": "<string>",
        "data": "<object>"
    }
}
Status
422 
{
    "message": "The given data was invalid.",
    "errors": {
        "field": [
            "validation_rule_failed"
        ]
    }
}
cURL Example
curl -X POST "{{BASE_URL}}/api/video-qna/{question}/reply" \
  -H "Authorization: Bearer <API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"answer_text":"<value>"}'

Endpoint
Controller
App\Http\Controllers\API\APIStudentVideoQAController@update
Middleware
api auth:sanctum account.status.api role.api:student
Auth
Required
Request
Path params
question: string
Query params
None
Body fields
Field Type Required Rules
question_text string Yes required|string
is_anonymous boolean No nullable|boolean
Content type: application/json
Responses
Status
403 
{
    "example": {
        "status": "<boolean>",
        "message": "<string>"
    }
}
Status
400 
{
    "example": {
        "status": "<boolean>",
        "message": "<string>"
    }
}
Status
200 
{
    "example": {
        "status": "<boolean>",
        "message": "<string>",
        "data": "<object>"
    }
}
Status
422 
{
    "message": "The given data was invalid.",
    "errors": {
        "field": [
            "validation_rule_failed"
        ]
    }
}
cURL Example
curl -X PUT "{{BASE_URL}}/api/video-qna/{question}/update-qa" \
  -H "Authorization: Bearer <API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"question_text":"<value>","is_anonymous":true}'

Endpoint
Controller
App\Http\Controllers\API\APIStudentVideoQAController@upvote
Middleware
api auth:sanctum account.status.api role.api:student
Auth
Required
Request
Path params
question: string
Query params
None
Body fields
None
Responses
Status
200 
{
    "example": {
        "status": "<boolean>",
        "message": "<string>"
    }
}
cURL Example
curl -X POST "{{BASE_URL}}/api/video-qna/{question}/upvote" \
  -H "Authorization: Bearer <API_TOKEN>"

Tutor API

Endpoint
Controller
App\Http\Controllers\API\Tutor\CaptionController@updateSegment
Middleware
api auth:sanctum account.status.api role.api:tutor
Auth
Required
Request
Path params
segment: string
Query params
None
Body fields
None
Responses
Status
200 
{
    "example": {
        "success": "<boolean>",
        "segment": "<object>"
    }
}
cURL Example
curl -X PATCH "{{BASE_URL}}/api/tutor/captions/segments/{segment}" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\Tutor\CourseController@index
Middleware
api auth:sanctum account.status.api role.api:tutor
Auth
Required
Request
Path params
None
Query params
search: string subject: string level: string status: string
Body fields
None
Responses
Status
200 
{
    "example": {
        "success": "<boolean>",
        "courses": "<object>"
    }
}
cURL Example
curl -X GET "{{BASE_URL}}/api/tutor/courses?search=%3Cvalue%3E&subject=%3Cvalue%3E&level=%3Cvalue%3E&status=%3Cvalue%3E" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\Tutor\CourseController@store
Middleware
api auth:sanctum account.status.api role.api:tutor
Auth
Required
Request
Path params
None
Query params
None
Body fields
Field Type Required Rules
title string Yes required|string|max:255
description string No nullable|string
subject_id string Yes required|exists:subjects,id
level_id string Yes required|exists:levels,id
thumbnail_url file No nullable|image|max:2048
access_type boolean Yes required|boolean
Content type: multipart/form-data
Responses
Status
201 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>",
        "data": "<object>"
    }
}
Status
500 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>"
    }
}
Status
422 
{
    "message": "The given data was invalid.",
    "errors": {
        "field": [
            "validation_rule_failed"
        ]
    }
}
cURL Example
curl -X POST "{{BASE_URL}}/api/tutor/courses" \
+  -H "Authorization: Bearer <API_TOKEN>" \
+  -F "title=<value>" \
+  -F "description=<value>" \
+  -F "subject_id=<value>" \
+  -F "level_id=<value>" \
+  -F "thumbnail_url=@/path/to/thumbnail_url.bin" \
+  -F "access_type=<value>"

Endpoint
Controller
App\Http\Controllers\API\Tutor\CourseController@destroy
Middleware
api auth:sanctum account.status.api role.api:tutor
Auth
Required
Request
Path params
course: string
Query params
None
Body fields
None
Responses
Status
403 
{
    "example": {
        "message": "<string>"
    }
}
Status
422 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>"
    }
}
Status
200 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>"
    }
}
cURL Example
curl -X DELETE "{{BASE_URL}}/api/tutor/courses/{course}" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\Tutor\CourseController@show
Middleware
api auth:sanctum account.status.api role.api:tutor
Auth
Required
Request
Path params
course: string
Query params
None
Body fields
None
Responses
Status
200 
{
    "example": {
        "success": "<boolean>",
        "course": "<array>"
    }
}
Status
404 
{
    "success": false,
    "message": "The requested resource was not found."
}
cURL Example
curl -X GET "{{BASE_URL}}/api/tutor/courses/{course}" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\Tutor\CourseController@update
Middleware
api auth:sanctum account.status.api role.api:tutor
Auth
Required
Request
Path params
course: string
Query params
None
Body fields
Field Type Required Rules
title string Yes required|string|max:255
description string No nullable|string
subject_id string Yes required|exists:subjects,id
level_id string Yes required|exists:levels,id
thumbnail_url file No nullable|image|max:2048
access_type boolean Yes required|boolean
Content type: multipart/form-data
Responses
Status
403 
{
    "example": {
        "message": "<string>"
    }
}
Status
200 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>",
        "data": "<object>"
    }
}
Status
500 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>"
    }
}
Status
422 
{
    "message": "The given data was invalid.",
    "errors": {
        "field": [
            "validation_rule_failed"
        ]
    }
}
cURL Example
curl -X PUT "{{BASE_URL}}/api/tutor/courses/{course}" \
+  -H "Authorization: Bearer <API_TOKEN>" \
+  -F "title=<value>" \
+  -F "description=<value>" \
+  -F "subject_id=<value>" \
+  -F "level_id=<value>" \
+  -F "thumbnail_url=@/path/to/thumbnail_url.bin" \
+  -F "access_type=<value>"

Endpoint
Controller
App\Http\Controllers\API\Tutor\CourseController@publish
Middleware
api auth:sanctum account.status.api role.api:tutor
Auth
Required
Request
Path params
course: string
Query params
None
Body fields
None
Responses
Status
403 
{
    "example": {
        "message": "<string>"
    }
}
Status
422 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>"
    }
}
Status
200 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>"
    }
}
cURL Example
curl -X POST "{{BASE_URL}}/api/tutor/courses/{course}/publish" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\Tutor\TutorDashboardController@stats
Middleware
api auth:sanctum account.status.api role.api:tutor
Auth
Required
Request
Path params
None
Query params
None
Body fields
None
Responses
Status
200 
{
    "example": {
        "status": "<boolean>",
        "data": "<array>"
    }
}
cURL Example
curl -X GET "{{BASE_URL}}/api/tutor/dashboard-stats" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\Tutor\LessonController@index
Middleware
api auth:sanctum account.status.api role.api:tutor
Auth
Required
Request
Path params
None
Query params
chapter_id: string status: string
Body fields
None
Responses
Status
200 
{
    "example": {
        "success": "<boolean>",
        "lessons": "<object>"
    }
}
cURL Example
curl -X GET "{{BASE_URL}}/api/tutor/lessons?chapter_id=%3Cvalue%3E&status=%3Cvalue%3E" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\Tutor\LessonController@store
Middleware
api auth:sanctum account.status.api role.api:tutor
Auth
Required
Request
Path params
None
Query params
None
Body fields
Field Type Required Rules
chapter_id string Yes required|exists:chapters,id
title string Yes required|string|max:255
description string No nullable|string
video file Yes required_without:video_key|nullable|file|mimes:mp4,mov,avi|max:2048000
video_key string Yes required_without:video|nullable|string|regex:/^lessons\/videos\//
video_duration integer No nullable|integer
resource file No nullable|file|mimes:pdf|max:10240
resource_key string No nullable|string|regex:/^lessons\/resources\//
is_review boolean No nullable|boolean
Content type: multipart/form-data
Responses
Status
403 
{
    "example": {
        "message": "<string>"
    }
}
Status
201 
{
    "example": {
        "success": "<boolean>",
        "message": "<object>",
        "data": "<object>"
    }
}
Status
500 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>"
    }
}
Status
422 
{
    "message": "The given data was invalid.",
    "errors": {
        "field": [
            "validation_rule_failed"
        ]
    }
}
cURL Example
curl -X POST "{{BASE_URL}}/api/tutor/lessons" \
+  -H "Authorization: Bearer <API_TOKEN>" \
+  -F "chapter_id=<value>" \
+  -F "title=<value>" \
+  -F "description=<value>" \
+  -F "video=@/path/to/video.bin" \
+  -F "video_key=<value>" \
+  -F "video_duration=<value>" \
+  -F "resource=@/path/to/resource.bin" \
+  -F "resource_key=<value>" \
+  -F "is_review=<value>"

Endpoint
Controller
App\Http\Controllers\API\Tutor\LessonController@uploadInit
Middleware
api auth:sanctum account.status.api role.api:tutor
Auth
Required
Request
Path params
None
Query params
None
Body fields
Field Type Required Rules
filename string Yes required|string|max:255
content_type string Yes required|string|max:100
kind string Yes required|in:video,resource
chapter_id integer Yes required|integer|exists:chapters,id
Content type: application/json
Responses
Status
422 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>"
    }
}
Status
200 
{
    "example": {
        "success": "<boolean>",
        "key": "<object>",
        "upload_url": "<object>",
        "headers": "<value>",
        "expires_at": "<value>"
    }
}
cURL Example
curl -X POST "{{BASE_URL}}/api/tutor/lessons/upload-init" \
  -H "Authorization: Bearer <API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"filename":"<value>","content_type":"<value>","kind":"<value>","chapter_id":0}'

Endpoint
Controller
App\Http\Controllers\API\Tutor\LessonController@destroy
Middleware
api auth:sanctum account.status.api role.api:tutor
Auth
Required
Request
Path params
lesson: string
Query params
None
Body fields
None
Responses
Status
403 
{
    "example": {
        "message": "<string>"
    }
}
Status
200 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>"
    }
}
cURL Example
curl -X DELETE "{{BASE_URL}}/api/tutor/lessons/{lesson}" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\Tutor\LessonController@show
Middleware
api auth:sanctum account.status.api role.api:tutor
Auth
Required
Request
Path params
lesson: string
Query params
None
Body fields
None
Responses
Status
403 
{
    "example": {
        "message": "<string>"
    }
}
Status
200 
{
    "example": {
        "success": "<boolean>",
        "data": "<array>"
    }
}
cURL Example
curl -X GET "{{BASE_URL}}/api/tutor/lessons/{lesson}" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\Tutor\LessonController@update
Middleware
api auth:sanctum account.status.api role.api:tutor
Auth
Required
Request
Path params
lesson: string
Query params
None
Body fields
Field Type Required Rules
chapter_id string Yes required|exists:chapters,id
title string Yes required|string|max:255
description string No nullable|string
video file No nullable|file|mimes:mp4,mov,avi|max:2048000
video_key string No nullable|string|regex:/^lessons\/videos\//
video_duration integer No nullable|integer
resource file No nullable|file|mimes:pdf|max:10240
resource_key string No nullable|string|regex:/^lessons\/resources\//
is_review boolean No nullable|boolean
Content type: multipart/form-data
Responses
Status
403 
{
    "example": {
        "message": "<string>"
    }
}
Status
200 
{
    "example": {
        "success": "<boolean>",
        "message": "<object>",
        "data": "<object>"
    }
}
Status
500 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>"
    }
}
Status
422 
{
    "message": "The given data was invalid.",
    "errors": {
        "field": [
            "validation_rule_failed"
        ]
    }
}
cURL Example
curl -X PUT "{{BASE_URL}}/api/tutor/lessons/{lesson}" \
+  -H "Authorization: Bearer <API_TOKEN>" \
+  -F "chapter_id=<value>" \
+  -F "title=<value>" \
+  -F "description=<value>" \
+  -F "video=@/path/to/video.bin" \
+  -F "video_key=<value>" \
+  -F "video_duration=<value>" \
+  -F "resource=@/path/to/resource.bin" \
+  -F "resource_key=<value>" \
+  -F "is_review=<value>"

Endpoint
Controller
App\Http\Controllers\API\Tutor\CaptionController@show
Middleware
api auth:sanctum account.status.api role.api:tutor
Auth
Required
Request
Path params
lesson: string
Query params
None
Body fields
None
Responses
Status
200 
{
    "example": {
        "success": "<boolean>",
        "caption": "<value>",
        "segments": "<array>"
    }
}
cURL Example
curl -X GET "{{BASE_URL}}/api/tutor/lessons/{lesson}/captions" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\Tutor\CaptionController@update
Middleware
api auth:sanctum account.status.api role.api:tutor
Auth
Required
Request
Path params
lesson: string
Query params
None
Body fields
Field Type Required Rules
language string Yes required|string|in:en|ms|zh
Content type: application/json
Responses
Status
404 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>"
    }
}
Status
200 
{
    "example": {
        "success": "<boolean>",
        "caption": "<object>"
    }
}
Status
422 
{
    "message": "The given data was invalid.",
    "errors": {
        "field": [
            "validation_rule_failed"
        ]
    }
}
cURL Example
curl -X PATCH "{{BASE_URL}}/api/tutor/lessons/{lesson}/captions" \
  -H "Authorization: Bearer <API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"language":"<value>"}'

Endpoint
Controller
App\Http\Controllers\API\Tutor\CaptionController@publish
Middleware
api auth:sanctum account.status.api role.api:tutor
Auth
Required
Request
Path params
lesson: string
Query params
None
Body fields
None
Responses
Status
422 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>"
    }
}
Status
200 
{
    "example": {
        "success": "<boolean>",
        "caption": "<object>"
    }
}
cURL Example
curl -X POST "{{BASE_URL}}/api/tutor/lessons/{lesson}/captions/publish" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\Tutor\CaptionController@revertSegment
Middleware
api auth:sanctum account.status.api role.api:tutor
Auth
Required
Request
Path params
lesson: string segment: string
Query params
None
Body fields
None
Responses
Status
422 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>"
    }
}
Status
200 
{
    "example": {
        "success": "<boolean>",
        "segment": "<object>"
    }
}
cURL Example
curl -X POST "{{BASE_URL}}/api/tutor/lessons/{lesson}/captions/revert-segment/{segment}" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\Tutor\CaptionController@transcribe
Middleware
api auth:sanctum account.status.api role.api:tutor
Auth
Required
Request
Path params
lesson: string
Query params
None
Body fields
None
Responses
Status
409 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>",
        "caption_status": "<object>"
    }
}
Status
422 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>",
        "caption_status": "<object>"
    }
}
Status
200 
{
    "example": {
        "success": "<boolean>",
        "caption": "<object>"
    }
}
cURL Example
curl -X POST "{{BASE_URL}}/api/tutor/lessons/{lesson}/captions/transcribe" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\Tutor\LessonController@publish
Middleware
api auth:sanctum account.status.api role.api:tutor
Auth
Required
Request
Path params
lesson: string
Query params
None
Body fields
None
Responses
Status
403 
{
    "example": {
        "message": "<string>"
    }
}
Status
200 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>"
    }
}
cURL Example
curl -X POST "{{BASE_URL}}/api/tutor/lessons/{lesson}/publish" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\Backend\LiveClassController@index
Middleware
api auth:sanctum account.status.api role.api:tutor
Auth
Required
Request
Path params
None
Query params
date: string tutor_id: string course_id: string status: string
Body fields
None
Responses
Status
200 
{
    "example": {
        "status": "<boolean>",
        "message": "<string>",
        "data": "<object>"
    }
}
Status
500 
{
    "example": {
        "status": "<boolean>",
        "message": "<object>",
        "error": "<object>"
    }
}
cURL Example
curl -X GET "{{BASE_URL}}/api/tutor/live-classes?date=%3Cvalue%3E&tutor_id=%3Cvalue%3E&course_id=%3Cvalue%3E&status=%3Cvalue%3E" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\Backend\LiveClassController@store
Middleware
api auth:sanctum account.status.api role.api:tutor
Auth
Required
Request
Path params
None
Query params
None
Body fields
Field Type Required Rules
title string Yes required|string|max:255
course_id string Yes required|exists:courses,id
scheduled_at date Yes required|date|after:now
duration integer Yes required|integer|min:1
description string No nullable|string
Content type: application/json
Responses
Status
201 
{
    "example": {
        "status": "<boolean>",
        "message": "<string>",
        "data": "<object>"
    }
}
Status
500 
{
    "example": {
        "status": "<boolean>",
        "message": "<object>",
        "error": "<object>"
    }
}
Status
422 
{
    "message": "The given data was invalid.",
    "errors": {
        "field": [
            "validation_rule_failed"
        ]
    }
}
cURL Example
curl -X POST "{{BASE_URL}}/api/tutor/live-classes" \
  -H "Authorization: Bearer <API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"title":"<value>","course_id":"<value>","scheduled_at":"2026-01-01","duration":0,"description":"<value>"}'

Endpoint
Controller
App\Http\Controllers\Backend\LiveClassController@show
Middleware
api auth:sanctum account.status.api role.api:tutor
Auth
Required
Request
Path params
liveClass: string
Query params
None
Body fields
None
Responses
Status
403 
{
    "example": {
        "status": "<boolean>",
        "message": "<string>"
    }
}
Status
200 
{
    "example": {
        "status": "<boolean>",
        "message": "<string>",
        "data": "<array>"
    }
}
Status
500 
{
    "example": {
        "status": "<boolean>",
        "message": "<object>",
        "error": "<object>"
    }
}
cURL Example
curl -X GET "{{BASE_URL}}/api/tutor/live-classes/{liveClass}" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\Backend\LiveClassController@update
Middleware
api auth:sanctum account.status.api role.api:tutor
Auth
Required
Request
Path params
liveClass: string
Query params
None
Body fields
Field Type Required Rules
title string Yes required|string|max:255
course_id string Yes required|exists:courses,id
scheduled_at date Yes required|date|after:now
duration integer Yes required|integer|min:1
description string No nullable|string
Content type: application/json
Responses
Status
403 
{
    "example": {
        "status": "<boolean>",
        "message": "<string>"
    }
}
Status
400 
{
    "example": {
        "status": "<boolean>",
        "message": "<object>"
    }
}
Status
200 
{
    "example": {
        "status": "<boolean>",
        "message": "<string>",
        "data": "<object>"
    }
}
Status
500 
{
    "example": {
        "status": "<boolean>",
        "message": "<object>",
        "error": "<object>"
    }
}
Status
422 
{
    "message": "The given data was invalid.",
    "errors": {
        "field": [
            "validation_rule_failed"
        ]
    }
}
cURL Example
curl -X PUT "{{BASE_URL}}/api/tutor/live-classes/{liveClass}" \
  -H "Authorization: Bearer <API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"title":"<value>","course_id":"<value>","scheduled_at":"2026-01-01","duration":0,"description":"<value>"}'

Endpoint
Controller
App\Http\Controllers\Backend\LiveClassController@attendanceLog
Middleware
api auth:sanctum account.status.api role.api:tutor
Auth
Required
Request
Path params
liveClass: string
Query params
None
Body fields
None
Responses
Status
403 
{
    "example": {
        "status": "<boolean>",
        "message": "<string>"
    }
}
Status
200 
{
    "example": {
        "status": "<boolean>",
        "message": "<string>",
        "data": "<array>"
    }
}
Status
500 
{
    "example": {
        "status": "<boolean>",
        "message": "<object>",
        "error": "<object>"
    }
}
cURL Example
curl -X GET "{{BASE_URL}}/api/tutor/live-classes/{liveClass}/attendance-log" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\Backend\LiveClassController@cancel
Middleware
api auth:sanctum account.status.api role.api:tutor
Auth
Required
Request
Path params
liveClass: string
Query params
None
Body fields
None
Responses
Status
403 
{
    "example": {
        "status": "<boolean>",
        "message": "<string>"
    }
}
Status
400 
{
    "example": {
        "status": "<boolean>",
        "message": "<object>"
    }
}
Status
200 
{
    "example": {
        "status": "<boolean>",
        "message": "<string>",
        "data": "<object>"
    }
}
Status
500 
{
    "example": {
        "status": "<boolean>",
        "message": "<object>",
        "error": "<object>"
    }
}
Status
422 
{
    "message": "The given data was invalid.",
    "errors": {
        "field": [
            "validation_rule_failed"
        ]
    }
}
cURL Example
curl -X POST "{{BASE_URL}}/api/tutor/live-classes/{liveClass}/cancel" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\Backend\LiveClassController@edit
Middleware
api auth:sanctum account.status.api role.api:tutor
Auth
Required
Request
Path params
liveClass: string
Query params
None
Body fields
None
Responses
Status
403 
{
    "example": {
        "status": "<boolean>",
        "message": "<string>"
    }
}
Status
422 
{
    "example": {
        "status": "<boolean>",
        "message": "<string>"
    }
}
Status
200 
{
    "example": {
        "status": "<boolean>",
        "message": "<string>",
        "data": "<array>"
    }
}
Status
500 
{
    "example": {
        "status": "<boolean>",
        "message": "<string>"
    }
}
cURL Example
curl -X GET "{{BASE_URL}}/api/tutor/live-classes/{liveClass}/edit" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\Backend\LiveClassController@join
Middleware
api auth:sanctum account.status.api role.api:tutor
Auth
Required
Request
Path params
liveClass: string
Query params
None
Body fields
None
Responses
Status
400 
{
    "example": {
        "status": "<boolean>",
        "message": "<object>"
    }
}
Status
200 
{
    "example": {
        "status": "<boolean>",
        "message": "<string>",
        "data": "<array>"
    }
}
Status
500 
{
    "example": {
        "status": "<boolean>",
        "message": "<object>",
        "error": "<object>"
    }
}
cURL Example
curl -X GET "{{BASE_URL}}/api/tutor/live-classes/{liveClass}/join" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\Backend\LiveClassController@uploadRecording
Middleware
api auth:sanctum account.status.api role.api:tutor
Auth
Required
Request
Path params
liveClass: string
Query params
None
Body fields
Field Type Required Rules
chapter_id string Yes required|exists:chapters,id
title string Yes required|string|max:255
video file Yes required_without:video_key|nullable|file|mimes:mp4|max:2048000
video_key string Yes required_without:video|nullable|string|regex:/^lessons\/videos\//
recording_access string Yes required|in:premium_only,free_for_all
Content type: multipart/form-data
Responses
Status
403 
{
    "example": {
        "status": "<boolean>",
        "message": "<string>"
    }
}
Status
200 
{
    "example": {
        "status": "<boolean>",
        "message": "<string>",
        "lesson": "<object>"
    }
}
Status
500 
{
    "example": {
        "status": "<boolean>",
        "message": "<string>",
        "error": "<object>"
    }
}
Status
422 
{
    "message": "The given data was invalid.",
    "errors": {
        "field": [
            "validation_rule_failed"
        ]
    }
}
cURL Example
curl -X POST "{{BASE_URL}}/api/tutor/live-classes/{liveClass}/upload-recording" \
+  -H "Authorization: Bearer <API_TOKEN>" \
+  -F "chapter_id=<value>" \
+  -F "title=<value>" \
+  -F "video=@/path/to/video.bin" \
+  -F "video_key=<value>" \
+  -F "recording_access=<value>"

Endpoint
Controller
App\Http\Controllers\API\Tutor\QuizController@index
Middleware
api auth:sanctum account.status.api role.api:tutor
Auth
Required
Request
Path params
None
Query params
status: string
Body fields
None
Responses
Status
200 
{
    "example": {
        "success": "<boolean>",
        "data": "<object>"
    }
}
cURL Example
curl -X GET "{{BASE_URL}}/api/tutor/quizzes?status=%3Cvalue%3E" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\Tutor\QuizController@store
Middleware
api auth:sanctum account.status.api role.api:tutor
Auth
Required
Request
Path params
None
Query params
None
Body fields
Field Type Required Rules
lesson_id string Yes nullable|required_if:quiz_type,lesson_quiz|exists:lessons,id
chapter_ids array Yes nullable|required_if:quiz_type,exam_quiz|array|min:1
chapter_ids[] string No exists:chapters,id
title string Yes required|string|max:255
quiz_type string Yes required|in:lesson_quiz,exam_quiz
time_limit integer No nullable|integer|min:1|max:60
total_marks integer Yes required|integer|min:1
attempts_allowed integer Yes required|integer|min:1|max:3
show_results boolean No nullable|boolean
shuffle_questions boolean No nullable|boolean
questions array Yes required|array|min:5|max:20
questions[].text string Yes required
questions[].type string Yes required|in:mcq,true_false
questions[].correct string Yes required
questions[].topic_id integer No nullable|integer|exists:topics,id
Content type: application/json
Responses
Status
422 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>"
    }
}
Status
201 
{
    "example": {
        "success": "<boolean>",
        "message": "<object>",
        "data": "<object>"
    }
}
Status
500 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>"
    }
}
cURL Example
curl -X POST "{{BASE_URL}}/api/tutor/quizzes" \
  -H "Authorization: Bearer <API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"lesson_id":"<value>","chapter_ids":["<value>"],"title":"<value>","quiz_type":"<value>","time_limit":0,"total_marks":0,"attempts_allowed":0,"show_results":true,"shuffle_questions":true,"questions":[{"text":"<value>","type":"<value>","correct":"<value>","topic_id":0}]}'

Endpoint
Controller
App\Http\Controllers\API\Tutor\QuizController@destroy
Middleware
api auth:sanctum account.status.api role.api:tutor
Auth
Required
Request
Path params
quiz: string
Query params
None
Body fields
None
Responses
Status
200 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>"
    }
}
Status
500 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>"
    }
}
cURL Example
curl -X DELETE "{{BASE_URL}}/api/tutor/quizzes/{quiz}" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\Tutor\QuizController@show
Middleware
api auth:sanctum account.status.api role.api:tutor
Auth
Required
Request
Path params
quiz: string
Query params
None
Body fields
None
Responses
Status
403 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>"
    }
}
Status
200 
{
    "example": {
        "success": "<boolean>",
        "data": "<object>"
    }
}
cURL Example
curl -X GET "{{BASE_URL}}/api/tutor/quizzes/{quiz}" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\Tutor\QuizController@update
Middleware
api auth:sanctum account.status.api role.api:tutor
Auth
Required
Request
Path params
quiz: string
Query params
None
Body fields
Field Type Required Rules
lesson_id string No nullable|exists:lessons,id
chapter_ids array Yes nullable|required_if:quiz_type,exam_quiz|array|min:1
chapter_ids[] string No exists:chapters,id
title string Yes required|string|max:255
quiz_type string Yes required|in:lesson_quiz,exam_quiz
time_limit integer No nullable|integer|min:1|max:60
total_marks integer Yes required|integer|min:1
attempts_allowed integer Yes required|integer|min:1|max:3
questions array Yes required|array|min:5|max:20
questions[].text string Yes required
questions[].type string Yes required|in:mcq,true_false
questions[].correct string Yes required
questions[].topic_id integer No nullable|integer|exists:topics,id
Content type: application/json
Responses
Status
200 
{
    "example": {
        "success": "<boolean>",
        "message": "<object>",
        "data": "<object>"
    }
}
Status
500 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>"
    }
}
Status
422 
{
    "message": "The given data was invalid.",
    "errors": {
        "field": [
            "validation_rule_failed"
        ]
    }
}
Status
404 
{
    "success": false,
    "message": "The requested resource was not found."
}
cURL Example
curl -X PUT "{{BASE_URL}}/api/tutor/quizzes/{quiz}" \
  -H "Authorization: Bearer <API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"lesson_id":"<value>","chapter_ids":["<value>"],"title":"<value>","quiz_type":"<value>","time_limit":0,"total_marks":0,"attempts_allowed":0,"questions":[{"text":"<value>","type":"<value>","correct":"<value>","topic_id":0}]}'

Endpoint
Controller
App\Http\Controllers\API\Tutor\QuizController@publish
Middleware
api auth:sanctum account.status.api role.api:tutor
Auth
Required
Request
Path params
quiz: string
Query params
None
Body fields
None
Responses
No explicit responses found in source code.
cURL Example
curl -X POST "{{BASE_URL}}/api/tutor/quizzes/{quiz}/publish" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\Tutor\TutorStudentController@index
Middleware
api auth:sanctum account.status.api role.api:tutor
Auth
Required
Request
Path params
None
Query params
None
Body fields
None
Responses
Status
200 
{
    "example": {
        "status": "<boolean>",
        "message": "<string>",
        "data": "<object>"
    }
}
cURL Example
curl -X GET "{{BASE_URL}}/api/tutor/students" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\Tutor\TutorStudentController@studentResults
Middleware
api auth:sanctum account.status.api role.api:tutor
Auth
Required
Request
Path params
None
Query params
None
Body fields
None
Responses
Status
200 
{
    "example": {
        "status": "<boolean>",
        "message": "<string>",
        "data": "<object>",
        "filters": "<array>"
    }
}
cURL Example
curl -X GET "{{BASE_URL}}/api/tutor/students/quiz-results" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\Tutor\TutorStudentController@show
Middleware
api auth:sanctum account.status.api role.api:tutor
Auth
Required
Request
Path params
student: string
Query params
None
Body fields
None
Responses
Status
403 
{
    "example": {
        "message": "<string>"
    }
}
Status
200 
{
    "example": {
        "status": "<boolean>",
        "message": "<string>",
        "data": "<array>"
    }
}
cURL Example
curl -X GET "{{BASE_URL}}/api/tutor/students/{student}" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\Tutor\TopicController@index
Middleware
api auth:sanctum account.status.api role.api:tutor
Auth
Required
Request
Path params
None
Query params
subject_id: string search: string
Body fields
None
Responses
Status
200 
{
    "example": {
        "data": "<object>"
    }
}
cURL Example
curl -X GET "{{BASE_URL}}/api/tutor/topics?subject_id=%3Cvalue%3E&search=%3Cvalue%3E" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\Tutor\TopicController@propose
Middleware
api auth:sanctum account.status.api role.api:tutor
Auth
Required
Request
Path params
None
Query params
None
Body fields
Field Type Required Rules
name string Yes required|string|max:120
parent_id integer No nullable|integer|Rule::exists('topics|id')->where('status|Topic::STATUS_APPROVED)
subject_id integer No nullable|integer|Rule::exists('subjects|id')
Content type: application/json
Responses
Status
422 
{
    "example": {
        "message": "<string>"
    }
}
Status
201 
{
    "example": {
        "data": "<object>"
    }
}
cURL Example
curl -X POST "{{BASE_URL}}/api/tutor/topics/propose" \
  -H "Authorization: Bearer <API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"name":"<value>","parent_id":0,"subject_id":0}'

Endpoint
Controller
App\Http\Controllers\Backend\TutorVerificationController@myVerification
Middleware
api auth:sanctum account.status.api role.api:tutor
Auth
Required
Request
Path params
None
Query params
None
Body fields
None
Responses
Status
200 
{
    "example": {
        "success": "<boolean>",
        "data": "<value>",
        "message": "<string>"
    }
}
cURL Example
curl -X GET "{{BASE_URL}}/api/tutor/verification" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\Backend\TutorVerificationController@store
Middleware
api auth:sanctum account.status.api role.api:tutor
Auth
Required
Request
Path params
None
Query params
levels: string subjects: string
Body fields
None
Responses
Status
400 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>"
    }
}
Status
422 
{
    "example": {
        "success": "<boolean>",
        "errors": "<object>"
    }
}
Status
201 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>",
        "data": "<object>"
    }
}
cURL Example
curl -X POST "{{BASE_URL}}/api/tutor/verification" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\Backend\TutorVerificationController@update
Middleware
api auth:sanctum account.status.api role.api:tutor
Auth
Required
Request
Path params
id: string
Query params
levels: string subjects: string
Body fields
None
Responses
Status
403 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>"
    }
}
Status
422 
{
    "example": {
        "success": "<boolean>",
        "errors": "<object>"
    }
}
Status
200 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>",
        "data": "<object>"
    }
}
Status
404 
{
    "success": false,
    "message": "The requested resource was not found."
}
cURL Example
curl -X PUT "{{BASE_URL}}/api/tutor/verification/{id}" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\Tutor\VideoQAController@index
Middleware
api auth:sanctum account.status.api role.api:tutor
Auth
Required
Request
Path params
None
Query params
filter: string course_id: string subject_id: string form_level: string
Body fields
None
Responses
Status
200 
{
    "example": {
        "success": "<boolean>",
        "filters": "<array>",
        "data": "<object>"
    }
}
cURL Example
curl -X GET "{{BASE_URL}}/api/tutor/video-qa?filter=%3Cvalue%3E&course_id=%3Cvalue%3E&subject_id=%3Cvalue%3E&form_level=%3Cvalue%3E" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\Tutor\VideoQAController@updateAnswer
Middleware
api auth:sanctum account.status.api role.api:tutor
Auth
Required
Request
Path params
answer: string
Query params
None
Body fields
Field Type Required Rules
answer_text string Yes required|string|min:1
Content type: application/json
Responses
Status
200 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>",
        "data": "<object>"
    }
}
Status
422 
{
    "message": "The given data was invalid.",
    "errors": {
        "field": [
            "validation_rule_failed"
        ]
    }
}
cURL Example
curl -X PUT "{{BASE_URL}}/api/tutor/video-qa/answers/{answer}" \
  -H "Authorization: Bearer <API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"answer_text":"<value>"}'

Endpoint
Controller
App\Http\Controllers\API\Tutor\VideoQAController@reply
Middleware
api auth:sanctum account.status.api role.api:tutor
Auth
Required
Request
Path params
answer: string
Query params
None
Body fields
Field Type Required Rules
reply_text string Yes required|string|min:1
Content type: application/json
Responses
Status
201 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>",
        "data": "<object>"
    }
}
Status
422 
{
    "message": "The given data was invalid.",
    "errors": {
        "field": [
            "validation_rule_failed"
        ]
    }
}
cURL Example
curl -X POST "{{BASE_URL}}/api/tutor/video-qa/answers/{answer}/reply" \
  -H "Authorization: Bearer <API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"reply_text":"<value>"}'

Endpoint
Controller
App\Http\Controllers\API\Tutor\VideoQAController@unflag
Middleware
api auth:sanctum account.status.api role.api:tutor
Auth
Required
Request
Path params
None
Query params
None
Body fields
Field Type Required Rules
flaggable_type string Yes required|in:video_question,video_answer
flaggable_id integer Yes required|integer
Content type: application/json
Responses
Status
404 
{
    "example": {
        "message": "<string>"
    }
}
Status
200 
{
    "example": {
        "message": "<string>"
    }
}
Status
422 
{
    "message": "The given data was invalid.",
    "errors": {
        "field": [
            "validation_rule_failed"
        ]
    }
}
cURL Example
curl -X DELETE "{{BASE_URL}}/api/tutor/video-qa/flag" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\Tutor\VideoQAController@flag
Middleware
api auth:sanctum account.status.api role.api:tutor
Auth
Required
Request
Path params
None
Query params
None
Body fields
Field Type Required Rules
flaggable_type string Yes required|in:video_question,video_answer
flaggable_id integer Yes required|integer
reason string No nullable|string|max:1000
Content type: application/json
Responses
Status
404 
{
    "example": {
        "message": "<string>"
    }
}
Status
201 
{
    "example": {
        "message": "<string>",
        "data": "<object>"
    }
}
Status
422 
{
    "message": "The given data was invalid.",
    "errors": {
        "field": [
            "validation_rule_failed"
        ]
    }
}
cURL Example
curl -X POST "{{BASE_URL}}/api/tutor/video-qa/flag" \
  -H "Authorization: Bearer <API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"flaggable_type":"<value>","flaggable_id":0,"reason":"<value>"}'

Endpoint
Controller
App\Http\Controllers\API\Tutor\VideoQAController@thread
Middleware
api auth:sanctum account.status.api role.api:tutor
Auth
Required
Request
Path params
question: string
Query params
None
Body fields
None
Responses
Status
200 
{
    "example": {
        "success": "<boolean>",
        "data": "<object>"
    }
}
cURL Example
curl -X GET "{{BASE_URL}}/api/tutor/video-qa/{question}" \
  -H "Authorization: Bearer <API_TOKEN>"

Endpoint
Controller
App\Http\Controllers\API\Tutor\VideoQAController@submitAnswer
Middleware
api auth:sanctum account.status.api role.api:tutor
Auth
Required
Request
Path params
question: string
Query params
None
Body fields
Field Type Required Rules
answer_text string Yes required|string
image file No nullable|image|mimes:jpeg,png,jpg,gif|max:5120
Content type: multipart/form-data
Responses
Status
201 
{
    "example": {
        "success": "<boolean>",
        "message": "<string>",
        "data": "<object>"
    }
}
Status
422 
{
    "message": "The given data was invalid.",
    "errors": {
        "field": [
            "validation_rule_failed"
        ]
    }
}
cURL Example
curl -X POST "{{BASE_URL}}/api/tutor/video-qa/{question}/answer" \
+  -H "Authorization: Bearer <API_TOKEN>" \
+  -F "answer_text=<value>" \
+  -F "image=@/path/to/image.bin"

Endpoint
Controller
App\Http\Controllers\API\Tutor\VideoQAController@togglePin
Middleware
api auth:sanctum account.status.api role.api:tutor
Auth
Required
Request
Path params
question: string
Query params
None
Body fields
None
Responses
Status
200 
{
    "example": {
        "success": "<boolean>",
        "message": "<object>",
        "data": "<object>"
    }
}
cURL Example
curl -X POST "{{BASE_URL}}/api/tutor/video-qa/{question}/toggle-pin" \
  -H "Authorization: Bearer <API_TOKEN>"