### Get Template with Code Examples

Source: https://context7_llms

Retrieve detailed information about a specific process template using a GET request.

```JavaScript
const templateId = 'template-abc';

fetch(`/api/templates/${templateId}?include=steps,tags`, {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_API_TOKEN'
  }
})
.then(response => response.json())
.then(data => console.log('Template details:', data))
.catch(error => console.error('Error:', error));
```

```Python
import requests

template_id = 'template-abc'

headers = {
    'Authorization': 'Bearer YOUR_API_TOKEN'
}
response = requests.get(f'https://api.tallyfy.com/templates/{template_id}', params={'include': 'steps,tags'}, headers=headers)
print(response.json())
```

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

### Upload and Attach File with Code Examples

Source: https://context7_llms

Upload a file to get an asset reference, then link it to a task or process.

```JavaScript
const fileInput = document.getElementById('fileUpload');
const file = fileInput.files[0];
const taskId = 'task-123';

const formData = new FormData();
formData.append('file', file);

// 1. Upload the file
fetch('/api/files/upload', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer YOUR_API_TOKEN'
  },
  body: formData
})
.then(response => response.json())
.then(uploadResult => {
  const assetReference = uploadResult.assetId; // Assuming response contains assetId
  
  // 2. Attach the file to the task
  fetch(`/api/tasks/${taskId}/attach-file`, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': 'Bearer YOUR_API_TOKEN'
    },
    body: JSON.stringify({ assetReference: assetReference })
  })
  .then(response => response.json())
  .then(attachResult => console.log('File attached:', attachResult))
  .catch(error => console.error('Error attaching file:', error));
})
.catch(error => console.error('Error uploading file:', error));
```

```Python
import requests

file_path = 'path/to/your/file.pdf'
task_id = 'task-123'

# 1. Upload the file
with open(file_path, 'rb') as f:
    files = {'file': f}
    headers = {'Authorization': 'Bearer YOUR_API_TOKEN'}
    upload_response = requests.post('https://api.tallyfy.com/files/upload', headers=headers, files=files)
    upload_data = upload_response.json()
    asset_reference = upload_data.get('assetId') # Assuming response contains assetId

# 2. Attach the file to the task
if asset_reference:
    attach_payload = {'assetReference': asset_reference}
    headers = {
        'Content-Type': 'application/json',
        'Authorization': 'Bearer YOUR_API_TOKEN'
    }
    attach_response = requests.post(f'https://api.tallyfy.com/tasks/{task_id}/attach-file', headers=headers, json=attach_payload)
    print(attach_response.json())
```

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

### Launch Tallyfy Process in Go

Source: https://tallyfy.com/products/pro/integrations/open-api/code-samples/processes/launch-process/index

Demonstrates how to make an HTTP POST request to the Tallyfy API to launch a process. It includes setting headers, making the request, reading the response, and handling status codes. Requires standard Go libraries like `net/http` and `io/ioutil`.

```go
package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io/ioutil"
	"net/http"
)

func LaunchTallyfyProcess(accessToken string, processPayload map[string]interface{}) {
	url := "https://go.tallyfy.com/api/organizations/YOUR_ORGANIZATION_ID/runs"

	payloadBytes, err := json.Marshal(processPayload)
	if err != nil {
		fmt.Printf("Error marshalling payload: %v\n", err)
		return
	}

	req, err := http.NewRequest("POST", url, bytes.NewBuffer(payloadBytes))
	if err != nil {
		fmt.Printf("Error creating POST request: %v\n", err)
		return
	}



	req.Header.Set("Authorization", "Bearer "+accessToken)
	req.Header.Set("Accept", "application/json")
	req.Header.Set("X-Tallyfy-Client", "APIClient")
	req.Header.Set("Content-Type", "application/json")


	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		fmt.Printf("Error making POST request: %v\n", err)
		return
	}
	defer resp.Body.Close()


	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		fmt.Printf("Error reading response body: %v\n", err)
		return
	}


	// Check for successful status codes (e.g., 200 OK or 201 Created)
	if resp.StatusCode != http.StatusOK && resp.StatusCode != http.StatusCreated {
		fmt.Printf("Failed to launch process. Status: %d\nBody: %s\n", resp.StatusCode, string(body))
		return
	}


	fmt.Println("Successfully launched process:")
	  // Pretty print JSON response
	  var prettyJSON bytes.Buffer
	  if err := json.Indent(&prettyJSON, body, "", "  "); err == nil {
		  fmt.Println(prettyJSON.String())
	  } else {
		fmt.Println(string(body))
	  }
	// TODO: Unmarshal response JSON into Go structs to get run ID etc.
  }

```

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

