### Get Fund Webhooks (Python)

Source: https://developers.anduintransact.com/reference/legacy-webhooks-1

Python example using the 'requests' library to fetch fund webhooks. This snippet illustrates how to construct the API request and handle the response.

```python
import requests

fund_id = 'your_fund_id'  # Replace with the actual fund ID
url = f"https://api.anduin.app/api/v1/fundsub/{fund_id}/webhook"

headers = {
    'accept': 'application/json'
}

try:
    response = requests.get(url, headers=headers)
    response.raise_for_status()  # Raise an exception for bad status codes
    print(response.json())
except requests.exceptions.RequestException as e:
    print(f"Error fetching webhooks: {e}")
```

--------------------------------

### Get File Download URL - Ruby Example

Source: https://developers.anduintransact.com/reference/file

This Ruby example demonstrates how to fetch a file download URL using the 'httparty' gem. It constructs the request URL with the file ID and sets the 'accept' header. The response data, containing the pre-signed URL, is returned.

```ruby
require 'httparty'

def get_file_download_url(file_id)
  url = "https://api.anduin.app/api/v1/fundsub/files/#{file_id}/url"
  headers = {
    'accept' => 'application/json'
  }
  begin
    response = HTTParty.get(url, headers: headers)
    if response.success?
      return response.parsed_response
    else
      puts "Error fetching file download URL: #{response.code} - #{response.message}"
      return nil
    end
  rescue StandardError => e
    puts "An error occurred: #{e.message}"
    return nil
  end
end

# Example usage:
# file_data = get_file_download_url('your-file-id')
# puts file_data['url'] if file_data
```

--------------------------------

### Get Fund Webhooks (Node.js)

Source: https://developers.anduintransact.com/reference/legacy-webhooks-1

Node.js example using the 'axios' library to make a GET request to retrieve fund webhooks. It shows how to configure the request with the correct URL and headers.

```javascript
const axios = require('axios');

const fundId = 'your_fund_id'; // Replace with the actual fund ID

axios.get(`https://api.anduin.app/api/v1/fundsub/${fundId}/webhook`, {
    headers: {
        'accept': 'application/json'
    }
})
.then(response => {
    console.log(response.data);
})
.catch(error => {
    console.error('Error fetching webhooks:', error);
});
```

--------------------------------

### List Orders by Fund (Python)

Source: https://developers.anduintransact.com/reference/orders

This Python example uses the 'requests' library to fetch a list of orders for a fund. It constructs the URL with the firm and fund IDs and includes the 'accept' header in the GET request.

```python
import requests

firm_id = 'your_firm_id'
fund_id = 'your_fund_id'

url = f"https://api.anduin.app/api/v1/idm/{firm_id}/funds/{fund_id}/orders"
headers = {
    'accept': 'application/json'
}

response = requests.get(url, headers=headers)

if response.status_code == 200:
    print(response.json())
else:
    print(f"Error: {response.status_code} - {response.text}")
```

--------------------------------

### Get Folder Structure using Node.js

Source: https://developers.anduintransact.com/reference/folder

This Node.js example shows how to make a GET request to retrieve folder structure information. It utilizes the 'axios' library for HTTP requests and includes essential parameters. Replace placeholders for accurate requests.

```javascript
const axios = require('axios');

const dataRoomId = 'YOUR_DATA_ROOM_ID';
const folderId = 'YOUR_FOLDER_ID';

axios.get(`https://api.anduin.app/api/v1/dataroom/${dataRoomId}/folder/${folderId}`, {
  headers: {
    'accept': 'application/json'
  }
})
  .then(response => {
    console.log(response.data);
  })
  .catch(error => {
    console.error('Error fetching folder structure:', error);
  });

```

--------------------------------

### Get File Download URL - Node.js Example

Source: https://developers.anduintransact.com/reference/file

This Node.js example shows how to fetch a file download URL using the 'axios' library. It constructs the request URL with the provided file ID and sets the 'accept' header to 'application/json'. The response contains a pre-signed URL with a 10-minute expiry.

```javascript
const axios = require('axios');

async function getFileDownloadUrl(fileId) {
  const url = `https://api.anduin.app/api/v1/fundsub/files/${fileId}/url`;
  try {
    const response = await axios.get(url, {
      headers: {
        'accept': 'application/json'
      }
    });
    return response.data;
  } catch (error) {
    console.error('Error fetching file download URL:', error);
    throw error;
  }
}

