diff --git a/src/@types/requests.ts b/src/@types/requests.ts
index d6b7ff75fa2..7c778b9bd9d 100644
--- a/src/@types/requests.ts
+++ b/src/@types/requests.ts
@@ -14,6 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
+import { EitherAnd } from "matrix-events-sdk/lib/types";
+
 import { IContent, IEvent } from "../models/event";
 import { Preset, Visibility } from "./partials";
 import { IEventWithRoomId, SearchKey } from "./search";
@@ -76,6 +78,52 @@ export interface ISendEventResponse {
     event_id: string;
 }
 
+export interface IFutureGroupId {
+    future_group_id: string;
+}
+
+export interface IFutureTimeout {
+    future_timeout: number;
+}
+
+export type ISendFutureRequestOpts = EitherAnd<IFutureGroupId, IFutureTimeout>;
+
+export interface IFutureTokens {
+    send_token: string;
+    cancel_token: string;
+}
+
+export interface ITimeoutFutureTokens extends IFutureTokens {
+    refresh_token: string;
+}
+
+export type ISendActionFutureResponse = IFutureGroupId & IFutureTokens;
+export type ISendTimeoutFutureResponse = IFutureGroupId & ITimeoutFutureTokens;
+
+export type ISendFutureResponse<F extends ISendFutureRequestOpts> = F extends IFutureTimeout
+    ? ISendTimeoutFutureResponse
+    : ISendActionFutureResponse;
+
+export interface ISendFutureGroupResponse {
+    send_on_timeout: ITimeoutFutureTokens;
+    send_on_action?: {
+        [action_name: string]: IFutureTokens;
+    };
+    send_now?: ISendEventResponse;
+}
+
+interface IFuturePartialEvent {
+    room_id: string;
+    type: string;
+    state_key?: string;
+    content: IContent;
+}
+
+export type IActionFutureInfo = IFutureGroupId & IFuturePartialEvent & IFutureTokens;
+export type ITimeoutFutureInfo = IFutureGroupId & IFutureTimeout & IFuturePartialEvent & ITimeoutFutureTokens;
+
+export type IFutureInfo = IActionFutureInfo | ITimeoutFutureInfo;
+
 export interface IPresenceOpts {
     // One of "online", "offline" or "unavailable"
     presence: "online" | "offline" | "unavailable";
diff --git a/src/client.ts b/src/client.ts
index ae80589e97c..4b71226a4e5 100644
--- a/src/client.ts
+++ b/src/client.ts
@@ -120,6 +120,7 @@ import {
     ICreateRoomOpts,
     IEventSearchOpts,
     IFilterResponse,
+    IFutureInfo,
     IGuestAccessOpts,
     IJoinRoomOpts,
     INotificationsResponse,
@@ -130,7 +131,12 @@ import {
     IRelationsResponse,
     IRoomDirectoryOptions,
     ISearchOpts,
+    ISendActionFutureResponse,
     ISendEventResponse,
+    ISendFutureGroupResponse,
+    ISendFutureRequestOpts,
+    ISendFutureResponse,
+    ISendTimeoutFutureResponse,
     IStatusResponse,
     ITagsResponse,
     KnockRoomOpts,
@@ -530,6 +536,8 @@ export const UNSTABLE_MSC2666_SHARED_ROOMS = "uk.half-shot.msc2666";
 export const UNSTABLE_MSC2666_MUTUAL_ROOMS = "uk.half-shot.msc2666.mutual_rooms";
 export const UNSTABLE_MSC2666_QUERY_MUTUAL_ROOMS = "uk.half-shot.msc2666.query_mutual_rooms";
 
+const UNSTABLE_MSC4140_FUTURES = "org.matrix.msc4140";
+
 enum CrossSigningKeyType {
     MasterKey = "master_key",
     SelfSigningKey = "self_signing_key",
@@ -4557,6 +4565,29 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         contentOrTxnId?: IContent | string,
         txnIdOrVoid?: string,
     ): Promise<ISendEventResponse> {
+        const { threadId, eventType, content, txnId } = this.processEventArgs(
+            roomId,
+            threadIdOrEventType,
+            eventTypeOrContent,
+            contentOrTxnId,
+            txnIdOrVoid,
+        );
+
+        return this.sendCompleteEvent(roomId, threadId, { type: eventType, content }, txnId);
+    }
+
+    private processEventArgs(
+        roomId: string,
+        threadIdOrEventType: string | null,
+        eventTypeOrContent: string | IContent,
+        contentOrTxnId?: IContent | string,
+        txnIdOrVoid?: string,
+    ): {
+        threadId: string | null;
+        eventType: string;
+        content: IContent;
+        txnId: string | undefined;
+    } {
         let threadId: string | null;
         let eventType: string;
         let content: IContent;
@@ -4597,10 +4628,16 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
             }
         }
 
-        return this.sendCompleteEvent(roomId, threadId, { type: eventType, content }, txnId);
+        return {
+            threadId,
+            eventType,
+            content,
+            txnId,
+        };
     }
 
     /**
+     * TODO: update docstring for overloads
      * @param eventObject - An object with the partial structure of an event, to which event_id, user_id, room_id and origin_server_ts will be added.
      * @param txnId - Optional.
      * @returns Promise which resolves: to an empty object `{}`
@@ -4611,7 +4648,30 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         threadId: string | null,
         eventObject: Partial<IEvent>,
         txnId?: string,
-    ): Promise<ISendEventResponse> {
+    ): Promise<ISendEventResponse>;
+    private sendCompleteEvent<F extends ISendFutureRequestOpts>(
+        roomId: string,
+        threadId: string | null,
+        eventObject: Partial<IEvent>,
+        futureOpts: F,
+        txnId?: string,
+    ): Promise<ISendFutureResponse<F>>;
+    private sendCompleteEvent(
+        roomId: string,
+        threadId: string | null,
+        eventObject: Partial<IEvent>,
+        futureOptsOrTxnId?: ISendFutureRequestOpts | string,
+        txnIdOrVoid?: string,
+    ): Promise<ISendEventResponse | ISendTimeoutFutureResponse | ISendActionFutureResponse> {
+        let futureOpts: ISendFutureRequestOpts | undefined;
+        let txnId: string | undefined;
+        if (typeof futureOptsOrTxnId === "string") {
+            txnId = futureOptsOrTxnId;
+        } else {
+            futureOpts = futureOptsOrTxnId;
+            txnId = txnIdOrVoid;
+        }
+
         if (!txnId) {
             txnId = this.makeTxnId();
         }
@@ -4635,6 +4695,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         }
 
         // set up re-emitter for this new event - this is normally the job of EventMapper but we don't use it here
+        // TODO: skip for futures?
         this.reEmitter.reEmit(localEvent, [MatrixEventEvent.Replaced, MatrixEventEvent.VisibilityChange]);
         room?.reEmitter.reEmit(localEvent, [MatrixEventEvent.BeforeRedaction]);
 
@@ -4651,29 +4712,50 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         }
 
         const type = localEvent.getType();
-        this.logger.debug(`sendEvent of type ${type} in ${roomId} with txnId ${txnId}`);
+        this.logger.debug(`sendEvent of type ${type} in ${roomId} with txnId ${txnId}${futureOpts ? " (future)" : ""}`);
 
         localEvent.setTxnId(txnId);
         localEvent.setStatus(EventStatus.SENDING);
 
-        // add this event immediately to the local store as 'sending'.
-        room?.addPendingEvent(localEvent, txnId);
+        // TODO: separate store for futures?
+        if (!futureOpts) {
+            // add this event immediately to the local store as 'sending'.
+            room?.addPendingEvent(localEvent, txnId);
 
-        // addPendingEvent can change the state to NOT_SENT if it believes
-        // that there's other events that have failed. We won't bother to
-        // try sending the event if the state has changed as such.
-        if (localEvent.status === EventStatus.NOT_SENT) {
-            return Promise.reject(new Error("Event blocked by other events not yet sent"));
-        }
+            // addPendingEvent can change the state to NOT_SENT if it believes
+            // that there's other events that have failed. We won't bother to
+            // try sending the event if the state has changed as such.
+            if (localEvent.status === EventStatus.NOT_SENT) {
+                return Promise.reject(new Error("Event blocked by other events not yet sent"));
+            }
 
-        return this.encryptAndSendEvent(room, localEvent);
+            return this.encryptAndSendEvent(room, localEvent);
+        } else {
+            return this.encryptAndSendEvent(room, localEvent, futureOpts);
+        }
     }
 
     /**
+     * TODO: update docstring for overloads
      * encrypts the event if necessary; adds the event to the queue, or sends it; marks the event as sent/unsent
      * @returns returns a promise which resolves with the result of the send request
      */
-    protected async encryptAndSendEvent(room: Room | null, event: MatrixEvent): Promise<ISendEventResponse> {
+    protected async encryptAndSendEvent(room: Room | null, event: MatrixEvent): Promise<ISendEventResponse>;
+    protected async encryptAndSendEvent<F extends ISendFutureRequestOpts>(
+        room: Room | null,
+        event: MatrixEvent,
+        futureOpts: F,
+    ): Promise<ISendFutureResponse<F>>;
+    protected async encryptAndSendEvent(
+        room: Room | null,
+        event: MatrixEvent,
+        futureOpts?: ISendFutureRequestOpts,
+    ): Promise<ISendEventResponse | ISendTimeoutFutureResponse | ISendActionFutureResponse> {
+        // TODO: Allow encrypted futures, and encrypt them properly
+        if (futureOpts) {
+            return this.sendEventHttpRequest(event, futureOpts);
+        }
+
         try {
             let cancelled: boolean;
             this.eventsBeingEncrypted.add(event.getId()!);
@@ -4824,7 +4906,15 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         }
     }
 
-    private sendEventHttpRequest(event: MatrixEvent): Promise<ISendEventResponse> {
+    private sendEventHttpRequest(event: MatrixEvent): Promise<ISendEventResponse>;
+    private sendEventHttpRequest<F extends ISendFutureRequestOpts>(
+        event: MatrixEvent,
+        futureOpts: F,
+    ): Promise<ISendFutureResponse<F>>;
+    private sendEventHttpRequest(
+        event: MatrixEvent,
+        futureOpts?: ISendFutureRequestOpts,
+    ): Promise<ISendEventResponse | ISendTimeoutFutureResponse | ISendActionFutureResponse> {
         let txnId = event.getTxnId();
         if (!txnId) {
             txnId = this.makeTxnId();
@@ -4838,30 +4928,37 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
             $txnId: txnId,
         };
 
+        const futurePathPart = futureOpts ? "_future" : "";
         let path: string;
 
         if (event.isState()) {
-            let pathTemplate = "/rooms/$roomId/state/$eventType";
+            let pathTemplate = `/rooms/$roomId/state${futurePathPart}/$eventType`;
             if (event.getStateKey() && event.getStateKey()!.length > 0) {
-                pathTemplate = "/rooms/$roomId/state/$eventType/$stateKey";
+                pathTemplate = `/rooms/$roomId/state${futurePathPart}/$eventType/$stateKey`;
             }
             path = utils.encodeUri(pathTemplate, pathParams);
         } else if (event.isRedaction() && event.event.redacts) {
-            const pathTemplate = `/rooms/$roomId/redact/$redactsEventId/$txnId`;
+            // TODO: support future redactions?
+            const pathTemplate = `/rooms/$roomId/redact${futurePathPart}/$redactsEventId/$txnId`;
             path = utils.encodeUri(pathTemplate, {
                 $redactsEventId: event.event.redacts,
                 ...pathParams,
             });
         } else {
-            path = utils.encodeUri("/rooms/$roomId/send/$eventType/$txnId", pathParams);
+            path = utils.encodeUri(`/rooms/$roomId/send${futurePathPart}/$eventType/$txnId`, pathParams);
         }
 
-        return this.http
-            .authedRequest<ISendEventResponse>(Method.Put, path, undefined, event.getWireContent())
-            .then((res) => {
+        const content = event.getWireContent();
+        if (!futureOpts) {
+            return this.http.authedRequest<ISendEventResponse>(Method.Put, path, undefined, content).then((res) => {
                 this.logger.debug(`Event sent to ${event.getRoomId()} with event id ${res.event_id}`);
                 return res;
             });
+        } else {
+            return this.http.authedRequest(Method.Put, path, { ...futureOpts }, content, {
+                prefix: `${ClientPrefix.Unstable}/${UNSTABLE_MSC4140_FUTURES}`,
+            });
+        }
     }
 
     /**
@@ -5191,6 +5288,164 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         return this.sendMessage(roomId, threadId, content);
     }
 
+    /**
+     * Send a future for a timeline event.
+     *
+     * Note: This endpoint is unstable, and can throw an `Error`.
+     *   Check progress on [MSC4140](https://github.com/matrix-org/matrix-spec-proposals/pull/4140) for more details.
+     */
+    // eslint-disable-next-line
+    public _unstable_sendFuture<K extends keyof TimelineEvents, F extends ISendFutureRequestOpts>(
+        roomId: string,
+        futureOpts: F,
+        eventType: K,
+        content: TimelineEvents[K],
+        txnId?: string,
+    ): Promise<ISendFutureResponse<F>>;
+    // eslint-disable-next-line
+    public _unstable_sendFuture<K extends keyof TimelineEvents, F extends ISendFutureRequestOpts>(
+        roomId: string,
+        futureOpts: F,
+        threadId: string | null,
+        eventType: K,
+        content: TimelineEvents[K],
+        txnId?: string,
+    ): Promise<ISendFutureResponse<F>>;
+    // eslint-disable-next-line
+    public async _unstable_sendFuture(
+        roomId: string,
+        futureOpts: ISendFutureRequestOpts,
+        threadIdOrEventType: string | null,
+        eventTypeOrContent: string | IContent,
+        contentOrTxnId?: IContent | string,
+        txnIdOrVoid?: string,
+    ): Promise<ISendTimeoutFutureResponse | ISendActionFutureResponse> {
+        if (!(await this.doesServerSupportUnstableFeature(UNSTABLE_MSC4140_FUTURES))) {
+            throw Error("Server does not support the Futures API");
+        }
+
+        const { threadId, eventType, content, txnId } = this.processEventArgs(
+            roomId,
+            threadIdOrEventType,
+            eventTypeOrContent,
+            contentOrTxnId,
+            txnIdOrVoid,
+        );
+
+        return this.sendCompleteEvent(roomId, threadId, { type: eventType, content }, futureOpts, txnId);
+    }
+
+    /**
+     * Send a future for a state event.
+     *
+     * Note: This endpoint is unstable, and can throw an `Error`.
+     *   Check progress on [MSC4140](https://github.com/matrix-org/matrix-spec-proposals/pull/4140) for more details.
+     */
+    // eslint-disable-next-line
+    public async _unstable_sendStateFuture<K extends keyof StateEvents, F extends ISendFutureRequestOpts>(
+        roomId: string,
+        futureOpts: F,
+        eventType: K,
+        content: StateEvents[K],
+        stateKey = "",
+        opts: IRequestOpts = {},
+    ): Promise<ISendFutureResponse<F>> {
+        if (!(await this.doesServerSupportUnstableFeature(UNSTABLE_MSC4140_FUTURES))) {
+            throw Error("Server does not support the Futures API");
+        }
+
+        const pathParams = {
+            $roomId: roomId,
+            $eventType: eventType,
+            $stateKey: stateKey,
+        };
+        let path = utils.encodeUri("/rooms/$roomId/state_future/$eventType", pathParams);
+        if (stateKey !== undefined) {
+            path = utils.encodeUri(path + "/$stateKey", pathParams);
+        }
+        return this.http.authedRequest(Method.Put, path, { ...futureOpts }, content as Body, {
+            prefix: `${ClientPrefix.Unstable}/${UNSTABLE_MSC4140_FUTURES}`,
+            ...opts,
+        });
+    }
+
+    /**
+     * Send a group of future events.
+     * TODO: type safety & threads...or remove altogether
+     *
+     * Note: This endpoint is unstable, and can throw an `Error`.
+     *   Check progress on [MSC4140](https://github.com/matrix-org/matrix-spec-proposals/pull/4140) for more details.
+     */
+    // eslint-disable-next-line
+    public async _unstable_sendFutureGroup(
+        roomId: string,
+        timeout: number,
+        sendOnTimeout: MatrixEvent,
+        sendOnAction?: Record<string, MatrixEvent>,
+        sendNow?: MatrixEvent,
+    ): Promise<ISendFutureGroupResponse> {
+        if (!(await this.doesServerSupportUnstableFeature(UNSTABLE_MSC4140_FUTURES))) {
+            throw Error("Server does not support the Futures API");
+        }
+
+        return await this.http.authedRequest<ISendFutureGroupResponse>(
+            Method.Put,
+            // NOTE: Difference from MSC = remove /send part of path, to avoid ambiguity with regular event sending
+            utils.encodeUri("/rooms/$roomId/future/$txnId", {
+                $roomId: roomId,
+                $txnId: this.makeTxnId(),
+            }),
+            undefined,
+            {
+                timeout,
+                send_on_timeout: sendOnTimeout,
+                ...(sendOnAction ?? { send_on_action: sendOnAction }),
+                ...(sendNow ?? { send_now: sendNow }),
+            },
+            { prefix: `${ClientPrefix.Unstable}/${UNSTABLE_MSC4140_FUTURES}` },
+        );
+    }
+
+    /**
+     * Get all pending futures for the calling user.
+     *
+     * Note: This endpoint is unstable, and can throw an `Error`.
+     *   Check progress on [MSC4140](https://github.com/matrix-org/matrix-spec-proposals/pull/4140) for more details.
+     */
+    // eslint-disable-next-line
+    public async _unstable_getFutures(): Promise<IFutureInfo[]> {
+        if (!(await this.doesServerSupportUnstableFeature(UNSTABLE_MSC4140_FUTURES))) {
+            throw Error("Server does not support the Futures API");
+        }
+
+        return await this.http.authedRequest(Method.Get, "/future", undefined, undefined, {
+            prefix: `${ClientPrefix.Unstable}/${UNSTABLE_MSC4140_FUTURES}`,
+        });
+    }
+
+    /**
+     * Use a future token, taking the appropriate action given what the token is for.
+     *
+     * Note: This endpoint is unstable, and can throw an `Error`.
+     *   Check progress on [MSC4140](https://github.com/matrix-org/matrix-spec-proposals/pull/4140) for more details.
+     */
+    // eslint-disable-next-line
+    public async _unstable_useFutureToken(futureToken: string): Promise<{}> {
+        if (!(await this.doesServerSupportUnstableFeature(UNSTABLE_MSC4140_FUTURES))) {
+            throw Error("Server does not support the Futures API");
+        }
+
+        return await this.http.request(
+            Method.Post,
+            utils.encodeUri("/future/$futureToken", {
+                $futureToken: futureToken,
+            }),
+            undefined,
+            undefined,
+            { prefix: `${ClientPrefix.Unstable}/${UNSTABLE_MSC4140_FUTURES}` },
+        );
+    }
+
     /**
      * Send a receipt.
      * @param event - The event being acknowledged
diff --git a/src/embedded.ts b/src/embedded.ts
index 8a1492622ee..181bc14ebe4 100644
--- a/src/embedded.ts
+++ b/src/embedded.ts
@@ -26,8 +26,14 @@ import {
 } from "matrix-widget-api";
 
 import { MatrixEvent, IEvent, IContent, EventStatus } from "./models/event";
-import { ISendEventResponse } from "./@types/requests";
-import { EventType } from "./@types/event";
+import {
+    ISendActionFutureResponse,
+    ISendEventResponse,
+    ISendFutureRequestOpts,
+    ISendFutureResponse,
+    ISendTimeoutFutureResponse,
+} from "./@types/requests";
+import { EventType, StateEvents } from "./@types/event";
 import { logger } from "./logger";
 import {
     MatrixClient,
@@ -248,7 +254,33 @@ export class RoomWidgetClient extends MatrixClient {
         throw new Error(`Unknown room: ${roomIdOrAlias}`);
     }
 
-    protected async encryptAndSendEvent(room: Room, event: MatrixEvent): Promise<ISendEventResponse> {
+    protected async encryptAndSendEvent(room: Room, event: MatrixEvent): Promise<ISendEventResponse>;
+    protected async encryptAndSendEvent<F extends ISendFutureRequestOpts>(
+        room: Room,
+        event: MatrixEvent,
+        futureOpts: F,
+    ): Promise<ISendFutureResponse<F>>;
+    protected async encryptAndSendEvent(
+        room: Room,
+        event: MatrixEvent,
+        futureOpts?: ISendFutureRequestOpts,
+    ): Promise<ISendEventResponse | ISendTimeoutFutureResponse | ISendActionFutureResponse> {
+        if (futureOpts) {
+            // TODO: updatePendingEvent for futures?
+            const response = await this.widgetApi.sendRoomFuture(
+                futureOpts,
+                event.getType(),
+                event.getContent(),
+                room.roomId,
+            );
+            return {
+                future_group_id: response.future_group_id,
+                send_token: response.send_token,
+                cancel_token: response.cancel_token,
+                ...(response.refresh_token && { refresh_token: response.refresh_token }),
+            };
+        }
+
         let response: ISendEventFromWidgetResponseData;
         try {
             response = await this.widgetApi.sendRoomEvent(event.getType(), event.getContent(), room.roomId);
@@ -270,6 +302,27 @@ export class RoomWidgetClient extends MatrixClient {
         return (await this.widgetApi.sendStateEvent(eventType, stateKey, content, roomId)) as ISendEventResponse;
     }
 
+    /**
+     * @experimental This currently relies on an unstable MSC (MSC4140).
+     */
+    // eslint-disable-next-line
+    public async _unstable_sendStateFuture<K extends keyof StateEvents, F extends ISendFutureRequestOpts>(
+        roomId: string,
+        futureOpts: F,
+        eventType: K,
+        content: StateEvents[K],
+        stateKey = "",
+    ): Promise<ISendFutureResponse<F>> {
+        // TODO: better type checking
+        return (await this.widgetApi.sendStateFuture(
+            futureOpts,
+            eventType,
+            stateKey,
+            content,
+            roomId,
+        )) as unknown as ISendFutureResponse<F>;
+    }
+
     public async sendToDevice(eventType: string, contentMap: SendToDeviceContentMap): Promise<{}> {
         await this.widgetApi.sendToDevice(eventType, false, recursiveMapToObject(contentMap));
         return {};
diff --git a/src/matrixrtc/MatrixRTCSession.ts b/src/matrixrtc/MatrixRTCSession.ts
index 7f6d12aa203..9aa11be1338 100644
--- a/src/matrixrtc/MatrixRTCSession.ts
+++ b/src/matrixrtc/MatrixRTCSession.ts
@@ -137,6 +137,8 @@ export class MatrixRTCSession extends TypedEventEmitter<MatrixRTCSessionEvent, M
     private encryptionKeys = new Map<string, Array<Uint8Array>>();
     private lastEncryptionKeyUpdateRequest?: number;
 
+    private cancelFutureToken: string | undefined;
+
     /**
      * The callId (sessionId) of the call.
      *
@@ -865,18 +867,35 @@ export class MatrixRTCSession extends TypedEventEmitter<MatrixRTCSessionEvent, M
             newContent = this.makeNewMembership(localDeviceId);
         }
 
+        const stateKey = legacy ? localUserId : this.makeMembershipStateKey(localUserId, localDeviceId);
         try {
-            await this.client.sendStateEvent(
-                this.room.roomId,
-                EventType.GroupCallMemberPrefix,
-                newContent,
-                legacy ? localUserId : this.makeMembershipStateKey(localUserId, localDeviceId),
-            );
+            await this.client.sendStateEvent(this.room.roomId, EventType.GroupCallMemberPrefix, newContent, stateKey);
             logger.info(`Sent updated call member event.`);
 
             // check periodically to see if we need to refresh our member event
-            if (this.isJoined() && legacy) {
-                this.memberEventTimeout = setTimeout(this.triggerCallMembershipEventUpdate, MEMBER_EVENT_CHECK_PERIOD);
+            if (this.isJoined()) {
+                if (legacy) {
+                    this.memberEventTimeout = setTimeout(
+                        this.triggerCallMembershipEventUpdate,
+                        MEMBER_EVENT_CHECK_PERIOD,
+                    );
+                } else {
+                    const res = await this.client._unstable_sendStateFuture(
+                        this.room.roomId,
+                        {
+                            // TODO: choose a reasonable timeout
+                            future_timeout: 10000,
+                        },
+                        EventType.GroupCallMemberPrefix,
+                        {}, // leave event
+                        stateKey,
+                    );
+                    this.cancelFutureToken = res.cancel_token;
+                    this.scheduleRefreshFuture(res.refresh_token);
+                }
+            } else if (!legacy && this.cancelFutureToken !== undefined) {
+                // TODO: remove this once the Synapse MSC4140 implementation cancels timeout futures on state change
+                await this.client._unstable_useFutureToken(this.cancelFutureToken);
             }
         } catch (e) {
             const resendDelay = CALL_MEMBER_EVENT_RETRY_DELAY_MIN + Math.random() * 2000;
@@ -886,6 +905,18 @@ export class MatrixRTCSession extends TypedEventEmitter<MatrixRTCSessionEvent, M
         }
     }
 
+    private scheduleRefreshFuture(refreshToken: string): void {
+        // TODO: choose a reasonable timeout
+        this.memberEventTimeout = setTimeout(() => this.refreshFuture(refreshToken), 3000);
+    }
+
+    private refreshFuture(refreshToken: string): void {
+        this.client
+            ._unstable_useFutureToken(refreshToken)
+            .then(() => this.scheduleRefreshFuture(refreshToken))
+            .catch((err) => logger.error("Failed to refresh future", err));
+    }
+
     private stateEventsContainOngoingLegacySession(callMemberEvents: Map<string, MatrixEvent>): boolean {
         for (const callMemberEvent of callMemberEvents.values()) {
             const content = callMemberEvent.getContent();