diff --git a/.gitignore b/.gitignore
index 6bc9edb40a3..98d71fcd60a 100644
--- a/.gitignore
+++ b/.gitignore
@@ -19,3 +19,4 @@ out
 
 .vscode
 .vscode/
+.idea/
diff --git a/spec/unit/webrtc/groupCall.spec.ts b/spec/unit/webrtc/groupCall.spec.ts
index 4b68100113e..02e3a18b495 100644
--- a/spec/unit/webrtc/groupCall.spec.ts
+++ b/spec/unit/webrtc/groupCall.spec.ts
@@ -109,7 +109,7 @@ const mockGetStateEvents = (type: EventType, userId?: string): MatrixEvent[] | M
 const ONE_HOUR = 1000 * 60 * 60;
 
 const createAndEnterGroupCall = async (cli: MatrixClient, room: Room): Promise<GroupCall> => {
-    const groupCall = new GroupCall(cli, room, GroupCallType.Video, false, GroupCallIntent.Prompt, FAKE_CONF_ID);
+    const groupCall = new GroupCall(cli, room, GroupCallType.Video, false, GroupCallIntent.Prompt, false, FAKE_CONF_ID);
 
     await groupCall.create();
     await groupCall.enter();
@@ -135,7 +135,7 @@ describe("Group Call", function () {
             mockClient = typedMockClient as unknown as MatrixClient;
 
             room = new Room(FAKE_ROOM_ID, mockClient, FAKE_USER_ID_1);
-            groupCall = new GroupCall(mockClient, room, GroupCallType.Video, false, GroupCallIntent.Prompt);
+            groupCall = new GroupCall(mockClient, room, GroupCallType.Video, false, GroupCallIntent.Prompt, false);
             room.currentState.members[FAKE_USER_ID_1] = {
                 userId: FAKE_USER_ID_1,
                 membership: "join",
@@ -484,7 +484,7 @@ describe("Group Call", function () {
         describe("PTT calls", () => {
             beforeEach(async () => {
                 // replace groupcall with a PTT one
-                groupCall = new GroupCall(mockClient, room, GroupCallType.Video, true, GroupCallIntent.Prompt);
+                groupCall = new GroupCall(mockClient, room, GroupCallType.Video, true, GroupCallIntent.Prompt, false);
 
                 await groupCall.create();
 
@@ -647,6 +647,7 @@ describe("Group Call", function () {
                 GroupCallType.Video,
                 false,
                 GroupCallIntent.Prompt,
+                false,
                 FAKE_CONF_ID,
             );
 
@@ -656,6 +657,7 @@ describe("Group Call", function () {
                 GroupCallType.Video,
                 false,
                 GroupCallIntent.Prompt,
+                false,
                 FAKE_CONF_ID,
             );
         });
@@ -882,11 +884,27 @@ describe("Group Call", function () {
                 expect(await groupCall.setMicrophoneMuted(false)).toBe(false);
             });
 
+            it("returns false when no permission for audio stream", async () => {
+                const groupCall = await createAndEnterGroupCall(mockClient, room);
+                jest.spyOn(mockClient.getMediaHandler(), "getUserMediaStream").mockRejectedValueOnce(
+                    new Error("No Permission"),
+                );
+                expect(await groupCall.setMicrophoneMuted(false)).toBe(false);
+            });
+
             it("returns false when unmuting video with no video device", async () => {
                 const groupCall = await createAndEnterGroupCall(mockClient, room);
                 jest.spyOn(mockClient.getMediaHandler(), "hasVideoDevice").mockResolvedValue(false);
                 expect(await groupCall.setLocalVideoMuted(false)).toBe(false);
             });
+
+            it("returns false when no permission for video stream", async () => {
+                const groupCall = await createAndEnterGroupCall(mockClient, room);
+                jest.spyOn(mockClient.getMediaHandler(), "getUserMediaStream").mockRejectedValueOnce(
+                    new Error("No Permission"),
+                );
+                expect(await groupCall.setLocalVideoMuted(false)).toBe(false);
+            });
         });
 
         describe("remote muting", () => {
@@ -1465,6 +1483,7 @@ describe("Group Call", function () {
                 GroupCallType.Video,
                 false,
                 GroupCallIntent.Prompt,
+                false,
                 FAKE_CONF_ID,
             );
             await groupCall.create();
diff --git a/spec/unit/webrtc/mediaHandler.spec.ts b/spec/unit/webrtc/mediaHandler.spec.ts
index 1b3a815b00a..f50baec1f06 100644
--- a/spec/unit/webrtc/mediaHandler.spec.ts
+++ b/spec/unit/webrtc/mediaHandler.spec.ts
@@ -242,6 +242,11 @@ describe("Media Handler", function () {
             );
             expect(await mediaHandler.hasAudioDevice()).toEqual(false);
         });
+
+        it("returns false if the system not permitting access audio inputs", async () => {
+            mockMediaDevices.enumerateDevices.mockRejectedValueOnce(new Error("No Permission"));
+            expect(await mediaHandler.hasAudioDevice()).toEqual(false);
+        });
     });
 
     describe("hasVideoDevice", () => {
@@ -255,6 +260,11 @@ describe("Media Handler", function () {
             );
             expect(await mediaHandler.hasVideoDevice()).toEqual(false);
         });
+
+        it("returns false if the system not permitting access video inputs", async () => {
+            mockMediaDevices.enumerateDevices.mockRejectedValueOnce(new Error("No Permission"));
+            expect(await mediaHandler.hasVideoDevice()).toEqual(false);
+        });
     });
 
     describe("getUserMediaStream", () => {
diff --git a/src/client.ts b/src/client.ts
index d59f5cc5d68..963c244b689 100644
--- a/src/client.ts
+++ b/src/client.ts
@@ -371,6 +371,13 @@ export interface ICreateClientOpts {
      * Defaults to a built-in English handler with basic pluralisation.
      */
     roomNameGenerator?: (roomId: string, state: RoomNameState) => string | null;
+
+    /**
+     * If true, participant can join group call without video and audio this has to be allowed. By default, a local
+     * media stream is needed to establish a group call.
+     * Default: false.
+     */
+    isVoipWithNoMediaAllowed?: boolean;
 }
 
 export interface IMatrixClientCreateOpts extends ICreateClientOpts {
@@ -1169,6 +1176,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     public iceCandidatePoolSize = 0; // XXX: Intended private, used in code.
     public idBaseUrl?: string;
     public baseUrl: string;
+    public readonly isVoipWithNoMediaAllowed;
 
     // Note: these are all `protected` to let downstream consumers make mistakes if they want to.
     // We don't technically support this usage, but have reasons to do this.
@@ -1313,6 +1321,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         this.iceCandidatePoolSize = opts.iceCandidatePoolSize === undefined ? 0 : opts.iceCandidatePoolSize;
         this.supportsCallTransfer = opts.supportsCallTransfer || false;
         this.fallbackICEServerAllowed = opts.fallbackICEServerAllowed || false;
+        this.isVoipWithNoMediaAllowed = opts.isVoipWithNoMediaAllowed || false;
 
         if (opts.useE2eForGroupCall !== undefined) this.useE2eForGroupCall = opts.useE2eForGroupCall;
 
@@ -1880,14 +1889,17 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
             throw new Error(`Cannot find room ${roomId}`);
         }
 
+        // Because without Media section a WebRTC connection is not possible, so need a RTCDataChannel to set up a
+        // no media WebRTC connection anyway.
         return new GroupCall(
             this,
             room,
             type,
             isPtt,
             intent,
+            this.isVoipWithNoMediaAllowed,
             undefined,
-            dataChannelsEnabled,
+            dataChannelsEnabled || this.isVoipWithNoMediaAllowed,
             dataChannelOptions,
         ).create();
     }
diff --git a/src/webrtc/call.ts b/src/webrtc/call.ts
index 2962105f243..6d48c1c06dc 100644
--- a/src/webrtc/call.ts
+++ b/src/webrtc/call.ts
@@ -390,6 +390,9 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
     // Used to keep the timer for the delay before actually stopping our
     // video track after muting (see setLocalVideoMuted)
     private stopVideoTrackTimer?: ReturnType<typeof setTimeout>;
+    // Used to allow connection without Video and Audio. To establish a webrtc connection without media a Data channel is
+    // needed At the moment this property is true if we allow MatrixClient with isVoipWithNoMediaAllowed = true
+    private readonly isOnlyDataChannelAllowed: boolean;
 
     /**
      * Construct a new Matrix Call.
@@ -420,6 +423,8 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
             utils.checkObjectHasKeys(server, ["urls"]);
         }
         this.callId = genCallID();
+        // If the Client provides calls without audio and video we need a datachannel for a webrtc connection
+        this.isOnlyDataChannelAllowed = this.client.isVoipWithNoMediaAllowed;
     }
 
     /**
@@ -944,7 +949,11 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
         // According to previous comments in this file, firefox at some point did not
         // add streams until media started arriving on them. Testing latest firefox
         // (81 at time of writing), this is no longer a problem, so let's do it the correct way.
-        if (!remoteStream || remoteStream.getTracks().length === 0) {
+        //
+        // For example in case of no media webrtc connections like screen share only call we have to allow webrtc
+        // connections without remote media. In this case we always use a data channel. At the moment we allow as well
+        // only data channel as media in the WebRTC connection with this setup here.
+        if (!this.isOnlyDataChannelAllowed && (!remoteStream || remoteStream.getTracks().length === 0)) {
             logger.error(
                 `Call ${this.callId} initWithInvite() no remote stream or no tracks after setting remote description!`,
             );
diff --git a/src/webrtc/groupCall.ts b/src/webrtc/groupCall.ts
index 4e9971f10ad..f6ab54fa2e1 100644
--- a/src/webrtc/groupCall.ts
+++ b/src/webrtc/groupCall.ts
@@ -216,6 +216,7 @@ export class GroupCall extends TypedEventEmitter<
         public type: GroupCallType,
         public isPtt: boolean,
         public intent: GroupCallIntent,
+        public readonly allowCallWithoutVideoAndAudio: boolean,
         groupCallId?: string,
         private dataChannelsEnabled?: boolean,
         private dataChannelOptions?: IGroupCallDataChannelOptions,
@@ -374,8 +375,15 @@ export class GroupCall extends TypedEventEmitter<
         try {
             stream = await this.client.getMediaHandler().getUserMediaStream(true, this.type === GroupCallType.Video);
         } catch (error) {
-            this.state = GroupCallState.LocalCallFeedUninitialized;
-            throw error;
+            // If is allowed to join a call without a media stream, then we
+            // don't throw an error here. But we need an empty Local Feed to establish
+            // a connection later.
+            if (this.allowCallWithoutVideoAndAudio) {
+                stream = new MediaStream();
+            } else {
+                this.state = GroupCallState.LocalCallFeedUninitialized;
+                throw error;
+            }
         }
 
         // The call could've been disposed while we were waiting, and could
@@ -584,6 +592,31 @@ export class GroupCall extends TypedEventEmitter<
             logger.log(
                 `GroupCall ${this.groupCallId} setMicrophoneMuted() (streamId=${this.localCallFeed.stream.id}, muted=${muted})`,
             );
+
+            // We needed this here to avoid an error in case user join a call without a device.
+            // I can not use .then .catch functions because linter :-(
+            try {
+                if (!muted) {
+                    const stream = await this.client
+                        .getMediaHandler()
+                        .getUserMediaStream(true, !this.localCallFeed.isVideoMuted());
+                    if (stream === null) {
+                        // if case permission denied to get a stream stop this here
+                        /* istanbul ignore next */
+                        logger.log(
+                            `GroupCall ${this.groupCallId} setMicrophoneMuted() no device to receive local stream, muted=${muted}`,
+                        );
+                        return false;
+                    }
+                }
+            } catch (e) {
+                /* istanbul ignore next */
+                logger.log(
+                    `GroupCall ${this.groupCallId} setMicrophoneMuted() no device or permission to receive local stream, muted=${muted}`,
+                );
+                return false;
+            }
+
             this.localCallFeed.setAudioVideoMuted(muted, null);
             // I don't believe its actually necessary to enable these tracks: they
             // are the one on the GroupCall's own CallFeed and are cloned before being
@@ -617,14 +650,24 @@ export class GroupCall extends TypedEventEmitter<
         }
 
         if (this.localCallFeed) {
+            /* istanbul ignore next */
             logger.log(
                 `GroupCall ${this.groupCallId} setLocalVideoMuted() (stream=${this.localCallFeed.stream.id}, muted=${muted})`,
             );
 
-            const stream = await this.client.getMediaHandler().getUserMediaStream(true, !muted);
-            await this.updateLocalUsermediaStream(stream);
-            this.localCallFeed.setAudioVideoMuted(null, muted);
-            setTracksEnabled(this.localCallFeed.stream.getVideoTracks(), !muted);
+            try {
+                const stream = await this.client.getMediaHandler().getUserMediaStream(true, !muted);
+                await this.updateLocalUsermediaStream(stream);
+                this.localCallFeed.setAudioVideoMuted(null, muted);
+                setTracksEnabled(this.localCallFeed.stream.getVideoTracks(), !muted);
+            } catch (_) {
+                // No permission to video device
+                /* istanbul ignore next */
+                logger.log(
+                    `GroupCall ${this.groupCallId} setLocalVideoMuted() no device or permission to receive local stream, muted=${muted}`,
+                );
+                return false;
+            }
         } else {
             logger.log(`GroupCall ${this.groupCallId} setLocalVideoMuted() no stream muted (muted=${muted})`);
             this.initWithVideoMuted = muted;
diff --git a/src/webrtc/groupCallEventHandler.ts b/src/webrtc/groupCallEventHandler.ts
index 2efed52933c..7392a75adab 100644
--- a/src/webrtc/groupCallEventHandler.ts
+++ b/src/webrtc/groupCallEventHandler.ts
@@ -183,8 +183,11 @@ export class GroupCallEventHandler {
             callType,
             isPtt,
             callIntent,
+            this.client.isVoipWithNoMediaAllowed,
             groupCallId,
-            content?.dataChannelsEnabled,
+            // Because without Media section a WebRTC connection is not possible, so need a RTCDataChannel to set up a
+            // no media WebRTC connection anyway.
+            content?.dataChannelsEnabled || this.client.isVoipWithNoMediaAllowed,
             dataChannelOptions,
         );
 
diff --git a/src/webrtc/mediaHandler.ts b/src/webrtc/mediaHandler.ts
index b472b7a4b3d..7f65835d18f 100644
--- a/src/webrtc/mediaHandler.ts
+++ b/src/webrtc/mediaHandler.ts
@@ -185,13 +185,23 @@ export class MediaHandler extends TypedEventEmitter<
     }
 
     public async hasAudioDevice(): Promise<boolean> {
-        const devices = await navigator.mediaDevices.enumerateDevices();
-        return devices.filter((device) => device.kind === "audioinput").length > 0;
+        try {
+            const devices = await navigator.mediaDevices.enumerateDevices();
+            return devices.filter((device) => device.kind === "audioinput").length > 0;
+        } catch (err) {
+            logger.log(`MediaHandler hasAudioDevice() calling navigator.mediaDevices.enumerateDevices with error`, err);
+            return false;
+        }
     }
 
     public async hasVideoDevice(): Promise<boolean> {
-        const devices = await navigator.mediaDevices.enumerateDevices();
-        return devices.filter((device) => device.kind === "videoinput").length > 0;
+        try {
+            const devices = await navigator.mediaDevices.enumerateDevices();
+            return devices.filter((device) => device.kind === "videoinput").length > 0;
+        } catch (err) {
+            logger.log(`MediaHandler hasVideoDevice() calling navigator.mediaDevices.enumerateDevices with error`, err);
+            return false;
+        }
     }
 
     /**