// Example usage:
// getFileDownloadUrl('your-file-id').then(data => console.log(data.url));
```

--------------------------------

### Get Standard Form Fields using Ruby

Source: https://developers.anduintransact.com/reference/form-fields

This Ruby example demonstrates fetching standard form fields via an HTTP GET request. It uses the 'net/http' library to interact with the API.

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

def get_standard_form_fields(fund_id)
  uri = URI.parse("https://api.anduin.app/api/v1/fundsub/#{fund_id}/standardFormFields")
  http = Net::HTTP.new(uri.host, uri.port)
  http.use_ssl = true

  request = Net::HTTP::Get.new(uri.request_uri)
  request['accept'] = 'application/json'

  begin
    response = http.request(request)
    if response.is_a?(Net::HTTPSuccess)
      JSON.parse(response.body)
    else
      puts "Error: #{response.code} #{response.message}"
      nil
    end
  rescue StandardError => e
    puts "Error fetching standard form fields: #{e.message}"
    nil
  end
end

# Example usage:
# fund_id = "your-fund-id"
# fields = get_standard_form_fields(fund_id)
# if fields
#   puts fields.inspect
# end
```

--------------------------------

### List Profiles by Client (Ruby)

Source: https://developers.anduintransact.com/reference/profiles

Ruby code example using the 'httparty' gem to make a GET request for client profiles. This snippet illustrates how to specify the endpoint URL and required headers for the API call.

```ruby
require 'httparty'

firm_id = 'your_firm_id'
client_id = 'your_client_id'

url = "https://api.anduin.app/api/v1/idm/#{firm_id}/clients/#{client_id}/profiles"

response = HTTParty.get(url, headers: { 'accept' => 'application/json' })

if response.code == 200
  puts "Profiles: #{response.parsed_response}"
else
  puts "Error: #{response.code} - #{response.parsed_response}"
end
```

--------------------------------

### Webhook Setup and Validation

Source: https://developers.anduintransact.com/reference/createwebhook

This section details how to set up a webhook endpoint, including the required parameters and the validation process.

```APIDOC
## POST /webhooks

### Description
Creates a new webhook endpoint to receive event notifications. Requires specifying the fund ID, enabled event types, and the endpoint URL.

### Method
POST

### Endpoint
/webhooks

### Parameters
#### Query Parameters
- **fund-id** (string) - Required - The ID of the fund for which to receive events.
- **enabled_events** (array of strings) - Required - A list of event types to subscribe to (e.g., `new_investor_added`, `subscription_status_changed`).
- **url** (string) - Required - The URL of your webhook endpoint.

### Request Body
(Not applicable for this endpoint, parameters are passed as query parameters)

### Validation Request
Upon creation, a validation request is sent to your provided URL.

#### Method
GET

#### Endpoint
`https://yourdomain.com` (Your provided URL)

#### Headers
- **x-anduin-webhook-validation-key** (string) - Required - A random validation key provided by the system.

#### Response (200 OK)
- **x-anduin-webhook-validation-key** (string) - The same validation key received in the request header.

### Request Example (Validation)
```bash
curl -X GET https:\yourdomain.com -H 'x-anduin-webhook-validation-key: [RANDOM_VALIDATIONKEY]'
```

### Response Example (Validation)
(Your endpoint should respond with a 200 status code and the same `x-anduin-webhook-validation-key` header.)
```

--------------------------------

### Get Invitation Link (Python)

Source: https://developers.anduintransact.com/reference/link

This Python example uses the 'requests' library to get an invitation link. It constructs the URL with the fund ID and sends a GET request with the 'accept' header.

```python
import requests

fund_id = 'your-fund-id'  # Replace with the actual fund ID
url = f"https://api.anduin.app/api/v1/fundsub/{fund_id}/link"

headers = {
    'accept': 'application/json'
}

try:
    response = requests.get(url, headers=headers)
    response.raise_for_status()  # Raise an exception for bad status codes
    print(response.json())
except requests.exceptions.RequestException as e:
    print(f"Error: {e}")