### Test Tallyfy API Authentication

Source: https://tallyfy.com/products/pro/integrations/open-api/api-clients/postman/authentication-setup/index

A simple GET request example to test if Tallyfy API authentication is correctly configured. It targets the '/me' endpoint for an organization and requires the access token and client header to be set correctly.

```plaintext
GET {{TALLYFY_BASE_URL}}/organizations/{{TALLYFY_ORG_ID}}/me

Headers:
Authorization: Bearer {{TALLYFY_ACCESS_TOKEN}}
X-Tallyfy-Client: APIClient
```

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

### Markdown Collection Description for Tallyfy API

Source: https://tallyfy.com/products/pro/integrations/open-api/api-clients/postman/collection-organization/index

A detailed markdown example for a Postman collection description, covering overview, prerequisites, quick start guide, required environment variables, and security best practices for the Tallyfy API.

```markdown
# Tallyfy API Collection v2.1


## 🎯 Overview
This collection provides complete coverage of Tallyfy's REST API for workflow automation.
Designed for developers, QA engineers, and integration specialists.


## 📋 Prerequisites
- Tallyfy account with API access enabled
- Client ID and Secret from Settings > Integrations > REST API
- Basic understanding of OAuth 2.0 and REST APIs
- Postman v10.0+ (for advanced scripting features)


## 🚀 Quick Start
1. **Import collection**: Use "Import" button and select this file
2. **Create environment**:
   - Name: "Tallyfy Production" (or "Staging")
   - Add required variables (see Variables section below)
3. **Run setup**: Execute "[SETUP] Get Access Token" request first
4. **Verify connection**: Run "[TEST] Authentication Check"
5. **Explore workflows**: Start with "[DEMO] Workflows" folder


## 🔧 Required Environment Variables
| Variable |
|----------|----------|
| `TALLYFY_BASE_URL` | API base URL | `https://go.tallyfy.com/api` |
| `TALLYFY_CLIENT_ID` | OAuth client ID | `3MVG9...` |
| `TALLYFY_CLIENT_SECRET` | OAuth client secret | ⚠️ Store in vault |
| `TALLYFY_USERNAME` | Your email | `you@company.com` |
| `TALLYFY_PASSWORD` | Your password | ⚠️ Store in vault |
| `TALLYFY_ORG_ID` | Organization ID | `org_abc123` |


## 🛡️ Security Best Practices
- **Use Postman Vault** for sensitive data (passwords, secrets)
- **Never commit** environment files with real credentials
- **Rotate credentials** every 90 days
- **Use separate** environments for prod/staging/dev
```

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

### Launch Tallyfy Process in C++

Source: https://tallyfy.com/products/pro/integrations/open-api/code-samples/processes/launch-process/index

Provides a C++ example using the C++ REST SDK (Casablanca) to launch a Tallyfy process. It demonstrates setting up the HTTP client, constructing the request with headers and JSON body, and handling the asynchronous response. Requires the C++ REST SDK.

```cpp
#include <iostream>
#include <string>
#include <vector>
#include <cpprest/http_client.h>
#include <cpprest/json.h>


using namespace web;
using namespace web::http;
using namespace web::http::client;
using namespace web::json;


pplx::task<void> LaunchTallyfyProcess(const value& launchPayload)
{
    utility::string_t accessToken = U("YOUR_PERSONAL_ACCESS_TOKEN");
    utility::string_t orgId = U("YOUR_ORGANIZATION_ID");
    utility::string_t apiUrl = U("https://go.tallyfy.com/api/organizations/") + orgId + U("/runs");


    http_client client(apiUrl);
    http_request request(methods::POST);


    request.headers().add(U("Authorization"), U("Bearer ") + accessToken);
    request.headers().add(U("Accept"), U("application/json"));
    request.headers().add(U("X-Tallyfy-Client"), U("APIClient"));
    request.headers().set_content_type(U("application/json"));
    request.set_body(launchPayload);


    return client.request(request).then([](http_response response)
    {
        return response.extract_json().then([response](pplx::task<value> task)
        {
            try {
                value const & body = task.get();
                // API might return 201 Created
                if (response.status_code() == status_codes::OK || response.status_code() == status_codes::Created) {
                    std::wcout << L"Successfully launched process:\n" << body.serialize() << std::endl;
                    // Extract new run ID: body[U("data")][U("id")].as_string();
                } else {
                    std::wcerr << L"Failed to launch process. Status: " << response.status_code() << L"\nResponse: " << body.serialize() << std::endl;
                }
            } catch (const http_exception& e) {
                 std::wcerr << L"HTTP exception during launch process: " << e.what() << std::endl;
            } catch (const std::exception& e) {
                std::wcerr << L"Exception during launch process response handling: " << e.what() << std::endl;
            }
        });
    });
}


