SDK Error Identifiers

Per-platform SDK error constants and their numeric identifiers, generated from the public SDK interface definitions.

Generated from the public SDK error-code definitions

Version v1.1.0 · Updated 2026-10-26 · revision 1

Agora error numbers visible to the SDK (numeric)

Client facades report failures as { code, sdkCode, message, retryable }, where sdkCode uses the negative Agora error numbers below, so applications migrating from Agora can keep their existing if (err === -110) checks. REST never returns negative values: sdkCode stores the positive absolute value, so compare by absolute value across layers.

sdkCode	Constant	Meaning
`0`	`ERR_OK`	Success
`-1`	`ERR_FAILED`	generic failure(fallback for unmapped cases)
`-2`	`ERR_INVALID_ARGUMENT`	invalid argument
`-3`	`ERR_NOT_READY`	SDK not ready yet
`-4`	`ERR_NOT_SUPPORTED`	this platform does not support this capability
`-5`	`ERR_REFUSED`	call rejected
`-7`	`ERR_NOT_INITIALIZED`	not initialized
`-8`	`ERR_INVALID_STATE`	the current state does not allow this operation
`-9`	`ERR_NO_PERMISSION`	no permission
`-10`	`ERR_TIMEDOUT`	Timeout
`-17`	`ERR_JOIN_CHANNEL_REJECTED`	join channel rejected
`-18`	`ERR_LEAVE_CHANNEL_REJECTED`	leave channel rejected
`-19`	`ERR_ALREADY_IN_USE`	already in a channel / resource in use
`-101`	`ERR_INVALID_APP_ID`	invalid App ID
`-102`	`ERR_INVALID_CHANNEL_NAME`	invalid channel name
`-103`	`ERR_NO_SERVER_RESOURCES`	server resources insufficient
`-109`	`ERR_TOKEN_EXPIRED`	Token expired
`-110`	`ERR_INVALID_TOKEN`	invalid Token
`-111`	`ERR_CONNECTION_INTERRUPTED`	connection interrupted(supports automatic reconnection)
`-112`	`ERR_CONNECTION_LOST`	connection lost(rejoin required)
`-113`	`ERR_NOT_IN_CHANNEL`	not in a channel

REST error code → SDK error number

The table is generated from the public error-code definition (42 rows); the same absolute value means the same error number.

REST code	HTTP	sdkCode (positive)	Matching negative constant	retryable
`collaborator_not_found`	404	-1	`ERR_FAILED`	false
`internal_error`	500	-1	`ERR_FAILED`	true
`outbox_not_found`	404	-1	`ERR_FAILED`	false
`project_exists`	409	-1	`ERR_FAILED`	false
`project_not_found`	404	-1	`ERR_FAILED`	false
`recording_not_found`	404	-1	`ERR_FAILED`	false
`recording_upstream_error`	502	-1	`ERR_FAILED`	true
`RTC_PROVIDER_DISABLED`	503	-1	`ERR_FAILED`	true
`service_not_enabled`	403	-1	`ERR_FAILED`	false
`streaming_not_found`	404	-1	`ERR_FAILED`	false
`streaming_upstream_error`	502	-1	`ERR_FAILED`	true
`webhook_not_found`	404	-1	`ERR_FAILED`	false
`invalid_parameter`	400	-2	`ERR_INVALID_ARGUMENT`	false
`RTC_TOKEN_INVALID_REQUEST`	400	-2	`ERR_INVALID_ARGUMENT`	false
`RTC_UID_MAPPING_INVALID_REQUEST`	400	-2	`ERR_INVALID_ARGUMENT`	false
`unsupported_media_type`	415	-4	`ERR_NOT_SUPPORTED`	false
`recording_invalid_state`	409	-8	`ERR_INVALID_STATE`	false
`streaming_invalid_state`	409	-8	`ERR_INVALID_STATE`	false
`unauthorized`	401	-9	`ERR_NO_PERMISSION`	false
`rate_limited`	429	-12	No matching constant	true
`banned`	403	-17	`ERR_JOIN_CHANNEL_REJECTED`	false
`join_rejected`	403	-17	`ERR_JOIN_CHANNEL_REJECTED`	false
`RTC_TOKEN_DENIED`	403	-17	`ERR_JOIN_CHANNEL_REJECTED`	false
`already_in_channel`	409	-19	`ERR_ALREADY_IN_USE`	false
`recording_quota_exceeded`	429	-22	No matching constant	true
`streaming_quota_exceeded`	429	-22	No matching constant	true
`app_disabled`	403	-101	`ERR_INVALID_APP_ID`	false
`invalid_appid`	401	-101	`ERR_INVALID_APP_ID`	false
`invalid_channel_name`	400	-102	`ERR_INVALID_CHANNEL_NAME`	false
`no_server_resources`	503	-103	`ERR_NO_SERVER_RESOURCES`	true
`token_expired`	401	-109	`ERR_TOKEN_EXPIRED`	false
`token_privilege_expired`	401	-109	`ERR_TOKEN_EXPIRED`	false
`invalid_credentials`	401	-110	`ERR_INVALID_TOKEN`	false
`invalid_token`	401	-110	`ERR_INVALID_TOKEN`	false
`missing_authorization`	401	-110	`ERR_INVALID_TOKEN`	false
`token_channel_mismatch`	401	-110	`ERR_INVALID_TOKEN`	false
`token_not_yet_valid`	401	-110	`ERR_INVALID_TOKEN`	false
`token_uid_mismatch`	401	-110	`ERR_INVALID_TOKEN`	false
`RTC_PROVIDER_UNAVAILABLE`	503	-111	`ERR_CONNECTION_INTERRUPTED`	true
`upstream_unavailable`	503	-111	`ERR_CONNECTION_INTERRUPTED`	true
`channel_not_found`	404	-113	`ERR_NOT_IN_CHANNEL`	false
`user_not_found`	404	-113	`ERR_NOT_IN_CHANNEL`	false

Facade-specific error codes (no Agora equivalent)

code	Meaning
`RTC_RECONNECTING`	The transport is reconnecting: show a “reconnecting” state and do not destroy tracks.
`RTC_PUBLISH_DENIED`	The server denied publishing (audience role, muted or banned).
`RTC_DEVICE_NOT_FOUND`	The capture device does not exist (no camera/microphone, or it is in use by another app).

Registered facadeCodes: RTC_RECONNECTING, RTC_PUBLISH_DENIED, RTC_DEVICE_NOT_FOUND.

Error constants and identifiers by platform

Each platform exposes errors differently: the Web SDK uses string identifiers (err.code === 'INVALID_PARAMS') and native SDKs use numeric constants (ERR_INVALID_ARGUMENT). The table is generated from each platform's public errorCodes definition.