```

--------------------------------

### List Profiles by Client (PHP)

Source: https://developers.anduintransact.com/reference/profiles

PHP code example using cURL to fetch client profiles. This snippet shows how to initialize a cURL session, set the URL and headers, and execute the request to retrieve profile data.

```php
<?php

$firmId = 'your_firm_id';
$clientId = 'your_client_id';

$url = "https://api.anduin.app/api/v1/idm/{$firmId}/clients/{$clientId}/profiles";

$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_HTTPHEADER, array('accept: application/json'));

$response = curl_exec($ch);

if (curl_errno($ch)) {
    echo 'Error:' . curl_error($ch);
} else {
    echo 'Profiles:' . $response;
}

c_close($ch);

?>
```

--------------------------------

### Get Fund Webhooks (Ruby)

Source: https://developers.anduintransact.com/reference/legacy-webhooks-1

Ruby example using the 'httparty' gem to retrieve fund webhook information. It demonstrates making a GET request and processing the JSON response.

```ruby
require 'httparty'

fund_id = 'your_fund_id' # Replace with the actual fund ID
url = "https://api.anduin.app/api/v1/fundsub/#{fund_id}/webhook"

response = HTTParty.get(url, headers: { 'accept' => 'application/json' })

if response.success?
  puts response.parsed_response
else
  puts "Error fetching webhooks: #{response.code} - #{response.message}"
end
```

--------------------------------

### List Profiles by Client (Node.js)

Source: https://developers.anduintransact.com/reference/profiles

Example Node.js code using the 'axios' library to fetch a list of client profiles. This snippet shows how to construct the request URL and handle the response, including potential errors.

```javascript
const axios = require('axios');

const firmId = 'your_firm_id';
const clientId = 'your_client_id';

axios.get(`https://api.anduin.app/api/v1/idm/${firmId}/clients/${clientId}/profiles`, {
  headers: {
    'accept': 'application/json'
  }
})
  .then(response => {
    console.log('Profiles:', response.data);
  })
  .catch(error => {
    console.error('Error fetching profiles:', error.response.data);
  });
```

--------------------------------

### Get All Webhook Endpoints (Node.js)

Source: https://developers.anduintransact.com/reference/general

This Node.js example shows how to make a GET request to retrieve webhook endpoint data. It utilizes the 'axios' library for HTTP communication and handles the JSON response.

```javascript
const axios = require('axios');

const getWebhooks = async () => {
  try {
    const response = await axios.get('https://api.anduin.app/api/v1/webhook', {
      headers: {
        'accept': 'application/json'
      }
    });
    console.log(response.data);
  } catch (error) {
    console.error('Error fetching webhooks:', error);
  }
};

getWebhooks();
```

--------------------------------

### List Orders by Fund (Ruby)

Source: https://developers.anduintransact.com/reference/orders

This Ruby example illustrates how to retrieve a list of orders for a fund using the Net::HTTP library. It defines the firm and fund IDs, constructs the request URL, and sends a GET request with the appropriate 'accept' header.

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

firm_id = 'your_firm_id'
fund_id = 'your_fund_id'

uri = URI.parse("https://api.anduin.app/api/v1/idm/#{firm_id}/funds/#{fund_id}/orders")

request = Net::HTTP::Get.new(uri)
request['accept'] = 'application/json'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
  http.request(request)
end

puts response.body
```

--------------------------------

### Get Fund Information (Ruby)

Source: https://developers.anduintransact.com/reference/fund

This Ruby example demonstrates how to retrieve fund information using the 'httparty' gem. It sends a GET request to the specified URL with the 'accept' header set to 'application/json'.

```ruby
require 'httparty'

fund_id = 'your-fund-id' # Replace with the actual fund ID
url = "https://api.anduin.app/api/v1/fundsub/#{fund_id}"

response = HTTParty.get(url, headers: { 'accept' => 'application/json' })

if response.success?
  puts response.parsed_response
else
  puts "Error fetching fund information: #{response.code} - #{response.message}"
end
```

--------------------------------

### Get File Download URL - PHP Example

Source: https://developers.anduintransact.com/reference/file

This PHP example shows how to retrieve a file download URL using cURL. It sets up the cURL request to the API endpoint, including the 'accept' header. The function returns the JSON-decoded response, which contains the pre-signed URL.