int main() {
    try {
        value payload = value::object();
        payload[U("checklist_id")] = value::string(U("TEMPLATE_ID_TO_LAUNCH")); // Required
        payload[U("name")] = value::string(U("Process Launched via C++")); // Required
        payload[U("summary")] = value::string(U("Launched using C++ REST SDK"));


        // Example prerun data
        value prerunArray = value::array();
        value prerunField1 = value::object();
        prerunField1[U("kickoff_field_id_1")] = value::string(U("C++ Client Inc."));
        prerunArray[0] = prerunField1;
        payload[U("prerun")] = prerunArray;


        // Example task override
        value tasksObj = value::object();
        value taskOverride = value::object();
        value usersArray = value::array();
        usersArray[0] = value::number(12345);
        taskOverride[U("users")] = usersArray;
        tasksObj[U("step_id_abc")] = taskOverride;
        payload[U("tasks")] = tasksObj;


        LaunchTallyfyProcess(payload).wait();
    } catch (const std::exception &e) {
        std::cerr << "Error in main: " << e.what() << std::endl;
    }
    return 0;
}
// Requires C++ REST SDK (Casablanca)

```

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

### Example: Create a Magic Link to Launch a Process

Source: https://tallyfy.com/products/pro/launching/triggers/magic-links/index

This example demonstrates how to construct a magic link URL to initiate a Tallyfy process from a specific template. It includes setting a process name and pre-filling kick-off form fields.

```APIDOC
Example URL Structure:

https://your-tallyfy-domain.com/magic-link?action=launch_process&template_id=TEMPLATE_XYZ&process_name=New%20Project%20Initiation&kickoff_field_values[project_type]=Design&kickoff_field_values[client_name]=Acme%20Corp
```

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

### Fetch Tallyfy Asset Metadata in C++

Source: https://tallyfy.com/products/pro/integrations/open-api/code-samples/files/get-file-metadata/index

This C++ example utilizes the C++ REST SDK (Casablanca) to fetch asset metadata from the Tallyfy API. It shows how to construct the request, set headers for authentication and content type, and handle the asynchronous response. You need to have the C++ REST SDK installed and configured.

```C++
#include <iostream>
#include <string>
#include <cpprest/http_client.h>
#include <cpprest/filestream.h>


using namespace web;
using namespace web::http;
using namespace web::http::client;


pplx::task<void> GetAssetMetadata(const utility::string_t& assetId)
{
  utility::string_t accessToken = U("YOUR_PERSONAL_ACCESS_TOKEN"); // Replace
  utility::string_t orgId = U("YOUR_ORGANIZATION_ID"); // Replace
  utility::string_t apiUrl = U("https://go.tallyfy.com/api/organizations/") + orgId + U("/assets/") + assetId;


  http_client client(apiUrl);


  http_request request(methods::GET);
  request.headers().add(U("Authorization"), U("Bearer ") + accessToken);
  request.headers().add(U("Accept"), U("application/json"));
  request.headers().add(U("X-Tallyfy-Client"), U("APIClient"));


  return client.request(request).then([assetId](http_response response)
  {
    utility::string_t assetIdW = assetId;
    if (response.status_code() == status_codes::OK)
    {
      return response.extract_json().then([assetIdW](json::value v)
      {
           std::wcout << L"Successfully retrieved metadata for asset " << assetIdW << L":\n" << v.serialize() << std::endl;
           // Access fields e.g., v[U("data")][0][U("filename")].as_string();
      });
    }
    else
    {
      // Handle error
      return response.extract_string().then([response, assetIdW](utility::string_t body)
      {
          std::wcerr << L"Failed to get metadata for asset " << assetIdW << L". Status: " << response.status_code() << std::endl;
          std::wcerr << L"Response Body: " << body << std::endl;
          // Indicate error - throwing exception is another option
          return pplx::task_from_exception<void>(std::runtime_error("API request failed"));
      });
    }
  });
}


int main()
{
  utility::string_t assetToGet = U("ASSET_ID_TO_GET_METADATA"); // Replace
  try
  {
    GetAssetMetadata(assetToGet).wait();
  }
  catch (const std::exception &e)
  {
    std::cerr << "Error: " << e.what() << std::endl;
  }
  return 0;
}
// Note: Requires C++ REST SDK (Casablanca).
// Proper JSON parsing (checking types, field existence) is recommended.

