---
title: Handling Connection Requests
slug: v4-7/sync/handling-connection-requests
docTags: 
createdAt: 2024-03-21T18:19:48.836Z
---

This article provides concepts and step-by-step instructions for how to use the `connectingRequestHandler` API method within your app logic to enable end-user functionality of intercepting and managing new peer connections advertised in the mesh.

# Overview

Using the `connectionRequestHandler` API method, you can intercept new peer connections and make decisions to accept or reject them based on the peer metadata set for a given device. (See [Setting the Connection Request Handler](./#setting-the-connection-request-handler))

Within the `connectionRequestHandler` you can use the `connectionRequest` parameter to access information about the peer connection request. (See [Reading Connection Parameter](./#reading-connection-parameter))

- Peer key string — The identifier encoded as a `string` that uniquely identifies the requesting peer once discovered within the mesh.

- Connection type — The type of connection the peer is requesting.

- Peer metadata — The information provided by the end user associated with the peer making the request. (For more information on peer metadata, see [Using Mesh Presence](docId\:ZE725plpDADL4zThnx4Ct))

# Setting the Connection Request Handler

To accept or reject an incoming connection request:

:::hint{type="info"}
Once you've set the request handler, end users must always make a choice to accept or reject incoming connection requests; otherwise, potential issues like request deadlocks and connection timeouts may result. 
:::

:::CodeblockTabs
```swift
ditto.presence.connectionRequestHandler = { connectionRequest in
    if (true) {
        return .allow
    } else {
        return .deny
    }
}
```

```kotlin
ditto.presence.connectionRequestHandler = { connectionRequest ->
    if (true) {
        DittoConnectionRequestAuthorization.Allow
    } else {
        DittoConnectionRequestAuthorization.Deny
    }
}
```

```javascript
ditto.presence.connectionRequestHandler = async (connectionRequest) => {
    if (true) {
        return "allow";
    } else {
        return "deny";
    }
}
```

```java
// Not Supported
```

```csharp
Ditto.Presence.ConnectionRequestHandler = (connectionRequest) =>
{
    if (true) {
        return Task.FromResult(DittoConnectionRequestAuthorization.Allow);
    } else {
        return Task.FromResult(DittoConnectionRequestAuthorization.Deny);
    }
};
```

```cpp
ditto.get_presence().set_connection_request_handler(
    [&](ConnectionRequest connection_request) {
      if (true){
          return ConnectionRequestAuthorization::allow;
      } else {
          return ConnectionRequestAuthorization::deny;
      }
    }
  );
```

```rust
ditto.presence().set_connection_request_handler(|connection_request: ConnectionRequest| {
    if (true) {
        return ConnectionRequestAuthorization::Allow
    } else {
        return ConnectionRequestAuthorization::Deny
    }
});
```

Dart (beta)

```dart
// Coming Soon
```
:::

# Reading Connection Parameter

To see specific information associated with a requesting peer connection 

:::CodeblockTabs
```swift
ditto.presence.connectionRequestHandler = { connectionRequest in
    
    print(connectionRequest.peerKeyString)
    print(connectionRequest.connectionType)
    print(connectionRequest.peerMetadata)
    
    return .allow
}
```

```kotlin
ditto.presence.connectionRequestHandler = { connectionRequest ->
    
    println(connectionRequest.peerKeyString)
    println(connectionRequest.connectionType)
    println(connectionRequest.peerMetadata)
    
    DittoConnectionRequestAuthorization.Allow
}
```

```javascript
ditto.presence.connectionRequestHandler = async (connectionRequest) => {

    console.log(connectionRequest.peerKeyString)
    console.log(connectionRequest.connectionType)
    console.log(connectionRequest.peerMetadata)

    return "allow";
}
```

```java
// Not Supported
```

```csharp
Ditto.Presence.ConnectionRequestHandler = (connectionRequest) =>
{
    Console.WriteLine(connectionRequest.PeerKeyString);
    Console.WriteLine(connectionRequest.ConnectionType);
    Console.WriteLine(connectionRequest.PeerMetadata);

    return Task.FromResult(DittoConnectionRequestAuthorization.Allow);
};
```

```cpp
ditto.get_presence().set_connection_request_handler(
    [&](ConnectionRequest connection_request) {

        std::cout << connection_request.peer_key_string << std::endl;
        std::cout << connection_request.connection_type << std::endl;
        std::cout << connection_request.peer_metadata << std::endl;

        return ConnectionRequestAuthorization::allow;
    }
  );
```

```rust
ditto.presence().set_connection_request_handler(|connection_request: ConnectionRequest| {

    println!("{}", connection_request.peer_key_string);
    println!("{}", connection_request.connection_type);
    println!("{}", connection_request.peer_metadata);

    ConnectionRequestAuthorization::Allow
});
```

Dart (beta)

```dart
// Coming Soon
```
:::