```php
<?php

function getFileDownloadUrl(string $fileId): ?array {
    $url = "https://api.anduin.app/api/v1/fundsub/files/{$fileId}/url";
    $headers = [
        'Accept: application/json'
    ];

    $ch = curl_init();
    curl_setopt($ch, CURLOPT_URL, $url);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
    curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

    $response = curl_exec($ch);
    $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);

    if ($httpCode >= 200 && $httpCode < 300) {
        return json_decode($response, true);
    } else {
        error_log("Error fetching file download URL: HTTP Code {$httpCode}");
        return null;
    }
}

// Example usage:
// $fileData = getFileDownloadUrl('your-file-id');
// if ($fileData && isset($fileData['url'])) {
//     echo $fileData['url'];
// }

?>
```

--------------------------------

### Import Investments (Python)

Source: https://developers.anduintransact.com/reference/investments

This Python example utilizes the 'requests' library to import investments. It constructs the POST request with the API endpoint, headers, and a sample investment data payload. Remember to replace 'YOUR_FIRM_ID' with the actual firm ID and format the 'investment_data' correctly.

```Python
import requests

firm_id = 'YOUR_FIRM_ID'  # Replace with your firm ID
api_url = f'https://api.anduin.app/api/v1/idm/{firm_id}/investments/import'

investment_data = [
  {
    # Example investment object structure
    # Replace with your actual investment data
    'field1': 'value1',
    'field2': 'value2'
  }
]

headers = {
  'accept': 'application/json',
  'content-type': 'application/json'
}

try:
  response = requests.post(api_url, json=investment_data, headers=headers)
  response.raise_for_status()  # Raise an exception for bad status codes
  print('Import initiated successfully:', response.json())
except requests.exceptions.RequestException as e:
  print(f'Error initiating import: {e}')
```

--------------------------------

### Order Creation and Details

Source: https://developers.anduintransact.com/reference/bulkinviteinvestor

This section details the structure and properties of an order, including contact information, investment entity name, commitment amount, tags, form data, metadata, and collaborator organizations.

```APIDOC
## POST /orders

### Description
Creates a new order with specified details.

### Method
POST

### Endpoint
/orders

### Parameters
#### Request Body
- **contacts** (array) - Required - A non-empty list of the order's contact information. The first contact in the list is the order's default contact.
  - **email** (string) - Required - Email address
  - **firstName** (string) - Required - First name of the contact
  - **lastName** (string) - Required - Last name of the contact
  - **skipInvitationEmail** (boolean) - Optional - Whether Anduin should skip sending invitation email to this contact. Defaults to false.
  - **enableSso** (boolean) - Optional - Should SSO be enabled on the invitation email link. Defaults to false.
- **investmentEntityName** (string) - Optional - Name of the order's investment entity
- **expectedCommitmentAmount** (string) - Optional - Expected commitment amount of the order
- **tags** (array) - Optional - List of tags to assign to the order
  - items (string)
- **formData** (object) - Optional - Import data to the specified template `templateId`
  - additionalProperties (string)
- **metadata** (string) - Optional - Order metadata stored as `(key-value)` pairs
- **collaboratorOrgs** (array) - Optional - List of collaborator organizations
  - **organizationId** (string) - Required - The ID of the organization
  - **organizationName** (string) - Required - The name of the organization

### Request Example
```json
{
  "contacts": [
    {
      "email": "john.doe@email.com",
      "firstName": "John",
      "lastName": "Doe",
      "skipInvitationEmail": false,
      "enableSso": false
    }
  ],
  "investmentEntityName": "John's family fund",
  "expectedCommitmentAmount": "1000000",
  "tags": [],
  "formData": {},
  "metadata": "",
  "collaboratorOrgs": []
}
```

### Response
#### Success Response (200)
- **orderId** (string) - The unique identifier for the created order.

#### Response Example
```json
{
  "orderId": "ord_12345abcde"
}
```
```

--------------------------------

### Get Fund Information (Node.js)

Source: https://developers.anduintransact.com/reference/fund

This Node.js example shows how to make a GET request to the fund information API endpoint. It utilizes the 'axios' library for HTTP requests and includes the necessary URL and headers.