```

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

### C# Example Usage for Template Creation

Source: https://tallyfy.com/products/pro/integrations/open-api/code-samples/templates/create-template/index

Provides a commented-out example demonstrating how to instantiate a `TemplatePayload` object with necessary details and then call the `CreateTemplateAsync` method to initiate the template creation process.

```csharp
// Example Usage:
      // static async Task Main(string[] args)
      // {
      //     var newTemplate = new TemplatePayload {
      //         Title = "C# API Template Example",
      //         Summary = "Created from C#",
      //         Type = "procedure"
      //     };
      //     await CreateTemplateAsync(newTemplate);
      // }
  }
```

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

### Sample API Request for Process Launch

Source: https://tallyfy.com/products/pro/launching/triggers/via-api/index

Provides a concrete example of an HTTP POST request to the Tallyfy API for launching a process. It demonstrates the correct formatting for headers, including authorization and content type, and the structure of the JSON payload with template ID and kick-off data.

```HTTP
POST /api/processes HTTP/1.1
Host: go.tallyfy.com/api
Authorization: Bearer YOUR_API_TOKEN
Content-Type: application/json

{
  "template_id": "your-template-id",
  "name": "API Triggered Process - Customer Onboarding",
  "kickoff_fields": {
    "customer_name": "Acme Corporation",
    "contract_value": 15000,
    "start_date": "2023-05-01T00:00:00.000Z"
  }
}
```

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

### Get Specific Group API

Source: https://tallyfy.com/products/pro/integrations/open-api/code-samples/members/get-member/index

The GET endpoint allows retrieving detailed information about a specific group within an organization using its unique ID. It requires authenticated API requests and includes code examples.

```APIDOC
Groups > Get group

GET /groups/{groupId}

Retrieves detailed information for a specific group.

Description:
This endpoint fetches comprehensive details for a single group identified by its unique ID. Authentication is required.

Parameters:
- Authorization: Bearer <token> (Required)
- groupId: The unique identifier for the group (Path Parameter, Required)

Returns:
A JSON object containing the group's details, including ID, name, description, logo, member list, and timestamps.

Error Handling:
- 404: Group not found if the groupId is invalid.
- 401: Unauthorized if the token is missing or invalid.
```

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

### SAML SSO Integration Guides

Source: https://tallyfy.com/products/pro/integrations/authentication/index

Comprehensive guides for integrating Tallyfy with various identity providers using SAML-based Single Sign-On. These guides detail the configuration steps, user provisioning, and authentication flow setup.

```APIDOC
Azure AD SAML SSO Integration with Tallyfy:
  Description: Establishes SAML-based Single Sign-On integration between Microsoft Azure Active Directory and Tallyfy. Covers enterprise application creation, SAML configuration, and user provisioning setup.
  Purpose: Enables automated authentication for existing users and automatic account creation for new users accessing through the designated SSO URL.
  Key Steps:
    - Identity Provider Selection (Azure AD)
    - Tallyfy Support Engagement
    - Collaborative Implementation (Enterprise App Creation, SAML Config)
    - User Acceptance Testing
    - Organization-wide Deployment
  Related Guides:
    - Integrate Google Suite
    - Integrate Okta
    - Integrate OneLogin
```

```APIDOC
Google Suite SAML SSO Integration with Tallyfy:
  Description: Outlines the process of implementing SAML-based Single Sign-On between Google Workspace and Tallyfy.
  Purpose: Facilitates automated authentication and user provisioning.
  Key Steps:
    - Identity Provider Selection (Google Workspace)
    - Tallyfy Support Engagement
    - Collaborative Implementation (Application Setup, Attribute Mapping, User Access Config)
    - User Acceptance Testing
    - Organization-wide Deployment
  Related Guides:
    - Integrate Azure AD
    - Integrate Okta
    - Integrate OneLogin
```

```APIDOC
Okta SAML SSO Integration with Tallyfy:
  Description: Provides a walkthrough for implementing SAML-based Single Sign-On between Okta and Tallyfy.
  Purpose: Enables automated user authentication and provisioning.
  Key Steps:
    - Identity Provider Selection (Okta)
    - Tallyfy Support Engagement
    - Collaborative Implementation (Application Configuration, User Attribute Mapping, SSO Activation)
    - User Acceptance Testing
    - Organization-wide Deployment
  Related Guides:
    - Integrate Azure AD
    - Integrate Google Suite
    - Integrate OneLogin