Platform	Constant / identifier	Value
Web(browser)	`ADD_CANDIDATE_FAILED`	`ADD_CANDIDATE_FAILED`
Web(browser)	`API_INVOKE_TIMEOUT`	`API_INVOKE_TIMEOUT`
Web(browser)	`BEAUTY_PROCESSOR_INTERNAL_ERROR`	`BEAUTY_PROCESSOR_INTERNAL_ERROR`
Web(browser)	`CAN_NOT_GET_GATEWAY_SERVER`	`CAN_NOT_GET_GATEWAY_SERVER`
Web(browser)	`CAN_NOT_GET_PROXY_SERVER`	`CAN_NOT_GET_PROXY_SERVER`
Web(browser)	`CAN_NOT_PUBLISH_MULTIPLE_VIDEO_TRACKS`	`CAN_NOT_PUBLISH_MULTIPLE_VIDEO_TRACKS`
Web(browser)	`CHROME_PLUGIN_NO_RESPONSE`	`CHROME_PLUGIN_NO_RESPONSE`
Web(browser)	`CHROME_PLUGIN_NOT_INSTALL`	`CHROME_PLUGIN_NOT_INSTALL`
Web(browser)	`CONSTRAINT_NOT_SATISFIED`	`CONSTRAINT_NOT_SATISFIED`
Web(browser)	`CONVERTING_IMAGEDATA_TO_BLOB_FAILED`	`CONVERTING_IMAGEDATA_TO_BLOB_FAILED`
Web(browser)	`CONVERTING_VIDEO_FRAME_TO_BLOB_FAILED`	`CONVERTING_VIDEO_FRAME_TO_BLOB_FAILED`
Web(browser)	`CREATE_DATACHANNEL_ERROR`	`CREATE_DATACHANNEL_ERROR`
Web(browser)	`CREATE_OFFER_FAILED`	`CREATE_OFFER_FAILED`
Web(browser)	`CROSS_CHANNEL_FAILED_JOIN_DEST`	`CROSS_CHANNEL_FAILED_JOIN_DEST`
Web(browser)	`CROSS_CHANNEL_FAILED_JOIN_SRC`	`CROSS_CHANNEL_FAILED_JOIN_SEC`
Web(browser)	`CROSS_CHANNEL_FAILED_PACKET_SENT_TO_DEST`	`CROSS_CHANNEL_FAILED_PACKET_SENT_TO_DEST`
Web(browser)	`CROSS_CHANNEL_SERVER_ERROR_RESPONSE`	`CROSS_CHANNEL_SERVER_ERROR_RESPONSE`
Web(browser)	`CROSS_CHANNEL_WAIT_STATUS_ERROR`	`CROSS_CHANNEL_WAIT_STATUS_ERROR`
Web(browser)	`CUSTOM_REPORT_FREQUENCY_TOO_HIGH`	`CUSTOM_REPORT_FREQUENCY_TOO_HIGH`
Web(browser)	`CUSTOM_REPORT_SEND_FAILED`	`CUSTOM_REPORT_SEND_FAILED`
Web(browser)	`DATACHANNEL_CONNECTION_TIMEOUT`	`DATACHANNEL_CONNECTION_TIMEOUT`
Web(browser)	`DATACHANNEL_FAILED`	`DATACHANNEL_FAILED`
Web(browser)	`DECODE_AUDIO_FILE_FAILED`	`DECODE_AUDIO_FILE_FAILED`
Web(browser)	`DEVICE_NOT_FOUND`	`DEVICE_NOT_FOUND`
Web(browser)	`DISCONNECT_P2P`	`DISCONNECT_P2P`
Web(browser)	`ELECTRON_DESKTOP_CAPTURER_GET_SOURCES_ERROR`	`ELECTRON_DESKTOP_CAPTURER_GET_SOURCES_ERROR`
Web(browser)	`ELECTRON_IS_NULL`	`ELECTRON_IS_NULL`
Web(browser)	`ENUMERATE_DEVICES_FAILED`	`ENUMERATE_DEVICES_FAILED`
Web(browser)	`EXCHANGE_SDP_FAILED`	`EXCHANGE_SDP_FAILED`
Web(browser)	`EXIST_DISABLED_VIDEO_TRACK`	`EXIST_DISABLED_VIDEO_TRACK`
Web(browser)	`EXTERNAL_SIGNAL_ABORT`	`EXTERNAL_SIGNAL_ABORT`
Web(browser)	`FETCH_AUDIO_FILE_FAILED`	`FETCH_AUDIO_FILE_FAILED`
Web(browser)	`GATEWAY_P2P_LOST`	`GATEWAY_P2P_LOST`
Web(browser)	`GET_LOCAL_CAPABILITIES_FAILED`	`GET_LOCAL_CAPABILITIES_FAILED`
Web(browser)	`GET_LOCAL_CONNECTION_PARAMS_FAILED`	`GET_LOCAL_CONNECTION_PARAMS_FAILED`
Web(browser)	`GET_VIDEO_ELEMENT_VISIBLE_ERROR`	`GET_VIDEO_ELEMENT_VISIBLE_ERROR`
Web(browser)	`ICE_FAILED`	`ICE_FAILED`
Web(browser)	`IMAGE_MODERATION_UPLOAD_FAILED`	`IMAGE_MODERATION_UPLOAD_FAILED`
Web(browser)	`INIT_DATACHANNEL_TIMEOUT`	`INIT_DATACHANNEL_TIMEOUT`
Web(browser)	`INVALID_LOCAL_TRACK`	`INVALID_LOCAL_TRACK`
Web(browser)	`INVALID_OPERATION`	`INVALID_OPERATION`
Web(browser)	`INVALID_PARAMS`	`INVALID_PARAMS`
Web(browser)	`INVALID_PLUGIN`	`INVALID_PLUGIN`
Web(browser)	`INVALID_REMOTE_USER`	`INVALID_REMOTE_USER`
Web(browser)	`INVALID_TRACK`	`INVALID_TRACK`
Web(browser)	`INVALID_UINT_UID_FROM_STRING_UID`	`INVALID_UINT_UID_FROM_STRING_UID`
Web(browser)	`LIVE_STREAMING_CDN_ERROR`	`LIVE_STREAMING_CDN_ERROR`
Web(browser)	`LIVE_STREAMING_INTERNAL_SERVER_ERROR`	`LIVE_STREAMING_INTERNAL_SERVER_ERROR`
Web(browser)	`LIVE_STREAMING_INVALID_ARGUMENT`	`LIVE_STREAMING_INVALID_ARGUMENT`
Web(browser)	`LIVE_STREAMING_INVALID_RAW_STREAM`	`LIVE_STREAMING_INVALID_RAW_STREAM`
Web(browser)	`LIVE_STREAMING_PUBLISH_STREAM_NOT_AUTHORIZED`	`LIVE_STREAMING_PUBLISH_STREAM_NOT_AUTHORIZED`
Web(browser)	`LIVE_STREAMING_TASK_CONFLICT`	`LIVE_STREAMING_TASK_CONFLICT`
Web(browser)	`LIVE_STREAMING_TRANSCODING_NOT_SUPPORTED`	`LIVE_STREAMING_TRANSCODING_NOT_SUPPORTED`
Web(browser)	`LIVE_STREAMING_WARN_FAILED_LOAD_IMAGE`	`LIVE_STREAMING_WARN_FAILED_LOAD_IMAGE`
Web(browser)	`LIVE_STREAMING_WARN_FREQUENT_REQUEST`	`LIVE_STREAMING_WARN_FREQUENT_REQUEST`
Web(browser)	`LIVE_STREAMING_WARN_STREAM_NUM_REACH_LIMIT`	`LIVE_STREAMING_WARN_STREAM_NUM_REACH_LIMIT`
Web(browser)	`LOCAL_AEC_ERROR`	`LOCAL_AEC_ERROR`
Web(browser)	`LOW_STREAM_ENCODING_ERROR`	`LOW_STREAM_ENCODING_ERROR`
Web(browser)	`MEDIA_OPTION_INVALID`	`MEDIA_OPTION_INVALID`
Web(browser)	`METADATA_OUT_OF_RANGE`	`METADATA_OUT_OF_RANGE`
Web(browser)	`MULTI_UNILBS_RESPONSE_ERROR`	`MULTI_UNILBS_RESPONSE_ERROR`
Web(browser)	`NETWORK_ERROR`	`NETWORK_ERROR`
Web(browser)	`NETWORK_RESPONSE_ERROR`	`NETWORK_RESPONSE_ERROR`
Web(browser)	`NETWORK_TIMEOUT`	`NETWORK_TIMEOUT`
Web(browser)	`NO_ICE_CANDIDATE`	`NO_ICE_CANDIDATE`
Web(browser)	`NOT_READABLE`	`NOT_READABLE`
Web(browser)	`NOT_SUPPORTED`	`NOT_SUPPORTED`
Web(browser)	`OPERATION_ABORTED`	`OPERATION_ABORTED`
Web(browser)	`P2P_MESSAGE_FAILED`	`P2P_MESSAGE_FAILED`
Web(browser)	`PB_ERROR`	`PB_ERROR`
Web(browser)	`PC_CLOSED`	`PC_CLOSED`
Web(browser)	`PERMISSION_DENIED`	`PERMISSION_DENIED`
Web(browser)	`PROHIBITED_OPERATION`	`PROHIBITED_OPERATION`
Web(browser)	`READ_LOCAL_AUDIO_FILE_ERROR`	`READ_LOCAL_AUDIO_FILE_ERROR`
Web(browser)	`REMOTE_USER_IS_NOT_PUBLISHED`	`REMOTE_USER_IS_NOT_PUBLISHED`
Web(browser)	`SENDER_NOT_FOUND`	`SENDER_NOT_FOUND`
Web(browser)	`SENDER_REPLACE_FAILED`	`SENDER_REPLACE_FAILED`
Web(browser)	`SET_ANSWER_FAILED`	`SET_ANSWER_FAILED`
Web(browser)	`SET_ENCODING_PARAMETER_ERROR`	`SET_ENCODING_PARAMETER_ERROR`
Web(browser)	`SHARE_AUDIO_NOT_ALLOWED`	`SHARE_AUDIO_NOT_ALLOWED`
Web(browser)	`SUBSCRIBE_FAILED`	`SUBSCRIBE_FAILED`
Web(browser)	`TIMEOUT`	`TIMEOUT`
Web(browser)	`TOKEN_EXPIRE`	`TOKEN_EXPIRE`
Web(browser)	`TRACK_IS_DISABLED`	`TRACK_IS_DISABLED`
Web(browser)	`TRACK_STATE_UNREACHABLE`	`TRACK_STATE_UNREACHABLE`
Web(browser)	`UID_CONFLICT`	`UID_CONFLICT`
Web(browser)	`UNEXPECTED_ERROR`	`UNEXPECTED_ERROR`
Web(browser)	`UNEXPECTED_RESPONSE`	`UNEXPECTED_RESPONSE`
Web(browser)	`UNSUBSCRIBE_FAILED`	`UNSUBSCRIBE_FAILED`
Web(browser)	`UPDATE_TICKET_FAILED`	`UPDATE_TICKET_FAILED`
Web(browser)	`VOID_GATEWAY_ADDRESS`	`VOID_GATEWAY_ADDRESS`
Web(browser)	`WEB_SECURITY_RESTRICT`	`WEB_SECURITY_RESTRICT`
Web(browser)	`WEBGL_INTERNAL_ERROR`	`WEBGL_INTERNAL_ERROR`
Web(browser)	`WS_ABORT`	`WS_ABORT`
Web(browser)	`WS_DISCONNECT`	`WS_DISCONNECT`
Web(browser)	`WS_ERR`	`WS_ERR`
Electron(desktop)	`ErrAborted`	`20`
Electron(desktop)	`ErrAdmGeneralError`	`1005`
Electron(desktop)	`ErrAdmInitPlayout`	`1008`
Electron(desktop)	`ErrAdmInitRecording`	`1011`
Electron(desktop)	`ErrAdmStartPlayout`	`1009`
Electron(desktop)	`ErrAdmStartRecording`	`1012`
Electron(desktop)	`ErrAdmStopPlayout`	`1010`
Electron(desktop)	`ErrAdmStopRecording`	`1013`
Electron(desktop)	`ErrAlreadyInUse`	`19`
Electron(desktop)	`ErrBitrateLimit`	`115`
Electron(desktop)	`ErrBufferTooSmall`	`6`
Electron(desktop)	`ErrCertRaw`	`1001`
Electron(desktop)	`ErrClientIsBannedByServer`	`123`
Electron(desktop)	`ErrConnectionInterrupted`	`111`
Electron(desktop)	`ErrConnectionLost`	`112`
Electron(desktop)	`ErrDatastreamDecryptionFailed`	`122`
Electron(desktop)	`ErrDecryptionFailed`	`120`
Electron(desktop)	`ErrEncryptedStreamNotAllowedPublish`	`130`
Electron(desktop)	`ErrFailed`	`1`
Electron(desktop)	`ErrInitNetEngine`	`21`
Electron(desktop)	`ErrInvalidAppId`	`101`
Electron(desktop)	`ErrInvalidArgument`	`2`
Electron(desktop)	`ErrInvalidChannelName`	`102`
Electron(desktop)	`ErrInvalidState`	`8`
Electron(desktop)	`ErrInvalidToken`	`null`
Electron(desktop)	`ErrInvalidUserAccount`	`134`
Electron(desktop)	`ErrInvalidUserId`	`121`
Electron(desktop)	`ErrJoinChannelRejected`	`17`
Electron(desktop)	`ErrLeaveChannelRejected`	`18`
Electron(desktop)	`ErrNoPermission`	`9`
Electron(desktop)	`ErrNoServerResources`	`103`
Electron(desktop)	`ErrNotInChannel`	`113`
Electron(desktop)	`ErrNotInitialized`	`7`
Electron(desktop)	`ErrNotReady`	`3`
Electron(desktop)	`ErrNotSupported`	`4`
Electron(desktop)	`ErrOk`	`0`
Electron(desktop)	`ErrPcmsendBufferoverflow`	`201`
Electron(desktop)	`ErrPcmsendFormat`	`200`
Electron(desktop)	`ErrRefused`	`5`
Electron(desktop)	`ErrResourceLimited`	`22`
Electron(desktop)	`ErrSetClientRoleNotAuthorized`	`119`
Electron(desktop)	`ErrSizeTooLarge`	`114`
Electron(desktop)	`ErrStreamMessageTimeout`	`117`
Electron(desktop)	`ErrTimedout`	`10`
Electron(desktop)	`ErrTokenExpired`	`109`
Electron(desktop)	`ErrTooManyDataStreams`	`116`
Electron(desktop)	`ErrVdmCameraNotAuthorized`	`1501`
Electron(desktop)	`IRtcEngine`	`null`
Android	`AUTHENTICATION_FAILED`	`5`
Android	`INVALID_ARGUMENT`	`2`
Android	`INVALID_OPERATION`	`3`
Android	`NETWORK_ERROR`	`4`
Android	`OK`	`0`
Android	`STREAM_NOT_FOUND`	`6`
iOS	`AgoraErrorCodeAdmGeneralError`	`1005`
iOS	`AgoraErrorCodeAdmInitLoopback`	`1022`
iOS	`AgoraErrorCodeAdmInitPlayout`	`1008`
iOS	`AgoraErrorCodeAdmInitRecording`	`1011`
iOS	`AgoraErrorCodeAdmJavaResource`	`1006`
iOS	`AgoraErrorCodeAdmNoPlayoutDevice`	`1360`
iOS	`AgoraErrorCodeAdmNoRecordingDevice`	`1359`
iOS	`AgoraErrorCodeAdmPlayAbnormalFrequency`	`1020`
iOS	`AgoraErrorCodeAdmRecordAbnormalFrequency`	`1021`
iOS	`AgoraErrorCodeAdmRecordAudioFailed`	`1018`
iOS	`AgoraErrorCodeAdmRuntimePlayoutError`	`1015`
iOS	`AgoraErrorCodeAdmRuntimeRecordingError`	`1017`
iOS	`AgoraErrorCodeAdmSampleRate`	`1007`
iOS	`AgoraErrorCodeAdmStartLoopback`	`1023`
iOS	`AgoraErrorCodeAdmStartPlayout`	`1009`
iOS	`AgoraErrorCodeAdmStartRecording`	`1012`
iOS	`AgoraErrorCodeAdmStopPlayout`	`1010`
iOS	`AgoraErrorCodeAdmStopRecording`	`1013`
iOS	`AgoraErrorCodeAlreadyInUse`	`19`
iOS	`AgoraErrorCodeBitrateLimit`	`115`
iOS	`AgoraErrorCodeBufferTooSmall`	`6`
iOS	`AgoraErrorCodeConnectionInterrupted`	`111`
iOS	`AgoraErrorCodeConnectionLost`	`112`
iOS	`AgoraErrorCodeDecryptionFailed`	`120`
iOS	`AgoraErrorCodeEncryptedStreamNotAllowedPublish`	`130`
iOS	`AgoraErrorCodeFailed`	`1`
iOS	`AgoraErrorCodeInitNetEngine`	`21`
iOS	`AgoraErrorCodeInvalidAppId`	`101`
iOS	`AgoraErrorCodeInvalidArgument`	`2`
iOS	`AgoraErrorCodeInvalidChannelId`	`102`
iOS	`AgoraErrorCodeInvalidState`	`8`
iOS	`AgoraErrorCodeInvalidToken`	`110`
iOS	`AgoraErrorCodeInvalidUserAccount`	`134`
iOS	`AgoraErrorCodeJoinChannelRejected`	`17`
iOS	`AgoraErrorCodeLeaveChannelRejected`	`18`
iOS	`AgoraErrorCodeLoadMediaEngine`	`1001`
iOS	`AgoraErrorCodeNoError`	`0`
iOS	`AgoraErrorCodeNoServerResources`	`103`
iOS	`AgoraErrorCodeNotInChannel`	`113`
iOS	`AgoraErrorCodeNotInitialized`	`7`
iOS	`AgoraErrorCodeNotReady`	`3`
iOS	`AgoraErrorCodeNotSupported`	`4`
iOS	`AgoraErrorCodePcmSendBufferOverflow`	`201`
iOS	`AgoraErrorCodePcmSendFormat`	`200`
iOS	`AgoraErrorCodeResourceLimited`	`22`
iOS	`AgoraErrorCodeSizeTooLarge`	`114`
iOS	`AgoraErrorCodeStartCall`	`1002`
iOS	`AgoraErrorCodeStartCamera`	`1003`
iOS	`AgoraErrorCodeStartVideoRender`	`1004`
iOS	`AgoraErrorCodeTimedOut`	`10`
iOS	`AgoraErrorCodeTokenExpired`	`109`
iOS	`AgoraErrorCodeTooManyDataStreams`	`116`
iOS	`AgoraErrorCodeVcmEncoderEncodeError`	`1602`
iOS	`AgoraErrorCodeVcmEncoderInitError`	`1601`
iOS	`AgoraErrorCodeVcmEncoderSetError`	`1603`
iOS	`AgoraErrorCodeVcmUnknownError`	`1600`
iOS	`AgoraErrorCodeVdmCameraNotAuthorized`	`1501`
iOS	`AgoraErrorCodeVideoEffectAssetInvalid`	`1700`
iOS	`AgoraErrorCodeVideoEffectEngineInvalid`	`1702`
iOS	`AgoraErrorCodeVideoEffectInvalidBundlePath`	`1707`
iOS	`AgoraErrorCodeVideoEffectInvalidParam`	`1705`
iOS	`AgoraErrorCodeVideoEffectNodeNotActive`	`1704`
iOS	`AgoraErrorCodeVideoEffectNotSupported`	`1706`
iOS	`AgoraErrorCodeVideoEffectSaveFailed`	`1701`
iOS	`AgoraErrorCodeWatermarkAGRB`	`128`
iOS	`AgoraErrorCodeWatermarkInfo`	`127`
iOS	`AgoraErrorCodeWatermarkParam`	`124`
iOS	`AgoraErrorCodeWatermarkPath`	`125`
iOS	`AgoraErrorCodeWatermarkPng`	`126`
iOS	`AgoraErrorCodeWatermarkRead`	`129`
macOS	`AgoraErrorCodeAdmGeneralError`	`1005`
macOS	`AgoraErrorCodeAdmInitLoopback`	`1022`
macOS	`AgoraErrorCodeAdmInitPlayout`	`1008`
macOS	`AgoraErrorCodeAdmInitRecording`	`1011`
macOS	`AgoraErrorCodeAdmJavaResource`	`1006`
macOS	`AgoraErrorCodeAdmNoPlayoutDevice`	`1360`
macOS	`AgoraErrorCodeAdmNoRecordingDevice`	`1359`
macOS	`AgoraErrorCodeAdmPlayAbnormalFrequency`	`1020`
macOS	`AgoraErrorCodeAdmRecordAbnormalFrequency`	`1021`
macOS	`AgoraErrorCodeAdmRecordAudioFailed`	`1018`
macOS	`AgoraErrorCodeAdmRuntimePlayoutError`	`1015`
macOS	`AgoraErrorCodeAdmRuntimeRecordingError`	`1017`
macOS	`AgoraErrorCodeAdmSampleRate`	`1007`
macOS	`AgoraErrorCodeAdmStartLoopback`	`1023`
macOS	`AgoraErrorCodeAdmStartPlayout`	`1009`
macOS	`AgoraErrorCodeAdmStartRecording`	`1012`
macOS	`AgoraErrorCodeAdmStopPlayout`	`1010`
macOS	`AgoraErrorCodeAdmStopRecording`	`1013`
macOS	`AgoraErrorCodeAlreadyInUse`	`19`
macOS	`AgoraErrorCodeBitrateLimit`	`115`
macOS	`AgoraErrorCodeBufferTooSmall`	`6`
macOS	`AgoraErrorCodeConnectionInterrupted`	`111`
macOS	`AgoraErrorCodeConnectionLost`	`112`
macOS	`AgoraErrorCodeDecryptionFailed`	`120`
macOS	`AgoraErrorCodeEncryptedStreamNotAllowedPublish`	`130`
macOS	`AgoraErrorCodeFailed`	`1`
macOS	`AgoraErrorCodeInitNetEngine`	`21`
macOS	`AgoraErrorCodeInvalidAppId`	`101`
macOS	`AgoraErrorCodeInvalidArgument`	`2`
macOS	`AgoraErrorCodeInvalidChannelId`	`102`
macOS	`AgoraErrorCodeInvalidState`	`8`
macOS	`AgoraErrorCodeInvalidToken`	`110`
macOS	`AgoraErrorCodeInvalidUserAccount`	`134`
macOS	`AgoraErrorCodeJoinChannelRejected`	`17`
macOS	`AgoraErrorCodeLeaveChannelRejected`	`18`
macOS	`AgoraErrorCodeLoadMediaEngine`	`1001`
macOS	`AgoraErrorCodeNoError`	`0`
macOS	`AgoraErrorCodeNoServerResources`	`103`
macOS	`AgoraErrorCodeNotInChannel`	`113`
macOS	`AgoraErrorCodeNotInitialized`	`7`
macOS	`AgoraErrorCodeNotReady`	`3`
macOS	`AgoraErrorCodeNotSupported`	`4`
macOS	`AgoraErrorCodePcmSendBufferOverflow`	`201`
macOS	`AgoraErrorCodePcmSendFormat`	`200`
macOS	`AgoraErrorCodeResourceLimited`	`22`
macOS	`AgoraErrorCodeSizeTooLarge`	`114`
macOS	`AgoraErrorCodeStartCall`	`1002`
macOS	`AgoraErrorCodeStartCamera`	`1003`
macOS	`AgoraErrorCodeStartVideoRender`	`1004`
macOS	`AgoraErrorCodeTimedOut`	`10`
macOS	`AgoraErrorCodeTokenExpired`	`109`
macOS	`AgoraErrorCodeTooManyDataStreams`	`116`
macOS	`AgoraErrorCodeVcmEncoderEncodeError`	`1602`
macOS	`AgoraErrorCodeVcmEncoderInitError`	`1601`
macOS	`AgoraErrorCodeVcmEncoderSetError`	`1603`
macOS	`AgoraErrorCodeVcmUnknownError`	`1600`
macOS	`AgoraErrorCodeVdmCameraNotAuthorized`	`1501`
macOS	`AgoraErrorCodeVideoEffectAssetInvalid`	`1700`
macOS	`AgoraErrorCodeVideoEffectEngineInvalid`	`1702`
macOS	`AgoraErrorCodeVideoEffectInvalidBundlePath`	`1707`
macOS	`AgoraErrorCodeVideoEffectInvalidParam`	`1705`
macOS	`AgoraErrorCodeVideoEffectNodeNotActive`	`1704`
macOS	`AgoraErrorCodeVideoEffectNotSupported`	`1706`
macOS	`AgoraErrorCodeVideoEffectSaveFailed`	`1701`
macOS	`AgoraErrorCodeWatermarkAGRB`	`128`
macOS	`AgoraErrorCodeWatermarkInfo`	`127`
macOS	`AgoraErrorCodeWatermarkParam`	`124`
macOS	`AgoraErrorCodeWatermarkPath`	`125`
macOS	`AgoraErrorCodeWatermarkPng`	`126`
macOS	`AgoraErrorCodeWatermarkRead`	`129`
Windows（C++）	`ERR_ABORTED`	`20`
Windows（C++）	`ERR_ADM_GENERAL_ERROR`	`1005`
Windows（C++）	`ERR_ADM_INIT_PLAYOUT`	`1008`
Windows（C++）	`ERR_ADM_INIT_RECORDING`	`1011`
Windows（C++）	`ERR_ADM_START_PLAYOUT`	`1009`
Windows（C++）	`ERR_ADM_START_RECORDING`	`1012`
Windows（C++）	`ERR_ADM_STOP_PLAYOUT`	`1010`
Windows（C++）	`ERR_ADM_STOP_RECORDING`	`1013`
Windows（C++）	`ERR_ALREADY_IN_USE`	`19`
Windows（C++）	`ERR_BIND_SOCKET`	`13`
Windows（C++）	`ERR_BITRATE_LIMIT`	`115`
Windows（C++）	`ERR_BUFFER_TOO_SMALL`	`6`
Windows（C++）	`ERR_CANCELED`	`11`
Windows（C++）	`ERR_CLIENT_IS_BANNED_BY_SERVER`	`123`
Windows（C++）	`ERR_CONNECTION_INTERRUPTED`	`111`
Windows（C++）	`ERR_CONNECTION_LOST`	`112`
Windows（C++）	`ERR_DATASTREAM_DECRYPTION_FAILED`	`122`
Windows（C++）	`ERR_DECRYPTION_FAILED`	`120`
Windows（C++）	`ERR_ENCRYPTED_STREAM_NOT_ALLOWED_PUBLISH`	`130`
Windows（C++）	`ERR_FAILED`	`1`
Windows（C++）	`ERR_INIT_NET_ENGINE`	`21`
Windows（C++）	`ERR_INVALID_ARGUMENT`	`2`
Windows（C++）	`ERR_INVALID_CHANNEL_NAME`	`102`
Windows（C++）	`ERR_INVALID_STATE`	`8`
Windows（C++）	`ERR_INVALID_TOKEN`	`110`
Windows（C++）	`ERR_INVALID_USER_ID`	`121`
Windows（C++）	`ERR_JOIN_CHANNEL_REJECTED`	`17`
Windows（C++）	`ERR_LEAVE_CHANNEL_REJECTED`	`18`
Windows（C++）	`ERR_LOAD_MEDIA_ENGINE`	`1001`
Windows（C++）	`ERR_NET_DOWN`	`14`
Windows（C++）	`ERR_NO_PERMISSION`	`9`
Windows（C++）	`ERR_NO_SERVER_RESOURCES`	`103`
Windows（C++）	`ERR_NOT_IN_CHANNEL`	`113`
Windows（C++）	`ERR_NOT_INITIALIZED`	`7`
Windows（C++）	`ERR_NOT_READY`	`3`
Windows（C++）	`ERR_NOT_SUPPORTED`	`4`
Windows（C++）	`ERR_OK`	`0`
Windows（C++）	`ERR_PCMSEND_BUFFEROVERFLOW`	`201`
Windows（C++）	`ERR_PCMSEND_FORMAT`	`200`
Windows（C++）	`ERR_REFUSED`	`5`
Windows（C++）	`ERR_RESOURCE_LIMITED`	`22`
Windows（C++）	`ERR_SET_CLIENT_ROLE_NOT_AUTHORIZED`	`119`
Windows（C++）	`ERR_SIZE_TOO_LARGE`	`114`
Windows（C++）	`ERR_STREAM_MESSAGE_TIMEOUT`	`117`
Windows（C++）	`ERR_TIMEDOUT`	`10`
Windows（C++）	`ERR_TOKEN_EXPIRED`	`109`
Windows（C++）	`ERR_TOO_MANY_DATA_STREAMS`	`116`
Windows（C++）	`ERR_TOO_OFTEN`	`12`
Windows（C++）	`ERR_VDM_CAMERA_NOT_AUTHORIZED`	`1501`
Flutter	`errAborted`	`20`
Flutter	`errAdmGeneralError`	`1005`
Flutter	`errAdmInitPlayout`	`1008`
Flutter	`errAdmInitRecording`	`1011`
Flutter	`errAdmStartPlayout`	`1009`
Flutter	`errAdmStartRecording`	`1012`
Flutter	`errAdmStopPlayout`	`1010`
Flutter	`errAdmStopRecording`	`1013`
Flutter	`errAlreadyInUse`	`19`
Flutter	`errBitrateLimit`	`115`
Flutter	`errBufferTooSmall`	`6`
Flutter	`errClientIsBannedByServer`	`123`
Flutter	`errConnectionInterrupted`	`111`
Flutter	`errConnectionLost`	`112`
Flutter	`errDatastreamDecryptionFailed`	`122`
Flutter	`errDecryptionFailed`	`120`
Flutter	`errEncryptedStreamNotAllowedPublish`	`130`
Flutter	`errFailed`	`1`
Flutter	`errInitNetEngine`	`21`
Flutter	`errInvalidAppId`	`101`
Flutter	`errInvalidArgument`	`2`
Flutter	`errInvalidChannelName`	`102`
Flutter	`errInvalidState`	`8`
Flutter	`errInvalidToken`	`null`
Flutter	`errInvalidUserAccount`	`134`
Flutter	`errInvalidUserId`	`121`
Flutter	`errJoinChannelRejected`	`17`
Flutter	`errLeaveChannelRejected`	`18`
Flutter	`errLoadMediaEngine`	`1001`
Flutter	`errNoPermission`	`9`
Flutter	`errNoServerResources`	`103`
Flutter	`errNotInChannel`	`113`
Flutter	`errNotInitialized`	`7`
Flutter	`errNotReady`	`3`
Flutter	`errNotSupported`	`4`
Flutter	`errOk`	`0`
Flutter	`errPcmsendBufferoverflow`	`201`
Flutter	`errPcmsendFormat`	`200`
Flutter	`errRefused`	`5`
Flutter	`errResourceLimited`	`22`
Flutter	`errSetClientRoleNotAuthorized`	`119`
Flutter	`errSizeTooLarge`	`114`
Flutter	`errStreamMessageTimeout`	`117`
Flutter	`errTimedout`	`10`
Flutter	`errTokenExpired`	`109`
Flutter	`errTooManyDataStreams`	`116`
Flutter	`errVdmCameraNotAuthorized`	`1501`
Flutter	`RtcEngine`	`null`
React Native	`ErrAborted`	`20`
React Native	`ErrAdmGeneralError`	`1005`
React Native	`ErrAdmInitPlayout`	`1008`
React Native	`ErrAdmInitRecording`	`1011`
React Native	`ErrAdmStartPlayout`	`1009`
React Native	`ErrAdmStartRecording`	`1012`
React Native	`ErrAdmStopPlayout`	`1010`
React Native	`ErrAdmStopRecording`	`1013`
React Native	`ErrAlreadyInUse`	`19`
React Native	`ErrBitrateLimit`	`115`
React Native	`ErrBufferTooSmall`	`6`
React Native	`ErrCertRaw`	`1001`
React Native	`ErrClientIsBannedByServer`	`123`
React Native	`ErrConnectionInterrupted`	`111`
React Native	`ErrConnectionLost`	`112`
React Native	`ErrDatastreamDecryptionFailed`	`122`
React Native	`ErrDecryptionFailed`	`120`
React Native	`ErrEncryptedStreamNotAllowedPublish`	`130`
React Native	`ErrFailed`	`1`
React Native	`ErrInitNetEngine`	`21`
React Native	`ErrInvalidAppId`	`101`
React Native	`ErrInvalidArgument`	`2`
React Native	`ErrInvalidChannelName`	`102`
React Native	`ErrInvalidState`	`8`
React Native	`ErrInvalidToken`	`null`
React Native	`ErrInvalidUserAccount`	`134`
React Native	`ErrInvalidUserId`	`121`
React Native	`ErrJoinChannelRejected`	`17`
React Native	`ErrLeaveChannelRejected`	`18`
React Native	`ErrNoPermission`	`9`
React Native	`ErrNoServerResources`	`103`
React Native	`ErrNotInChannel`	`113`
React Native	`ErrNotInitialized`	`7`
React Native	`ErrNotReady`	`3`
React Native	`ErrNotSupported`	`4`
React Native	`ErrOk`	`0`
React Native	`ErrPcmsendBufferoverflow`	`201`
React Native	`ErrPcmsendFormat`	`200`
React Native	`ErrRefused`	`5`
React Native	`ErrResourceLimited`	`22`
React Native	`ErrSetClientRoleNotAuthorized`	`119`
React Native	`ErrSizeTooLarge`	`114`
React Native	`ErrStreamMessageTimeout`	`117`
React Native	`ErrTimedout`	`10`
React Native	`ErrTokenExpired`	`109`
React Native	`ErrTooManyDataStreams`	`116`
React Native	`ErrVdmCameraNotAuthorized`	`1501`
React Native	`IRtcEngine`	`null`
Unity（C#）	`ERR_ABORTED`	`20`
Unity（C#）	`ERR_ADM_GENERAL_ERROR`	`1005`
Unity（C#）	`ERR_ADM_INIT_PLAYOUT`	`1008`
Unity（C#）	`ERR_ADM_INIT_RECORDING`	`1011`
Unity（C#）	`ERR_ADM_START_PLAYOUT`	`1009`
Unity（C#）	`ERR_ADM_START_RECORDING`	`1012`
Unity（C#）	`ERR_ADM_STOP_PLAYOUT`	`1010`
Unity（C#）	`ERR_ADM_STOP_RECORDING`	`1013`
Unity（C#）	`ERR_ALREADY_IN_USE`	`19`
Unity（C#）	`ERR_BITRATE_LIMIT`	`115`
Unity（C#）	`ERR_BUFFER_TOO_SMALL`	`6`
Unity（C#）	`ERR_CLIENT_IS_BANNED_BY_SERVER`	`123`
Unity（C#）	`ERR_CONNECTION_INTERRUPTED`	`111`
Unity（C#）	`ERR_CONNECTION_LOST`	`112`
Unity（C#）	`ERR_DATASTREAM_DECRYPTION_FAILED`	`122`
Unity（C#）	`ERR_DECRYPTION_FAILED`	`120`
Unity（C#）	`ERR_ENCRYPTED_STREAM_NOT_ALLOWED_PUBLISH`	`130`
Unity（C#）	`ERR_FAILED`	`1`
Unity（C#）	`ERR_INIT_NET_ENGINE`	`21`
Unity（C#）	`ERR_INVALID_APP_ID`	`101`
Unity（C#）	`ERR_INVALID_ARGUMENT`	`2`
Unity（C#）	`ERR_INVALID_CHANNEL_NAME`	`102`
Unity（C#）	`ERR_INVALID_STATE`	`8`
Unity（C#）	`ERR_INVALID_TOKEN`	`null`
Unity（C#）	`ERR_INVALID_USER_ACCOUNT`	`134`
Unity（C#）	`ERR_INVALID_USER_ID`	`121`
Unity（C#）	`ERR_JOIN_CHANNEL_REJECTED`	`17`
Unity（C#）	`ERR_LEAVE_CHANNEL_REJECTED`	`18`
Unity（C#）	`ERR_LOAD_MEDIA_ENGINE`	`1001`
Unity（C#）	`ERR_NO_PERMISSION`	`9`
Unity（C#）	`ERR_NO_SERVER_RESOURCES`	`103`
Unity（C#）	`ERR_NOT_IN_CHANNEL`	`113`
Unity（C#）	`ERR_NOT_INITIALIZED`	`7`
Unity（C#）	`ERR_NOT_READY`	`3`
Unity（C#）	`ERR_NOT_SUPPORTED`	`4`
Unity（C#）	`ERR_OK`	`0`
Unity（C#）	`ERR_PCMSEND_BUFFEROVERFLOW`	`201`
Unity（C#）	`ERR_PCMSEND_FORMAT`	`200`
Unity（C#）	`ERR_REFUSED`	`5`
Unity（C#）	`ERR_RESOURCE_LIMITED`	`22`
Unity（C#）	`ERR_SET_CLIENT_ROLE_NOT_AUTHORIZED`	`119`
Unity（C#）	`ERR_SIZE_TOO_LARGE`	`114`
Unity（C#）	`ERR_STREAM_MESSAGE_TIMEOUT`	`117`
Unity（C#）	`ERR_TIMEDOUT`	`10`
Unity（C#）	`ERR_TOKEN_EXPIRED`	`109`
Unity（C#）	`ERR_TOO_MANY_DATA_STREAMS`	`116`
Unity（C#）	`ERR_VDM_CAMERA_NOT_AUTHORIZED`	`1501`
Unity（C#）	`IRtcEngine`	`null`
Unreal Engine（C++）	`ERR_ABORTED`	`20`
Unreal Engine（C++）	`ERR_ADM_GENERAL_ERROR`	`1005`
Unreal Engine（C++）	`ERR_ADM_INIT_PLAYOUT`	`1008`
Unreal Engine（C++）	`ERR_ADM_INIT_RECORDING`	`1011`
Unreal Engine（C++）	`ERR_ADM_START_PLAYOUT`	`1009`
Unreal Engine（C++）	`ERR_ADM_START_RECORDING`	`1012`
Unreal Engine（C++）	`ERR_ADM_STOP_PLAYOUT`	`1010`
Unreal Engine（C++）	`ERR_ADM_STOP_RECORDING`	`1013`
Unreal Engine（C++）	`ERR_ALREADY_IN_USE`	`19`
Unreal Engine（C++）	`ERR_BITRATE_LIMIT`	`115`
Unreal Engine（C++）	`ERR_BUFFER_TOO_SMALL`	`6`
Unreal Engine（C++）	`ERR_CLIENT_IS_BANNED_BY_SERVER`	`123`
Unreal Engine（C++）	`ERR_CONNECTION_INTERRUPTED`	`111`
Unreal Engine（C++）	`ERR_CONNECTION_LOST`	`112`
Unreal Engine（C++）	`ERR_DATASTREAM_DECRYPTION_FAILED`	`122`
Unreal Engine（C++）	`ERR_DECRYPTION_FAILED`	`120`
Unreal Engine（C++）	`ERR_ENCRYPTED_STREAM_NOT_ALLOWED_PUBLISH`	`130`
Unreal Engine（C++）	`ERR_FAILED`	`1`
Unreal Engine（C++）	`ERR_INIT_NET_ENGINE`	`21`
Unreal Engine（C++）	`ERR_INVALID_APP_ID`	`101`
Unreal Engine（C++）	`ERR_INVALID_ARGUMENT`	`2`
Unreal Engine（C++）	`ERR_INVALID_CHANNEL_NAME`	`102`
Unreal Engine（C++）	`ERR_INVALID_STATE`	`8`
Unreal Engine（C++）	`ERR_INVALID_TOKEN`	`110`
Unreal Engine（C++）	`ERR_INVALID_USER_ACCOUNT`	`134`
Unreal Engine（C++）	`ERR_INVALID_USER_ID`	`121`
Unreal Engine（C++）	`ERR_JOIN_CHANNEL_REJECTED`	`17`
Unreal Engine（C++）	`ERR_LEAVE_CHANNEL_REJECTED`	`18`
Unreal Engine（C++）	`ERR_LOAD_MEDIA_ENGINE`	`1001`
Unreal Engine（C++）	`ERR_NO_PERMISSION`	`9`
Unreal Engine（C++）	`ERR_NO_SERVER_RESOURCES`	`103`
Unreal Engine（C++）	`ERR_NOT_IN_CHANNEL`	`113`
Unreal Engine（C++）	`ERR_NOT_INITIALIZED`	`7`
Unreal Engine（C++）	`ERR_NOT_READY`	`3`
Unreal Engine（C++）	`ERR_NOT_SUPPORTED`	`4`
Unreal Engine（C++）	`ERR_OK`	`0`
Unreal Engine（C++）	`ERR_REFUSED`	`5`
Unreal Engine（C++）	`ERR_RESOURCE_LIMITED`	`22`
Unreal Engine（C++）	`ERR_SET_CLIENT_ROLE_NOT_AUTHORIZED`	`119`
Unreal Engine（C++）	`ERR_SIZE_TOO_LARGE`	`114`
Unreal Engine（C++）	`ERR_STREAM_MESSAGE_TIMEOUT`	`117`
Unreal Engine（C++）	`ERR_TIMEDOUT`	`10`
Unreal Engine（C++）	`ERR_TOKEN_EXPIRED`	`109`
Unreal Engine（C++）	`ERR_TOO_MANY_DATA_STREAMS`	`116`
Unreal Engine（C++）	`ERR_VDM_CAMERA_NOT_AUTHORIZED`	`1501`
Unreal Engine（C++）	`IRtcEngine`	`null`
Unreal Engine（Blueprint）	`VT_ERR_INTERNAL`	`20`
Unreal Engine（Blueprint）	`VT_ERR_INVALID_IMAGE_PATH`	`3`
Unreal Engine（Blueprint）	`VT_ERR_INVALID_LAYOUT`	`5`
Unreal Engine（Blueprint）	`VT_ERR_INVALID_VIDEO_SOURCE_TYPE`	`2`
Unreal Engine（Blueprint）	`VT_ERR_UNSUPPORT_IMAGE_FORMAT`	`4`
Unreal Engine（Blueprint）	`VT_ERR_VIDEO_SOURCE_NOT_READY`	`1`
Cocos Creator	`BridgeUnavailable`	`null`
Cocos Creator	`NativeFailure`	`null`
Cocos Creator	`ProtocolError`	`null`
Cocos Creator	`Timeout`	`null`
C#（.NET）	`ERR_ABORTED`	`20`
C#（.NET）	`ERR_ADM_GENERAL_ERROR`	`1005`
C#（.NET）	`ERR_ADM_INIT_PLAYOUT`	`1008`
C#（.NET）	`ERR_ADM_INIT_RECORDING`	`1011`
C#（.NET）	`ERR_ADM_START_PLAYOUT`	`1009`
C#（.NET）	`ERR_ADM_START_RECORDING`	`1012`
C#（.NET）	`ERR_ADM_STOP_PLAYOUT`	`1010`
C#（.NET）	`ERR_ADM_STOP_RECORDING`	`1013`
C#（.NET）	`ERR_ALREADY_IN_USE`	`19`
C#（.NET）	`ERR_BITRATE_LIMIT`	`115`
C#（.NET）	`ERR_BUFFER_TOO_SMALL`	`6`
C#（.NET）	`ERR_CLIENT_IS_BANNED_BY_SERVER`	`123`
C#（.NET）	`ERR_CONNECTION_INTERRUPTED`	`111`
C#（.NET）	`ERR_CONNECTION_LOST`	`112`
C#（.NET）	`ERR_DATASTREAM_DECRYPTION_FAILED`	`122`
C#（.NET）	`ERR_DECRYPTION_FAILED`	`120`
C#（.NET）	`ERR_ENCRYPTED_STREAM_NOT_ALLOWED_PUBLISH`	`130`
C#（.NET）	`ERR_FAILED`	`1`
C#（.NET）	`ERR_INIT_NET_ENGINE`	`21`
C#（.NET）	`ERR_INVALID_APP_ID`	`101`
C#（.NET）	`ERR_INVALID_ARGUMENT`	`2`
C#（.NET）	`ERR_INVALID_CHANNEL_NAME`	`102`
C#（.NET）	`ERR_INVALID_STATE`	`8`
C#（.NET）	`ERR_INVALID_TOKEN`	`110`
C#（.NET）	`ERR_INVALID_USER_ACCOUNT`	`134`
C#（.NET）	`ERR_INVALID_USER_ID`	`121`
C#（.NET）	`ERR_JOIN_CHANNEL_REJECTED`	`17`
C#（.NET）	`ERR_LEAVE_CHANNEL_REJECTED`	`18`
C#（.NET）	`ERR_LOAD_MEDIA_ENGINE`	`1001`
C#（.NET）	`ERR_NO_PERMISSION`	`9`
C#（.NET）	`ERR_NO_SERVER_RESOURCES`	`103`
C#（.NET）	`ERR_NOT_IN_CHANNEL`	`113`
C#（.NET）	`ERR_NOT_INITIALIZED`	`7`
C#（.NET）	`ERR_NOT_READY`	`3`
C#（.NET）	`ERR_NOT_SUPPORTED`	`4`
C#（.NET）	`ERR_OK`	`0`
C#（.NET）	`ERR_REFUSED`	`5`
C#（.NET）	`ERR_RESOURCE_LIMITED`	`22`
C#（.NET）	`ERR_SET_CLIENT_ROLE_NOT_AUTHORIZED`	`119`
C#（.NET）	`ERR_SIZE_TOO_LARGE`	`114`
C#（.NET）	`ERR_STREAM_MESSAGE_TIMEOUT`	`117`
C#（.NET）	`ERR_TIMEDOUT`	`10`
C#（.NET）	`ERR_TOKEN_EXPIRED`	`109`
C#（.NET）	`ERR_TOO_MANY_DATA_STREAMS`	`116`
C#（.NET）	`ERR_VDM_CAMERA_NOT_AUTHORIZED`	`1501`
C#（.NET）	`IRtcEngine`	`null`
HarmonyOS（ArkTS）	`ERR_ABORTED`	`20`
HarmonyOS（ArkTS）	`ERR_ADM_GENERAL_ERROR`	`1005`
HarmonyOS（ArkTS）	`ERR_ADM_INIT_PLAYOUT`	`1008`
HarmonyOS（ArkTS）	`ERR_ADM_INIT_RECORDING`	`1011`
HarmonyOS（ArkTS）	`ERR_ADM_START_PLAYOUT`	`1009`
HarmonyOS（ArkTS）	`ERR_ADM_START_RECORDING`	`1012`
HarmonyOS（ArkTS）	`ERR_ADM_STOP_PLAYOUT`	`1010`
HarmonyOS（ArkTS）	`ERR_ADM_STOP_RECORDING`	`1013`
HarmonyOS（ArkTS）	`ERR_ALREADY_IN_USE`	`19`
HarmonyOS（ArkTS）	`ERR_BITRATE_LIMIT`	`115`
HarmonyOS（ArkTS）	`ERR_BUFFER_TOO_SMALL`	`6`
HarmonyOS（ArkTS）	`ERR_CONNECTION_INTERRUPTED`	`111`
HarmonyOS（ArkTS）	`ERR_CONNECTION_LOST`	`112`
HarmonyOS（ArkTS）	`ERR_DATASTREAM_DECRYPTION_FAILED`	`122`
HarmonyOS（ArkTS）	`ERR_DECRYPTION_FAILED`	`120`
HarmonyOS（ArkTS）	`ERR_ENCRYPTED_STREAM_NOT_ALLOWED_PUBLISH`	`130`
HarmonyOS（ArkTS）	`ERR_FAILED`	`1`
HarmonyOS（ArkTS）	`ERR_INIT_NET_ENGINE`	`21`
HarmonyOS（ArkTS）	`ERR_INVALID_APP_ID`	`101`
HarmonyOS（ArkTS）	`ERR_INVALID_ARGUMENT`	`2`
HarmonyOS（ArkTS）	`ERR_INVALID_CHANNEL_NAME`	`102`
HarmonyOS（ArkTS）	`ERR_INVALID_TOKEN`	`110`
HarmonyOS（ArkTS）	`ERR_INVALID_USER_ACCOUNT`	`134`
HarmonyOS（ArkTS）	`ERR_JOIN_CHANNEL_REJECTED`	`17`
HarmonyOS（ArkTS）	`ERR_LEAVE_CHANNEL_REJECTED`	`18`
HarmonyOS（ArkTS）	`ERR_LOAD_MEDIA_ENGINE`	`1001`
HarmonyOS（ArkTS）	`ERR_NO_PERMISSION`	`9`
HarmonyOS（ArkTS）	`ERR_NOT_IN_CHANNEL`	`113`
HarmonyOS（ArkTS）	`ERR_NOT_INITIALIZED`	`7`
HarmonyOS（ArkTS）	`ERR_NOT_READY`	`3`
HarmonyOS（ArkTS）	`ERR_NOT_SUPPORTED`	`4`
HarmonyOS（ArkTS）	`ERR_OK`	`0`
HarmonyOS（ArkTS）	`ERR_REFUSED`	`5`
HarmonyOS（ArkTS）	`ERR_RESOURCE_LIMITED`	`22`
HarmonyOS（ArkTS）	`ERR_SIZE_TOO_LARGE`	`114`
HarmonyOS（ArkTS）	`ERR_TIMEDOUT`	`10`
HarmonyOS（ArkTS）	`ERR_TOKEN_EXPIRED`	`109`
HarmonyOS（ArkTS）	`ERR_TOO_MANY_DATA_STREAMS`	`116`
HarmonyOS（ArkTS）	`ERR_VDM_CAMERA_NOT_AUTHORIZED`	`1501`
HarmonyOS（ArkTS）	`RtcEngine`	`null`

For the full platform REST error table see Error codes.