```javascript
const axios = require('axios');

const fundId = 'your-fund-id'; // Replace with the actual fund ID

axios.get(`https://api.anduin.app/api/v1/fundsub/${fundId}`, {
  headers: {
    'accept': 'application/json'
  }
})
  .then(response => {
    console.log(response.data);
  })
  .catch(error => {
    console.error('Error fetching fund information:', error);
  });
```

--------------------------------

### POST /packages/distributions

Source: https://developers.anduintransact.com/reference/create-draft-package

Creates a new package distribution. This endpoint allows you to define who receives the package, whether they can download documents, and how they are notified.

```APIDOC
## POST /packages/distributions

### Description
Creates a new package distribution. This endpoint allows you to define who receives the package, whether they can download documents, and how they are notified.

### Method
POST

### Endpoint
/packages/distributions

### Parameters
#### Request Body
- **createDraftPackageParams** (object) - Required - Parameters for creating a draft package distribution.
  - **name** (string) - Required - Name of the document distribution package.
  - **shareWith** (object) - Required - Defines the recipients of the package distribution.
    - **targetType** (string) - Required - The type of distribution target. Must be one of: "AllContacts", "Contacts", "InvestmentEntities", "InvestmentEntitiesInFundLegalEntity".
    - **investmentEntityIds** (array[string]) - Optional - List of investment entity IDs to share with.
    - **fundLegalEntityId** (string) - Optional - The ID of the fund legal entity.
    - **communicationTypeId** (string) - Optional - The ID of the Communication type object.
  - **allowDownload** (boolean) - Optional - Whether recipients can download documents (default: true).
  - **attachDocumentsToEmail** (boolean) - Optional - Whether to attach documents to email notifications (default: false).
  - **notifyEmail** (boolean) - Optional - Whether to send email notifications (default: true).

### Request Example
```json
{
  "createDraftPackageParams": {
    "name": "Quarterly Report Distribution",
    "shareWith": {
      "targetType": "InvestmentEntities",
      "investmentEntityIds": [
        "inv00000000000000000000000000000000",
        "inv00000000000000000000000000000001"
      ]
    },
    "allowDownload": true,
    "attachDocumentsToEmail": false,
    "notifyEmail": true
  }
}
```

### Response
#### Success Response (200)
- **id** (string) - ID of the package distribution.
- **name** (string) - Name of the document distribution package.
- **method** (string) - Distribution method.
- **status** (string) - Current status of the distribution.
- **shareWith** (object) - Details of who the package was shared with.
- **allowDownload** (boolean) - Whether recipients can download documents.
- **attachDocumentsToEmail** (boolean) - Whether documents are attached to email notifications.
- **notifyEmail** (boolean) - Whether email notifications are sent.

#### Response Example
```json
{
  "id": "txn00000000000000000000000000000000",
  "name": "Quarterly Report Distribution",
  "method": "Email",
  "status": "Draft",
  "shareWith": {
    "targetType": "InvestmentEntities",
    "investmentEntityIds": [
      "inv00000000000000000000000000000000",
      "inv00000000000000000000000000000001"
    ]
  },
  "allowDownload": true,
  "attachDocumentsToEmail": false,
  "notifyEmail": true
}
```
```

--------------------------------

### Import Investments (Node.js)

Source: https://developers.anduintransact.com/reference/investments

This Node.js example shows how to import investments using the 'axios' library. It constructs the request with the correct URL, headers, and an example of the investment data payload. Ensure 'firm-id' is replaced with the actual firm ID and the data structure matches the API requirements.

```JavaScript
const axios = require('axios');

const firmId = 'YOUR_FIRM_ID'; // Replace with your firm ID
const apiUrl = `https://api.anduin.app/api/v1/idm/${firmId}/investments/import`;

const investmentData = [
  {
    // Example investment object structure
    // Replace with your actual investment data
    field1: 'value1',
    field2: 'value2'
  }
];

axios.post(apiUrl, investmentData, {
  headers: {
    'accept': 'application/json',
    'content-type': 'application/json'
  }
})
.then(response => {
  console.log('Import initiated successfully:', response.data);
})
.catch(error => {
  console.error('Error initiating import:', error.response ? error.response.data : error.message);
});
```

--------------------------------

### Get Standard Form Fields using Node.js

Source: https://developers.anduintransact.com/reference/form-fields

This example shows how to fetch standard form fields using Node.js. It utilizes the 'axios' library to make a GET request to the API endpoint.

```javascript
const axios = require('axios');