```

```APIDOC
OneLogin SAML SSO Integration with Tallyfy:
  Description: A comprehensive walkthrough for setting up SAML Single Sign-On between OneLogin and Tallyfy.
  Purpose: Enables user provisioning and tests the authentication flow.
  Key Steps:
    - Identity Provider Selection (OneLogin)
    - Tallyfy Support Engagement
    - Collaborative Implementation (Application Connector Creation, SAML Settings Configuration, User Provisioning)
    - User Acceptance Testing
    - Organization-wide Deployment
  Related Guides:
    - Integrate Azure AD
    - Integrate Google Suite
    - Integrate Okta
```

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

### Tallyfy Sign-up and Organization Creation Steps

Source: https://tallyfy.com/products/pro/tutorials/how-can-i-create-a-new-tallyfy-account/index

Provides a step-by-step guide for users to create a Tallyfy account and establish their organization. It details the sign-up process, including options for using existing Microsoft or Google accounts, and mentions the initial welcome task provided to new organizations.

```text
1. Go to the Tallyfy® sign-up page: https://tallyfy.com/start/
2. Fill in your details (name, email, password).
3. Using your existing Microsoft or Google account to sign up is often easier.
4. Follow the prompts to finish creating your user account and set up your first organization.
```

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

### Example Tallyfy Launch URL with Query Parameters

Source: https://tallyfy.com/products/pro/launching/how-to-launch-a-tallyfy-process-from-a-webform/index

Demonstrates the format of a Tallyfy process launch URL. It includes the base launch URL and appends form data as URL-encoded query parameters, where parameter names must match Tallyfy kick-off form field names. This allows external web forms to pre-fill data when launching a Tallyfy process.

```text
https://example.tallyfy.com/launch/xyz?customer_name=John%20Doe&customer_email=john.doe%40example.com
```

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

### Get Group API

Source: https://tallyfy.com/products/pro/integrations/open-api/code-samples/files/get-file-metadata/index

The GET endpoint allows retrieving detailed information about a specific group within an organization. It uses the group's unique ID and supports authenticated API requests. Code examples are available in multiple programming languages.

```APIDOC
GET /groups/{group_id}

Description:
  Retrieves detailed information for a specific group within an organization.

Parameters:
  - group_id (string, required): The unique identifier for the group.

Authentication:
  Requires API key or token in headers.

Returns:
  JSON object containing group details.
  Example:
  {
    "id": "group456",
    "name": "Development Team",
    "members": ["user1", "user2"]
  }

Error Handling:
  404 Not Found if the group_id does not exist.
  403 Forbidden if the user lacks permissions.
```

```JavaScript
fetch('/groups/{group_id}', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_API_KEY'
  }
})
.then(response => response.json())
.then(data => {
  console.log(data);
});
```

```Python
import requests

headers = {'Authorization': 'Bearer YOUR_API_KEY'}
response = requests.get('/groups/{group_id}', headers=headers)

if response.status_code == 200:
    print(response.json())
```

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

### Newman Setup and Verification

Source: https://tallyfy.com/products/pro/integrations/open-api/api-clients/postman/advanced-patterns/index

Installs the Newman CLI tool globally using npm, which is required for running Postman collections from the command line, and verifies the installation by checking the version.

```bash
# Install Newman (requires Node.js v16+)
npm install -g newman


# Verify installation
newman --version
```

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

### Tallyfy Pro Tutorials - How-to Guides

Source: https://tallyfy.com/products/pro/miscellaneous/index

Explains the purpose of Tallyfy's how-to guides, which provide task-focused instructions and practical implementation approaches to help users resolve common workflow challenges and enhance business process efficiency.

```APIDOC
TallyfyProTutorials_HowToGuides:
  description: "Tallyfy’s how-to guides offer task-focused instructions and real-world implementation approaches to help users solve common workflow challenges and optimize their business processes more effectively."
  purpose: "Provide task-focused instructions and real-world implementation approaches."
  benefits:
    - Solve common workflow challenges
    - Optimize business processes
```

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

### Create Template with Code Examples

Source: https://context7_llms

Create new process templates within organizations by sending a POST request with template configuration.

```JavaScript
const templateData = {
  title: "New Project Workflow",
  type: "Project",
  ownership: "team-a",
  permissions: "public"
};

fetch('/api/templates', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_API_TOKEN'
  },
  body: JSON.stringify(templateData)
})
.then(response => response.json())
.then(data => console.log('Template created:', data))
.catch(error => console.error('Error:', error));
```

```Python
import requests
import json

template_data = {
    "title": "New Project Workflow",
    "type": "Project",
    "ownership": "team-a",
    "permissions": "public"
}

