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

# Invite a contact

POST https://api.yunojuno.com/client_contacts/
Content-Type: application/json

Invite a freelancer to your directory.

This endpoint allows clients to add freelancers to their directory. If the email is new to the platform, a new freelancer profile will be created in an invited state and an invitation email will be sent. If the email already exists, the existing freelancer will be added to the client's directory.

**Hirer Attribution (Optional):**
You can optionally provide a `hirer` field with either the hirer's id or email address to specify which user within your organization is adding this contact. If not provided, the system will automatically use the oldest active hirer from your organization.

**Custom Invitation Message (Optional):**
You can optionally provide an `invite_message` field to include a custom message in the invitation email. This is only applicable for new freelancers and will be ignored if the freelancer already exists on the platform.

The freelancer will remain non-bookable until they complete the onboarding process.

Reference: https://docs.yunojuno.com/client-api/client-contacts/create

## Authentication

- `Authorization` header (bearer token, required) — Bearer authentication of the form `Bearer <token>`, where token is your auth token.

## Request

### Body (application/json)

This endpoint expects a CreateClientContact.

- `email` (string, required) — The contractor's email address.
- `first_name` (string, required) — The contractor's first name.
- `last_name` (string, required) — The contractor's last name.
- `hirer` (string, optional) — The identifier (id) or email address of the hirer who is adding this contact. If not provided, the system will use any active owner from the client.
- `invite_message` (string, optional, default: ) — Optional custom message to include in the invitation email sent to the freelancer. Only applicable for new freelancers.
- `custom_fields` (list of CustomField, optional) — An array of custom fields for the client contact, optional.

## Response

### 201

- `data` (ClientContact, required) — The client contact object. This object represents the lifetime relationship between a client and a freelancer on the platform.

## Types

### CustomField

Represents a single custom field.

- `name` (string, required) — The name of the custom field.
- `value` (string, required) — The value of the custom field.

### ClientContact

The client contact object. This object represents the lifetime relationship between a client and a freelancer on the platform.

- `client_contact_id` (string, required)
- `freelancer_id` (string, required)
- `custom_fields` (list of CustomField, required) — An array of custom fields to apply only when creating a new client contact.
- `url` (string, required) — The fully-qualified URL of the client contact detail page

## Examples

**Request**

```json
{
  "email": "string",
  "first_name": "string",
  "last_name": "string"
}
```

**Response**

```json
{
  "data": {
    "client_contact_id": "string",
    "freelancer_id": "string",
    "custom_fields": [
      {
        "name": "string",
        "value": "string",
        "metadata": null
      }
    ],
    "url": "string"
  }
}
```

**SDK Code**

```python
import requests

url = "https://api.yunojuno.com/client_contacts/"

payload = {
    "email": "string",
    "first_name": "string",
    "last_name": "string"
}
headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
}

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

print(response.json())
```

```javascript
const url = 'https://api.yunojuno.com/client_contacts/';
const options = {
  method: 'POST',
  headers: {Authorization: 'Bearer <token>', 'Content-Type': 'application/json'},
  body: '{"email":"string","first_name":"string","last_name":"string"}'
};

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.yunojuno.com/client_contacts/"

	payload := strings.NewReader("{\n  \"email\": \"string\",\n  \"first_name\": \"string\",\n  \"last_name\": \"string\"\n}")

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

	req.Header.Add("Authorization", "Bearer <token>")
	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.yunojuno.com/client_contacts/")

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

request = Net::HTTP::Post.new(url)
request["Authorization"] = 'Bearer <token>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"email\": \"string\",\n  \"first_name\": \"string\",\n  \"last_name\": \"string\"\n}"

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.yunojuno.com/client_contacts/")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/json")
  .body("{\n  \"email\": \"string\",\n  \"first_name\": \"string\",\n  \"last_name\": \"string\"\n}")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.yunojuno.com/client_contacts/', [
  'body' => '{
  "email": "string",
  "first_name": "string",
  "last_name": "string"
}',
  'headers' => [
    'Authorization' => 'Bearer <token>',
    'Content-Type' => 'application/json',
  ],
]);

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

```csharp
using RestSharp;

var client = new RestClient("https://api.yunojuno.com/client_contacts/");
var request = new RestRequest(Method.POST);
request.AddHeader("Authorization", "Bearer <token>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"email\": \"string\",\n  \"first_name\": \"string\",\n  \"last_name\": \"string\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = [
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
]
let parameters = [
  "email": "string",
  "first_name": "string",
  "last_name": "string"
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api.yunojuno.com/client_contacts/")! 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()
```