const getStandardFormFields = async (fundId) => {
  try {
    const response = await axios.get(`https://api.anduin.app/api/v1/fundsub/${fundId}/standardFormFields`, {
      headers: {
        'accept': 'application/json'
      }
    });
    return response.data;
  } catch (error) {
    console.error('Error fetching standard form fields:', error);
    throw error;
  }
};

// Example usage:
// getStandardFormFields('your-fund-id').then(fields => console.log(fields));
```

--------------------------------

### Import Investments (Ruby)

Source: https://developers.anduintransact.com/reference/investments

This Ruby example uses the 'httparty' gem to import investments. It sets up the POST request with the API endpoint, headers, and a sample investment data structure. Ensure 'your_firm_id' is replaced with the correct firm ID and the 'investment_data' adheres to the API's expected format.

```Ruby
require 'httparty'

firm_id = 'your_firm_id' # Replace with your firm ID
api_url = "https://api.anduin.app/api/v1/idm/#{firm_id}/investments/import"

investment_data = [
  {
    # Example investment object structure
    # Replace with your actual investment data
    field1: 'value1',
    field2: 'value2'
  }
]

headers = {
  'accept' => 'application/json',
  'content_type' => 'application/json'
}

response = HTTParty.post(api_url, body: investment_data.to_json, headers: headers)

if response.success?
  puts "Import initiated successfully: #{response.parsed_response}"
else
  puts "Error initiating import: #{response.code} - #{response.message}"
end
```

--------------------------------

### Import Investments (cURL)

Source: https://developers.anduintransact.com/reference/investments

This example demonstrates how to import investments using cURL. It specifies the POST request method, the API endpoint URL, and necessary headers for JSON content type and acceptance. Replace 'firm-id' with the actual firm ID.

```Shell
curl --request POST \
     --url https://api.anduin.app/api/v1/idm/firm-id/investments/import \
     --header 'accept: application/json' \
     --header 'content-type: application/json'
```

--------------------------------

### cURL GET Request to List Contacts

Source: https://developers.anduintransact.com/reference/contacts

Example of a cURL request to retrieve a list of contacts from the Anduin API. This demonstrates the basic structure for GET requests, including the URL and required headers.

```shell
curl --request GET \
     --url https://api.anduin.app/api/v1/idm/firm-id/contacts \
     --header 'accept: application/json'
```

--------------------------------

### POST /websites/developers_anduintransact_reference

Source: https://developers.anduintransact.com/reference/create-order-by-client

Creates a new order for a client. This endpoint allows for the submission of detailed order parameters and returns information about the created order.

```APIDOC
## POST /websites/developers_anduintransact_reference

### Description
Creates a new order for a client. This endpoint allows for the submission of detailed order parameters and returns information about the created order.

### Method
POST

### Endpoint
/websites/developers_anduintransact_reference

### Parameters
#### Request Body
- **CreateOrderByClientParams** (object) - Required - Parameters for creating an order by client.
  - **Map_String** (object) - Required - A map of strings.
    - **additionalProperties** (string) - Additional string properties for the map.

### Request Example
```json
{
  "CreateOrderByClientParams": {
    "Map_String": {
      "key1": "value1",
      "key2": "value2"
    }
  }
}
```

### Response
#### Success Response (200)
- **clientId** (string) - ID of the client.
- **clientName** (string) - Name of the client.
- **orderId** (string) - ID of the order.
- **mainInvestorEmail** (string) - Email of the main investor.
- **collaboratorEmails** (array[string]) - Emails of the collaborators.

#### Response Example
```json
{
  "clientId": "fdf0000000000000.fdv000000000",
  "clientName": "Example Client",
  "orderId": "txn0000000000000.fsb0000.lpp0000000",
  "mainInvestorEmail": "investor@example.com",
  "collaboratorEmails": [
    "collab1@example.com",
    "collab2@example.com"
  ]
}
```

#### Error Response (400)
- **message** (string) - Error message.
- **errorType** (string) - Type of the error.

#### Error Response (401)
- **message** (string) - Error message.
- **errorType** (string) - Type of the error.

#### Error Response (403)
- **message** (string) - Error message.
- **errorType** (string) - Type of the error.