headers = {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_API_TOKEN'
}

response = requests.post('https://api.tallyfy.com/templates', headers=headers, data=json.dumps(template_data))
print(response.json())
```

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

### Get Guest with Code Examples

Source: https://context7_llms

Retrieve specific guest user details within an organization using their email address.

```JavaScript
const guestEmail = 'guest@example.com';

fetch(`/api/guests/${guestEmail}?include=accessHistory`, {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_API_TOKEN'
  }
})
.then(response => response.json())
.then(data => console.log('Guest details:', data))
.catch(error => console.error('Error:', error));
```

```Python
import requests

guest_email = 'guest@example.com'

headers = {
    'Authorization': 'Bearer YOUR_API_TOKEN'
}
response = requests.get(f'https://api.tallyfy.com/guests/{guest_email}', params={'include': 'accessHistory'}, headers=headers)
print(response.json())
```

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

### Considerations for Auto-launch Templates

Source: https://tallyfy.com/products/pro/settings/org-settings/how-to-auto-launch-templates-for-new-members/index

Key points and limitations to keep in mind when using the auto-launch template feature for new member onboarding.

```APIDOC
Configuration_Constraints:
  - Timing: Template launches immediately upon account activation.
  - Uniqueness: Only one template can be configured for auto-launch at a time.
  - Naming: Launched processes will use the organization's default naming conventions.
  - Monitoring: Administrators can track completion progress via the 'Tracker view'.
```

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

### C# Example: Get Application Access Token

Source: https://tallyfy.com/products/pro/integrations/open-api/code-samples/authentication/client-credentials-flow/index

Demonstrates how to make an HTTP request in C# to obtain an application-level access token from the Tallyfy OAuth endpoint. It includes handling the response, deserializing JSON, and managing potential HTTP request exceptions. The example also shows how to define a class for the response structure.

```C#
using System;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text.Json.Serialization;
using System.Threading.Tasks;

public class TallyfyAuth
{
    // Placeholder for actual client ID and secret
    private const string ClientId = "YOUR_CLIENT_ID";
    private const string ClientSecret = "YOUR_CLIENT_SECRET";
    private const string BaseUrl = "https://go.tallyfy.com"; // Verify with Tallyfy Support

    public static async Task GetClientCredentialsToken()
    {
        using (var client = new HttpClient())
        {
            client.BaseAddress = new Uri(BaseUrl);
            client.DefaultRequestHeaders.Accept.Clear();
            client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));

            // Prepare the request body for client credentials grant
            var requestBody = new FormUrlEncodedContent(new[] 
            {
                new KeyValuePair<string, string>("grant_type", "client_credentials"),
                new KeyValuePair<string, string>("client_id", ClientId),
                new KeyValuePair<string, string>("client_secret", ClientSecret)
            });

            try
            {
                // The OAuth endpoint might be at the root or /api path - verify with Tallyfy docs
                var response = await client.PostAsync("/oauth/token", requestBody);

                if (response.IsSuccessStatusCode)
                {
                    var responseBody = await response.Content.ReadAsStringAsync();
                    // TODO: Deserialize JSON (e.g., using System.Text.Json or Newtonsoft.Json)
                    // var tokenData = JsonSerializer.Deserialize<TokenResponse>(responseBody);
                    // Console.WriteLine($"Access Token: {tokenData.AccessToken}");
                    Console.WriteLine("Token obtained successfully.");
                    Console.WriteLine(responseBody);
                }
                else
                {
                    Console.WriteLine($"Error: {response.StatusCode}");
                    var errorBody = await response.Content.ReadAsStringAsync();
                    Console.WriteLine(errorBody);
                }
            }
            catch (HttpRequestException e)
            {
                Console.WriteLine($"Request Exception: {e.Message}");
            }
        }
    }

    // Example usage (e.g., in a Main method)
    // static async Task Main(string[] args)
    // {
    //     await GetClientCredentialsToken();
    // }

    // Define a class to deserialize the JSON response if needed
    public class TokenResponse
    {
        [JsonPropertyName("access_token")]
        public string AccessToken { get; set; }
        [JsonPropertyName("token_type")]
        public string TokenType { get; set; }
        [JsonPropertyName("expires_in")]
        public int ExpiresIn { get; set; }
    }
}
```

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

### Set up Auto-launch Templates for New Members

Source: https://tallyfy.com/products/pro/settings/org-settings/how-to-auto-launch-templates-for-new-members/index

Step-by-step instructions for configuring Tallyfy Pro to automatically launch a template for new members upon their account activation. This process ensures consistent onboarding and reduces manual administrative effort.

```APIDOC
UI_Steps:
  - Action: Navigate to Settings
    Details: Access the main settings area of your Tallyfy organization.
  - Action: Click the Organization tab
    Details: Select the 'Organization' section within the settings.
  - Action: Select Customization
    Details: Navigate to the 'Customization' sub-section.
  - Action: Locate 'Launch template for new members?' setting
    Details: Find the specific configuration option for auto-launching templates.
  - Action: Select template from dropdown
    Details: Choose the desired onboarding template from the available list.
  - Action: Click Save Changes
    Details: Confirm and apply the selected settings at the bottom of the page.
