> This page is for version latest (default).
> For other versions, use one of these documentation indexes:
> - latest (default): https://docs.machanirobotics.dev/latest/llms.txt
> - v2026.01.16-dev: https://docs.machanirobotics.dev/v-2026-01-16-dev/llms.txt

> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.machanirobotics.dev/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.machanirobotics.dev/_mcp/server.

# Create Connection

POST https://api.machanirobotics.com/v1/management/networks/{network}/connections
Content-Type: application/json

Creates a new network connection configuration for a specific network device.
 The created connection specifies settings like WiFi credentials or Ethernet
 configuration that will be used when connecting to networks.

Reference: https://docs.machanirobotics.dev/latest/2026-01-16-dev/network-service/createconnection

## Request

### Path parameters

- `network` (string, required) — The network id.

### Query parameters

- `connectionId` (string, optional) — Required. The ID to use for the network connection, which becomes the final component of the connection's resource name. For linux systems, this will be ignored, since network manager sets its own id.

### Body (application/json)

This endpoint expects a Connection.

- `name` (string, optional) — Identifier for the network connection resource. Format: //system.v1.engine.core.machanirobotics.com/networks/\{network}/connections/\{connection}
- `ipv4Config` (IPV4Config, optional) — IPv4-specific connection configuration. If not specified, default system IPv4 configuration will be used.
- `ipv6Config` (IPV6Config, optional) — IPv6-specific connection configuration. If not specified, default system IPv6 configuration will be used.
- `wifi` (WifiConfig, optional) — WiFi-specific configuration. Must be specified if the associated Network has network_type=TYPE_WIFI.
- `ethernet` (EthernetConfig, optional) — Ethernet-specific configuration. Must be specified if the associated Network has network_type=TYPE_ETHERNET.

## Response

### 200

OK

- `name` (string, optional) — Identifier for the network connection resource. Format: //system.v1.engine.core.machanirobotics.com/networks/\{network}/connections/\{connection}
- `ipv4Config` (IPV4Config, optional) — IPv4-specific connection configuration. If not specified, default system IPv4 configuration will be used.
- `ipv6Config` (IPV6Config, optional) — IPv6-specific connection configuration. If not specified, default system IPv6 configuration will be used.
- `wifi` (WifiConfig, optional) — WiFi-specific configuration. Must be specified if the associated Network has network_type=TYPE_WIFI.
- `ethernet` (EthernetConfig, optional) — Ethernet-specific configuration. Must be specified if the associated Network has network_type=TYPE_ETHERNET.

## Errors

### 400 Bad Request Error

Bad Request

- `code` (integer, optional) — The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code].
- `message` (string, optional) — A developer-facing error message, which should be in English. Any user-facing error message should be localized and sent in the [google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client.
- `details` (list of GoogleProtobufAny, optional) — A list of messages that carry the error details. There is a common set of message types for APIs to use.

## Types

### IPV4Config

Configuration settings specific to IPv4 connectivity.

- `dns` (list of string, optional) — List of IPv4 DNS server addresses to use for this connection. If not specified, system default DNS servers will be used.

### IPV6Config

Configuration settings specific to IPv6 connectivity.

- `dns` (list of string, optional) — List of IPv6 DNS server addresses to use for this connection. If not specified, system default DNS servers will be used.

### WifiConfig

Configuration settings specific to WiFi connections.

- `psk` (string, required) — The pre-shared key or password for the WiFi network. Required for secured networks (all security types except SECURITY_TYPE_NONE and SECURITY_TYPE_OWE).
- `ssid` (string, optional) — The SSID (network name) of the WiFi network. This field must be set during resource creation and cannot be changed afterward.
- `security` (integer, optional) — The security type used by the WiFi network. If not specified, the system will attempt to auto-detect the security type.

### EthernetConfig

Configuration settings specific to Ethernet connections.

### GoogleProtobufAny

Contains an arbitrary serialized message along with a @type that describes the type of the serialized message.

- `@type` (string, optional) — The type of the serialized message.

## Examples

**Request**

```json
{}
```

**Response**

```json
{
  "name": "//system.v1.engine.core.machanirobotics.com/networks/office-network/connections/wifi-connection-01",
  "ipv4Config": {
    "dns": [
      "8.8.8.8",
      "8.8.4.4"
    ]
  },
  "ipv6Config": {
    "dns": [
      "2001:4860:4860::8888",
      "2001:4860:4860::8844"
    ]
  },
  "wifi": {
    "psk": "SecurePass1234!",
    "ssid": "Office_WiFi_5G",
    "security": 3
  },
  "ethernet": {}
}
```

**SDK Code**

```python
import requests

url = "https://api.machanirobotics.com/v1/management/networks/network/connections"

payload = {}
headers = {"Content-Type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript
const url = 'https://api.machanirobotics.com/v1/management/networks/network/connections';
const options = {method: 'POST', headers: {'Content-Type': 'application/json'}, body: '{}'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://api.machanirobotics.com/v1/management/networks/network/connections"

	payload := strings.NewReader("{}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby
require 'uri'
require 'net/http'

url = URI("https://api.machanirobotics.com/v1/management/networks/network/connections")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Content-Type"] = 'application/json'
request.body = "{}"

response = http.request(request)
puts response.read_body
```

```java
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api.machanirobotics.com/v1/management/networks/network/connections")
  .header("Content-Type", "application/json")
  .body("{}")
  .asString();
```

```php
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.machanirobotics.com/v1/management/networks/network/connections', [
  'body' => '{}',
  'headers' => [
    'Content-Type' => 'application/json',
  ],
]);

echo $response->getBody();
```

```csharp
using RestSharp;

var client = new RestClient("https://api.machanirobotics.com/v1/management/networks/network/connections");
var request = new RestRequest(Method.POST);
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = ["Content-Type": "application/json"]
let parameters = [] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://api.machanirobotics.com/v1/management/networks/network/connections")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```