#### Error Response (404)
- **message** (string) - Error message.
- **errorType** (string) - Type of the error.
```

--------------------------------

### Get File Download URL - Python Example

Source: https://developers.anduintransact.com/reference/file

This Python example utilizes the 'requests' library to retrieve a file download URL. It constructs the API endpoint URL dynamically using the file ID and includes the 'accept' header. The function returns the data from the API response, which includes the pre-signed URL.

```python
import requests

def get_file_download_url(file_id):
    url = f"https://api.anduin.app/api/v1/fundsub/files/{file_id}/url"
    headers = {
        'accept': 'application/json'
    }
    try:
        response = requests.get(url, headers=headers)
        response.raise_for_status()  # Raise an exception for bad status codes
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f"Error fetching file download URL: {e}")
        return None

# Example usage:
# file_data = get_file_download_url('your-file-id')
# if file_data:
#     print(file_data.get('url'))
```

--------------------------------

### Get Folder Structure using Ruby

Source: https://developers.anduintransact.com/reference/folder

This Ruby snippet illustrates how to fetch folder structure data via an HTTP GET request. It uses the 'net/http' library and demonstrates setting up the request with the correct URL and headers. Remember to substitute placeholder IDs.

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

data_room_id = 'YOUR_DATA_ROOM_ID'
folder_id = 'YOUR_FOLDER_ID'

uri = URI.parse("https://api.anduin.app/api/v1/dataroom/#{data_room_id}/folder/#{folder_id}")

request = Net::HTTP::Get.new(uri)
request['accept'] = 'application/json'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
  http.request(request)
end

puts response.body

```

--------------------------------

### Get Fund Information (Python)

Source: https://developers.anduintransact.com/reference/index

This Python example uses the 'requests' library to retrieve fund information. It constructs the API URL with the fund ID and sends a GET request with the 'accept: application/json' header. The function returns the JSON response data.

```python
import requests

def get_fund_info(fund_id):
    url = f"https://api.anduin.app/api/v1/fundsub/{fund_id}"
    headers = {
        'accept': 'application/json'
    }
    
    try:
        response = requests.get(url, headers=headers)
        response.raise_for_status()  # Raise an exception for bad status codes
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f"Error fetching fund information: {e}")
        return None

# Example usage:
# fund_data = get_fund_info('your-fund-id')
# if fund_data:
#     print(fund_data)
```

--------------------------------

### Create Webhook using cURL

Source: https://developers.anduintransact.com/reference/createwebhook

Demonstrates how to perform the initial validation request for setting up a webhook endpoint using cURL. This involves sending a GET request with a specific validation key header.

```shell
curl -X GET https:\\yourdomain.com -H 'x-anduin-webhook-validation-key: [RANDOM_VALIDATIONKEY]'
```

--------------------------------

### List Clients using cURL

Source: https://developers.anduintransact.com/reference/clients

This snippet demonstrates how to list clients using a cURL request. It includes the GET method, the API endpoint URL with a placeholder for the firm ID, and the necessary 'accept' header for JSON responses.

```shell
curl --request GET \
     --url https://api.anduin.app/api/v1/idm/firm-id/clients \
     --header 'accept: application/json'
```

--------------------------------

### Get Fund Webhooks (cURL)

Source: https://developers.anduintransact.com/reference/legacy-webhooks-1

Example cURL request to fetch all webhook endpoints for a given fund. This demonstrates the HTTP method, URL structure, and required headers.

```shell
curl --request GET \
     --url https://api.anduin.app/api/v1/fundsub/fund-id/webhook \
     --header 'accept: application/json'
```

--------------------------------

### Get Invitation Link (PHP)

Source: https://developers.anduintransact.com/reference/link

This PHP example demonstrates fetching an invitation link using cURL. It sets the URL with the fund ID and includes the 'accept' header for the request.

```php
<?php

$fundId = 'your-fund-id'; // Replace with the actual fund ID
$url = "https://api.anduin.app/api/v1/fundsub/{$fundId}/link";

$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_HTTPHEADER, array('accept: application/json'));

$response = curl_exec($ch);

if (curl_errno($ch)) {
    echo 'Error:' . curl_error($ch);
} else {
    echo $response;
}

curl_close($ch);
?>
```