```

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

### SAML SSO Integration Guide

Source: https://context7_llms

Provides comprehensive guides for integrating Tallyfy with enterprise identity providers using SAML-based Single Sign-On. This includes setup for Azure AD, Okta, Google Suite, and OneLogin, enabling centralized authentication, automated user provisioning, and enhanced security.

```APIDOC
Tallyfy SAML SSO Integration:

This documentation covers the process of establishing SAML-based Single Sign-On (SSO) between Tallyfy and various enterprise identity providers (IdPs).

Key Features:
- Centralized authentication for users.
- Automated account provisioning and de-provisioning.
- Enhanced security by leveraging existing corporate credentials.
- Optional SSO-only enforcement for compliance.

Supported Identity Providers:
- Microsoft Azure Active Directory (Azure AD)
- Okta
- Google Workspace
- OneLogin

General Integration Steps:
1.  **Enterprise Application Creation**: Create a new enterprise application within your IdP.
2.  **SAML Configuration**: Configure SAML settings in both the IdP and Tallyfy, including:
    - Entity ID (Audience URI)
    - Assertion Consumer Service (ACS) URL
    - Identity Provider Single Sign-On URL
    - Signing Certificate
3.  **User Attribute Mapping**: Map user attributes (e.g., email, first name, last name) from the IdP to Tallyfy.
4.  **User Provisioning Setup**: Configure automated user provisioning (if supported by the IdP and Tallyfy integration) to create, update, and disable user accounts.
5.  **SSO Activation & Testing**: Enable SSO in Tallyfy and test the authentication flow by accessing Tallyfy through the designated SSO URL.

Specific Provider Notes:

**Microsoft Azure AD Integration:**
- Involves creating an enterprise application in Azure AD.
- Configuring SAML settings with Azure AD's metadata.
- Setting up user assignment and provisioning.

**Okta Integration:**
- Requires application configuration within Okta.
- User attribute mapping for seamless data transfer.
- SSO activation and testing the authentication flow.

**Google Workspace Integration:**
- Involves application setup within Google Workspace.
- Attribute mapping and user access configuration for automated authentication.

**OneLogin Integration:**
- Setting up an application connector in OneLogin.
- Configuring SAML settings and enabling user provisioning.

Error Conditions:
- Incorrect SAML configuration (e.g., mismatched URLs, invalid certificates).
- User attribute mapping errors.
- Issues with user provisioning or de-provisioning.
- Network connectivity problems between IdP and Tallyfy.
```

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

### List Tallyfy Process Tasks

Source: https://tallyfy.com/products/pro/integrations/open-api/code-samples/tasks/list-process-tasks/index

Demonstrates how to make an HTTP GET request to the Tallyfy API to retrieve a list of tasks for a given process run. Includes setting up the HTTP client, constructing the request with necessary headers (Authorization, Accept, X-Tallyfy-Client), and handling the response, including status codes and potential errors. The Java example uses `java.net.http.HttpClient`, Go uses `net/http`, and C++ uses `cpprest`.

```java
HttpClient client = HttpClient.newBuilder()
        .connectTimeout(Duration.ofSeconds(10))
        .build();


HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create(apiUrl))
        .header("Authorization", "Bearer " + accessToken)
        .header("Accept", "application/json")
        .header("X-Tallyfy-Client", "APIClient")
        .GET()
        .build();


try {
    HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());


    if (response.statusCode() == 200) {
        System.out.println("Successfully listed tasks for process " + runId + ":");
        System.out.println(response.body());
        // TODO: Consider parsing JSON response using Jackson/Gson
    } else {
        System.err.println("Failed to list tasks for process " + runId + ". Status: " + response.statusCode());
        System.err.println("Response Body: " + response.body());
    }
} catch (IOException | InterruptedException e) {
    System.err.println("Request failed: " + e.getMessage());
    Thread.currentThread().interrupt();
} catch (Exception e) {
     System.err.println("An unexpected error occurred: " + e.getMessage());
     e.printStackTrace();
}
```

```go
package main


import (
  "bytes"
  "encoding/json"
  "fmt"
  "io/ioutil"
  "net/http"
  "net/url"
  "os"
    "time"
)


func main() {
  accessToken := os.Getenv("TALLYFY_ACCESS_TOKEN")
    if accessToken == "" { accessToken = "YOUR_PERSONAL_ACCESS_TOKEN" }
  orgId := os.Getenv("TALLYFY_ORG_ID")
    if orgId == "" { orgId = "YOUR_ORGANIZATION_ID" }
    runId := "PROCESS_RUN_ID" // ID of the specific process run
  baseURL := fmt.Sprintf("https://go.tallyfy.com/api/organizations/%s/runs/%s/tasks", orgId, runId)


    // Optional: Add query parameters
    queryParams := url.Values{}
   queryParams.Add("status", "active")
  queryParams.Add("with", "step")
  queryParams.Add("sort", "position")


  apiUrl := baseURL
  if len(queryParams) > 0 {
       apiUrl += "?" + queryParams.Encode()
  }


client := &http.Client{Timeout: 15 * time.Second}
req, err := http.NewRequest("GET", apiUrl, nil)
  if err != nil {
      fmt.Printf("Error creating list process tasks request for run %s: %v\n", runId, err)
      return
  }


req.Header.Set("Authorization", "Bearer "+accessToken)
req.Header.Set("Accept", "application/json")
req.Header.Set("X-Tallyfy-Client", "APIClient")


resp, err := client.Do(req)
  if err != nil {
      fmt.Printf("Error executing list process tasks request for run %s: %v\n", runId, err)
      return
  }
  defer resp.Body.Close()


body, err := ioutil.ReadAll(resp.Body)
  if err != nil {
      fmt.Printf("Error reading list process tasks response body for run %s: %v\n", runId, err)
      return
  }


if resp.StatusCode != http.StatusOK {
  fmt.Printf("Failed to list tasks for process %s. Status: %d\nBody: %s\n", runId, resp.StatusCode, string(body))
  return
}


fmt.Printf("Successfully listed tasks for process %s:\n", runId)
  // Pretty print JSON response
  var prettyJSON bytes.Buffer
  if err := json.Indent(&prettyJSON, body, "", "  "); err == nil {
      fmt.Println(prettyJSON.String())
  } else {
    fmt.Println(string(body))
  }
// TODO: Unmarshal JSON into a slice of task structs if needed
}
```

```cpp
#include <iostream>
#include <string>
#include <cpprest/http_client.h>
#include <cpprest/json.h>


using namespace web;
using namespace web::http;
using namespace web::http::client;
using namespace web::json;


pplx::task<void> ListTallyfyProcessTasks(const utility::string_t& runId)
{
    utility::string_t accessToken = U("YOUR_PERSONAL_ACCESS_TOKEN");
    utility::string_t orgId = U("YOUR_ORGANIZATION_ID");


    uri_builder builder(U("https://go.tallyfy.com/api/organizations/"));
    builder.append_path(orgId);
    builder.append_path(U("runs"));
    builder.append_path(runId);
    builder.append_path(U("tasks"));
    builder.append_query(U("with"), U("step,form_fields")); // Example query parameters
    builder.append_query(U("sort"), U("position"));
    utility::string_t apiUrl = builder.to_string();


    http_client client(apiUrl);
    http_request request(methods::GET);


    request.headers().add(U("Authorization"), U("Bearer ") + accessToken);
    request.headers().add(U("Accept"), U("application/json"));
    request.headers().add(U("X-Tallyfy-Client"), U("APIClient"));


    return client.request(request).then([runId](http_response response)
    {

```

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

### Gemma 3n Quick Start with Ollama and MLX

Source: https://tallyfy.com/products/pro/integrations/computer-ai-agents/local-computer-use-agents/index

Provides bash commands for installing and running Gemma 3n locally. It covers installation via Ollama for general use and using MLX on Apple Silicon for advanced multimodal capabilities, including a sample prompt for analysis.

```bash
# Install via Ollama (easiest option)
ollama pull gemma3n
llm install llm-ollama
llm -m gemma3n:latest "Analyze this screenshot and suggest automation opportunities"
```

```bash
# Or use MLX on Apple Silicon for full multimodal capabilities
uv run --with mlx-vlm mlx_vlm.generate \
  --model gg-hf-gm/gemma-3n-E4B-it \
  --prompt "Transcribe and analyze this interface" \
  --image screenshot.jpg
```