Transphurr Documentation

Introduction

Welcome to Transphurr – your ultimate solution for secure, seamless, and personalized file transfers. Empower your team with advanced organizational settings, custom branding, and detailed transfer management from an intuitive dashboard. Start transferring smarter today!

Features

Organizational Settings: Manage file types and user-specific transfer limits.
Transfer History: View and control transfer activities, with options to block access.
Custom Mail Templates: Create reusable email templates for consistent communication.
Managed Transfers: Set expiry times and download limits for secure file sharing.
Branding: Personalize emails and download pages with your company logo.
Dashboard: Monitor transfer activities, storage, and usage trends.
API Integration: Automate file transfers and integrate with third-party systems.

Getting Started

Visit transphurr.com and click the "Register Now" button under your chosen plan, or use the "Register" link at the top-right corner.
Choose a Plan:
- Free Plan: ₹0/year, 1 GB storage, max 10 recipients.
- Basic Plan: ₹65.5/year, 50 GB storage, max 20 recipients.
- Standard Plan: ₹165.5/year, 100 GB storage, max 30 recipients.

Fill in your details (name, email, password) to create an account.

After signing up, a verification email has been sent. Please check your email and activate your account.

Click the activation button.

Once you click the activation button, you'll receive an email confirming your account is now active.

To log in, enter your email and password, then click the 'Login' button.

Manage Subscription

Subscription

After logging in, activate your subscription. Once you're on the dashboard, go to the menu on the right, click 'Manage Subscription', then select the 'Subscription' submenu. Before making the payment, please fill in your billing details.

To make the payment, click the 'Pay Now' button displayed at the top and complete the payment process.

After clicking the 'Pay Now' button, you will be redirected to the payment page. Please read the terms and conditions, check the checkbox, and then click the 'Proceed to Payment' button.

Once your payment is complete, you will be automatically redirected to the subscription page, and a confirmation message will appear.

Payment History

If you want to view your payment history, go to the sidebar, click 'Manage Subscription', then choose 'Payment History'. Your past payments will be shown there.

Bills

To view and download your invoices, go to the sidebar, click on 'Manage Subscription', then select 'Bills'. Your past bills will be displayed there. To download an invoice, click the view icon.

Once you click the view icon, you'll be taken to the invoice page. There, you can download the invoice by clicking the 'Print/Save' button

Subscription Cancel

If you want to cancel your account for any reason, go to the sidebar, click 'Manage Subscription', then select the 'Cancel Subscription' option. Choose a reason from the 'Reason for Leaving' dropdown and optionally provide additional feedback.

Quick Send Feature (No Login Required)

You can use the Quick Send feature to transfer files up to 1 GB without logging in.

To do this:

Go to the Home page.
Scroll to the bottom and click the Quick Send button.

A popup will appear. Select the file you want to send and fill in the recipient details.

Click "Transfer" to send.

Dashboard: Monitor and Manage Your Transfers

The transphurr dashboard provides a comprehensive overview of your file transfer activities, helping you monitor and manage everything efficiently. Here’s what you can do:

View Total Counts

Total number of transfers initiated
Total number of downloaded files
Total number of users in your account
Total number of recipients added

Click on each metric (Transfers, Downloads, Users, Recipients) to quickly navigate to their respective detailed pages for more insights.

Monitor Storage

Available Storage: View the total allocated storage (e.g., 500 GB)
Used Storage: See the amount of storage currently used (e.g., 14.55 KB)

The circular gauge visually displays your storage usage as a percentage (e.g., 0% used).

Analyze Usage with Graphs

The usage graph shows the number of transfers made each month over the year. Identify peak months (e.g., a spike in May) to understand your transfer patterns. You can download the graph for further analysis.

Check Transfer History

Below the graphs, the Transfer History table lists all your transfers with detailed information.

Settings

General Settings

Go to the 'Settings' menu and click on the 'General' submenu to navigate to the Settings page.

1. File Settings

This feature allows you to:

Control which file extensions are permitted for email attachments.
Set the maximum allowed file size for attachments.

2. Transfer Settings

This feature allows you to:

Define how many days a sent file remains available before it expires (default: 7 days).
Set a download limit for each file (default: 7 downloads).

You can adjust both values according to your preferences.

3. Privacy

When you send an email with a file transfer, a privacy message will be displayed below the email content for each transfer. This ensures that recipients are aware of your data privacy notice.

4. Notifications

When you or someone from your organization sends a file via email and the recipient downloads it, a notification will appear on the top notification icon of your dashboard.

Branding

If you want your brand logo to appear in emails and on the file download page (replacing the default Transphurr logo), you can upload your own logo here.

Important:

Your logo must be exactly 200px wide and 50px high.
Logos that do not meet these dimensions will not be accepted.

By uploading a custom logo, you confirm that you own the rights to use the logo and that it is not copyrighted by another entity. Misuse of this feature may result in the cancellation of your subscription.

Administration

Manage Users

Add users, set user-specific file size limits, and control access levels.

To add and manage users:

Go to the sidebar, click on the Administration menu.
Select the 'Manage Users' submenu to navigate to the Users page.
Click the 'Add New User' button to open a popup form.
Fill in the user details, set a password, and allocate the allowed file size for the user.

Feature Benefit:

This feature is useful for organizations with multiple teams. You can create individual user accounts for specific employees, assigning each email and password.

When a user logs in, they will see a limited dashboard based on their access level. Only administrators have access to all features and menus.

Manage Recipients

Add recipients for quick selection during transfers.

To add or manage recipients:

Go to the sidebar and click on the Administration menu.
Then select the 'Manage Recipients' submenu.
You will be navigated to the Recipients page.
Click the 'Add New Recipient' button to open a popup form.
Fill in the recipient details and save.

Feature Benefit:

This feature allows you to add recipients to whom emails will be sent. When composing an email, you can easily select one or multiple recipients from the saved list—making the process faster and more efficient.

Email Template

To manage email templates:

Go to the sidebar menu and click on Email Templates.
This will navigate you to the Templates page.
Click the 'Add New Template' button to open a popup form.
Fill in the required details and save the template.

Feature Benefit:

This feature allows you to create and manage predefined email templates. When sending emails, you can simply select a saved template instead of writing a new message every time — saving time and ensuring consistency.

New Transfer

The "New Transfer" feature is the core of transphurr, enabling you to send files securely via email with ease and control. Follow these steps to use it effectively:

Select or Add Recipients: In the "To" dropdown, choose the recipient you want to send the email to. If the recipient isn’t listed, click "Add Recipient" to include a new contact, then select them from the dropdown.

Import or Edit Email Templates: If you’ve already created an email template, click the "Import Template" link to automatically populate the subject and body. You can edit the subject or body as needed to personalize your message.

Upload Files: On the right side, click the "Click or drag files to upload" box to select one or multiple files. Once uploaded, the files will appear below the box. To remove a file, click the close icon next to it.

Set Notifications and Limits:
- Notify Download: Check this box to receive a notification when the recipient downloads the file.
- Expiry Days: Specify the number of days (e.g., 7 days) after which the recipient can no longer access the file.
- Number of Downloads: Set a limit on how many times the file can be downloaded (e.g., 7 times). Once this limit is reached, the recipient cannot download the file anymore.

Apply Enhanced Security (OTP): Enable the "Apply Enhanced Security (OTP)" option to add an extra layer of protection. When the recipient opens the email and clicks the download link, they will be prompted to enter a one-time password (OTP). Only authenticated and registered users can access the file after entering the correct OTP.

Send the Transfer: Once everything is set, click the "Send" button to initiate the file transfer.

With these controls, you can ensure your files are shared securely and only accessible to the intended recipients within the specified limits.

Transfer History

This section allows you to manage your file transfers with the following features:

Resend Email: If you need to resend a previously sent email, click the info icon or the transfer code link to view the full details of the transfer. From there, you can easily resend the email.

Delete Transfer: Deleting a transfer will permanently remove the file from our server. Once deleted, it cannot be restored.

Enable/Disable Toggle: Use this toggle to temporarily disable or enable access to a specific transfer. This is helpful if you want to restrict access to a file for a certain period.
File Download Tracking: View complete download details, including the location and IP address from which the file was downloaded. This feature provides transparency and enhances security monitoring.

Recipient Download Process

Recipients access files via secure email links. If OTP is enabled, they must verify their identity with a one-time password before downloading.

Email and Attachment Access

The recipient receives an email with an attachment link. When they click the link, they are redirected to the secure file download page.

OTP Verification (If Enabled)

If the enhanced OTP feature is enabled, the recipient is prompted to enter their email address to receive a One-Time Password (OTP). This step ensures that only the intended recipient can access the file.

File Download and OTP Validation

After entering the OTP received via email, the system verifies the code. Once successfully validated, the recipient can view and securely download the file.

API Integration: Automate File Transfers

Transphurr provides an API to automate file transfers, allowing seamless integration with your existing systems. Below is a step-by-step guide to integrate with the Transphurr API using various programming languages.

Step-by-Step Guide

Obtain API Access: Subscribe to a plan that includes API access.
Set Up Your Environment: Ensure you have the necessary dependencies installed for your chosen programming language (e.g., requests for Python, Newtonsoft.Json for .NET, axios for JavaScript, or GuzzleHttp for PHP).

Implement the File Transfer Logic: Use the code examples below to upload files to the Transphurr API. Select a programming language to view the implementation.

                                
import os
import requests
import json

def bytes_for_human(bytes_size):
    units = ["B", "KB", "MB", "GB", "TB", "PB"]
    size = float(bytes_size)
    i = 0
    while size >= 1024 and i < len(units) - 1:
        size /= 1024
        i += 1
    return f"{size:.2f} {units[i]}"

def upload_files():
    folder_path = "./UploadFile"  # Directory containing files to upload
    api_url = "https://api.transphurr.com/saveFileTransfer"  # Transphurr API endpoint for file transfers
    file_list = []
    user_space = 0

    for file_name in os.listdir(folder_path):
        file_path = os.path.join(folder_path, file_name)
        if os.path.isfile(file_path):
            file_size = os.path.getsize(file_path)
            user_space += file_size
            file_list.append({
                "File_name": file_name,  # Name of the file
                "File_type": os.path.splitext(file_name)[1],  # File extension (e.g., .pdf, .jpg)
                "File_size": bytes_for_human(file_size),  # Human-readable file size (e.g., 1.23 MB)
                "File_size_byte": file_size  # File size in bytes
            })

    recipients = [{
        "Recipient_email": "recipient@example.com",  # Email address of the recipient
        "RecipientCode": "RECIPIENT_CODE"  # Unique code for the recipient
    }]

    file_transfer = {
        "CompanyCode": "COMPANY_CODE",  # Unique identifier for your company
        "SenderId": "SENDER_ID",  # Unique identifier for the sender
        "SenderEmail": "sender@example.com",  # Sender's email address
        "fileTransfers_Recipients": recipients,  # List of recipients for the file transfer
        "fileTransfers_Files": file_list,  # List of files to be transferred
        "Create_ts": "2025-05-29T12:00:00",  # Timestamp of transfer creation
        "Modify_date": "2025-05-29T12:00:00",  # Timestamp of last modification
        "Subject": "Test",  # Email subject
        "Body": "Testing",  # Email body content
        "LinkExpire_days": 1,  # Number of days until the download link expires
        "Download_limit": 1,  # Maximum number of downloads allowed
        "PrivacyMessage": "",  # Optional privacy message included in the email
        "Logo_url": "",  # URL of the company logo for branding
        "Used_space": str(user_space)  # Total storage used by the files in bytes
    }

    files = []
    for file_name in os.listdir(folder_path):
        file_path = os.path.join(folder_path, file_name)
        if os.path.isfile(file_path):
            files.append(("file", (file_name, open(file_path, "rb"))))  # Add file to the upload list

    data = {
        "fileTransfer": json.dumps(file_transfer),  # JSON string of transfer details
        "additionalParameter": "AdditionalValue"  # Optional additional parameter for custom use
    }

    try:
        response = requests.post(api_url, files=files, data=data)
        if response.status_code == 200:
            print("Files uploaded successfully.")
        else:
            print(f"Failed to upload files. Status code: {response.status_code}")
    except Exception as e:
        print(f"Error: {str(e)}")

if __name__ == "__main__":
    upload_files()

                                
using System;
using System.Collections.Generic;
using System.IO;
using System.Net.Http;
using System.Threading.Tasks;
using Newtonsoft.Json;

namespace CALL_API
{
    class Program
    {
        static async Task Main()
        {
            string folderPath = AppDomain.CurrentDomain.BaseDirectory + "UploadFile";  // Directory containing files to upload
            string apiUrl = "https://api.transphurr.com/saveFileTransfer";  // Transphurr API endpoint for file transfers
            try
            {
                List filelist = new List();
                List recipientsList = new List();
                var UserSpace = 0;
                foreach (string filePath in Directory.GetFiles(folderPath))
                {
                    byte[] fileBytes = File.ReadAllBytes(filePath);
                    UserSpace += fileBytes.Length;
                    FileTransfersFilesModel files = new FileTransfersFilesModel
                    {
                        File_name = Path.GetFileName(filePath),  // Name of the file
                        File_type = Path.GetExtension(filePath),  // File extension (e.g., .pdf, .jpg)
                        File_size = BytesForHuman(fileBytes.Length),  // Human-readable file size
                        File_size_byte = fileBytes.Length  // File size in bytes
                    };
                    filelist.Add(files);
                }
                FileTransfersRecipientsModel recipients = new FileTransfersRecipientsModel
                {
                    Recipient_email = "recipient@example.com",  // Email address of the recipient
                    RecipientCode = "RECIPIENT_CODE"  // Unique code for the recipient
                };
                recipientsList.Add(recipients);
                Email fileTransfer = new Email
                {
                    CompanyCode = "COMPANY_CODE",  // Unique identifier for your company
                    SenderId = "SENDER_ID",  // Unique identifier for the sender
                    SenderEmail = "sender@example.com",  // Sender's email address
                    fileTransfers_Recipients = recipientsList,  // List of recipients for the file transfer
                    fileTransfers_Files = filelist,  // List of files to be transferred
                    Create_ts = DateTime.Now,  // Timestamp of transfer creation
                    Modify_date = DateTime.Now,  // Timestamp of last modification
                    Subject = "Test",  // Email subject
                    Body = "Testing",  // Email body content
                    LinkExpire_days = 1,  // Number of days until the download link expires
                    Download_limit = 1,  // Maximum number of downloads allowed
                    PrivacyMessage = "",  // Optional privacy message included in the email
                    Logo_url = "",  // URL of the company logo for branding
                    Used_space = Convert.ToString(UserSpace)  // Total storage used by the files in bytes
                };
                string jsonData = JsonConvert.SerializeObject(fileTransfer);
                using (HttpClient client = new HttpClient())
                {
                    var formData = new MultipartFormDataContent
                    {
                        { new StringContent(jsonData), "fileTransfer" }  // JSON string of transfer details
                    };
                    foreach (string filePath in Directory.GetFiles(folderPath))
                    {
                        byte[] fileBytes = File.ReadAllBytes(filePath);
                        var fileContent = new ByteArrayContent(fileBytes);
                        formData.Add(fileContent, "file", Path.GetFileName(filePath));  // Add file to the upload list
                    }
                    formData.Add(new StringContent("AdditionalValue"), "additionalParameter");  // Optional additional parameter
                    HttpResponseMessage response = await client.PostAsync(apiUrl, formData);
                    if (response.IsSuccessStatusCode)
                    {
                        Console.WriteLine("Files uploaded successfully.");
                    }
                    else
                    {
                        Console.WriteLine($"Failed to upload files. Status code: {response.StatusCode}");
                    }
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error: {ex.Message}");
            }
        }

        static string BytesForHuman(long bytes)
        {
            string[] units = { "B", "KB", "MB", "GB", "TB", "PB" };
            int i = 0;
            double size = (double)bytes;
            while (size >= 1024 && i < units.Length - 1)
            {
                size /= 1024;
                i++;
            }
            return $"{size:F2} {units[i]}";
        }
    }

    public class Email
    {
        public int TransferId { get; set; }
        public string TransferCode { get; set; }
        public string CompanyCode { get; set; }  // Unique identifier for your company
        public string Subject { get; set; }  // Email subject
        public string Body { get; set; }  // Email body content
        public int TemplateId { get; set; }
        public string SenderId { get; set; }  // Unique identifier for the sender
        public string SenderName { get; set; }
        public string ExpiryStatus { get; set; }
        public string SenderEmail { get; set; }  // Sender's email address
        public bool LinkExpires { get; set; }
        public int? LinkExpire_days { get; set; }  // Number of days until the download link expires
        public DateTime LinkExpire_date { get; set; }
        public int? Download_limit { get; set; }  // Maximum number of downloads allowed
        public bool Active { get; set; }
        public string File_size { get; set; }
        public string Used_space { get; set; }  // Total storage used by the files in bytes
        public bool Notify_download { get; set; }
        public DateTime? Create_ts { get; set; }  // Timestamp of transfer creation
        public DateTime Modify_date { get; set; }  // Timestamp of last modification
        public bool Status { get; set; }
        public string PrivacyMessage { get; set; }  // Optional privacy message
        public string Logo_url { get; set; }  // URL of the company logo
        public int Totalfiles { get; set; }
        public int TotalBytes { get; set; }
        public List fileTransfers_Files { get; set; }  // List of files
        public List fileTransfers_Recipients { get; set; }  // List of recipients
        public bool isEnhancedSecurity { get; set; }
        public string IP { get; set; }
    }

    public class FileTransfersFilesModel
    {
        public int FileId { get; set; }
        public int TransferId { get; set; }
        public string TransferCode { get; set; }
        public string CompanyCode { get; set; }  // Unique identifier for your company
        public string File_name { get; set; }  // Name of the file
        public string File_type { get; set; }  // File extension
        public string File_size { get; set; }  // Human-readable file size
        public int File_size_byte { get; set; }  // File size in bytes
        public string Size { get; set; }
        public string File_url { get; set; }
        public string SenderId { get; set; }  // Unique identifier for the sender
        public string SenderName { get; set; }
        public string SenderEmail { get; set; }  // Sender's email address
        public string Base64 { get; set; }
        public string Download_limit { get; set; }  // Maximum number of downloads
        public string FileAccess { get; set; }
        public string Logo_url { get; set; }  // URL of the company logo
        public int file_download_count { get; set; }
        public DateTime Create_ts { get; set; }  // Timestamp of file creation
        public DateTime ExpiryDate { get; set; }
        public string Pageurl { get; set; }
        public bool isEnhancedSecurity { get; set; }
        public string Recipient_email { get; set; }  // Recipient's email address
    }

    public class FileTransfersRecipientsModel
    {
        public int Transfer_recipientId { get; set; }
        public int TransferId { get; set; }
        public string TransferCode { get; set; }
        public string RecipientCode { get; set; }  // Unique code for the recipient
        public string Name { get; set; }
        public int RecipientId { get; set; }
        public string Recipient_email { get; set; }  // Recipient's email address
        public string Email { get; set; }
        public string Mail_subject { get; set; }  // Email subject
        public string Mail_body { get; set; }  // Email body content
        public bool Mail_status { get; set; }
        public DateTime MailSent_ts { get; set; }
        public bool Active { get; set; }
    }
}

                                
const axios = require('axios');
const fs = require('fs').promises;
const path = require('path');

async function bytesForHuman(bytes) {
    const units = ['B', 'KB', 'MB', 'GB', 'TB', 'PB'];
    let size = bytes;
    let i = 0;
    while (size >= 1024 && i < units.length - 1) {
        size /= 1024;
        i++;
    }
    return `${size.toFixed(2)} ${units[i]}`;
}

async function uploadFiles() {
    const folderPath = './UploadFile';  // Directory containing files to upload
    const apiUrl = 'https://api.transphurr.com/saveFileTransfer';  // Transphurr API endpoint for file transfers
    const fileList = [];
    let userSpace = 0;

    const files = await fs.readdir(folderPath);
    for (const fileName of files) {
        const filePath = path.join(folderPath, fileName);
        const stats = await fs.stat(filePath);
        if (stats.isFile()) {
            const fileBuffer = await fs.readFile(filePath);
            userSpace += fileBuffer.length;
            fileList.push({
                File_name: fileName,  // Name of the file
                File_type: path.extname(fileName),  // File extension (e.g., .pdf, .jpg)
                File_size: await bytesForHuman(fileBuffer.length),  // Human-readable file size
                File_size_byte: fileBuffer.length  // File size in bytes
            });
        }
    }

    const recipients = [{
        Recipient_email: 'recipient@example.com',  // Email address of the recipient
        RecipientCode: 'RECIPIENT_CODE'  // Unique code for the recipient
    }];

    const fileTransfer = {
        CompanyCode: 'COMPANY_CODE',  // Unique identifier for your company
        SenderId: 'SENDER_ID',  // Unique identifier for the sender
        SenderEmail: 'sender@example.com',  // Sender's email address
        fileTransfers_Recipients: recipients,  // List of recipients for the file transfer
        fileTransfers_Files: fileList,  // List of files to be transferred
        Create_ts: new Date().toISOString(),  // Timestamp of transfer creation
        Modify_date: new Date().toISOString(),  // Timestamp of last modification
        Subject: 'Test',  // Email subject
        Body: 'Testing',  // Email body content
        LinkExpire_days: 1,  // Number of days until the download link expires
        Download_limit: 1,  // Maximum number of downloads allowed
        PrivacyMessage: '',  // Optional privacy message included in the email
        Logo_url: '',  // URL of the company logo for branding
        Used_space: userSpace.toString()  // Total storage used by the files in bytes
    };

    const formData = new FormData();
    formData.append('fileTransfer', JSON.stringify(fileTransfer));  // JSON string of transfer details
    for (const fileName of files) {
        const filePath = path.join(folderPath, fileName);
        const stats = await fs.stat(filePath);
        if (stats.isFile()) {
            const fileBuffer = await fs.readFile(filePath);
            formData.append('file', new Blob([fileBuffer]), fileName);  // Add file to the upload list
        }
    }
    formData.append('additionalParameter', 'AdditionalValue');  // Optional additional parameter

    try {
        const response = await axios.post(apiUrl, formData, {
            headers: { 'Content-Type': 'multipart/form-data' }
        });
        console.log('Files uploaded successfully.');
    } catch (error) {
        console.error(`Error: ${error.message}`);
    }
}

uploadFiles();

                                

function bytesForHuman($bytes) {
    $units = ['B', 'KB', 'MB', 'GB', 'TB', 'PB'];
    $size = $bytes;
    $i = 0;
    while ($size >= 1024 && $i < count($units) - 1) {
        $size /= 1024;
        $i++;
    }
    return sprintf("%.2f %s", $size, $units[$i]);
}

function uploadFiles() {
    $folderPath = './UploadFile/';  // Directory containing files to upload
    $apiUrl = 'https://api.transphurr.com/saveFileTransfer';  // Transphurr API endpoint for file transfers
    $fileList = [];
    $userSpace = 0;

    $files = scandir($folderPath);
    foreach ($files as $fileName) {
        $filePath = $folderPath . $fileName;
        if (is_file($filePath)) {
            $fileSize = filesize($filePath);
            $userSpace += $fileSize;
            $fileList[] = [
                'File_name' => $fileName,  // Name of the file
                'File_type' => pathinfo($fileName, PATHINFO_EXTENSION),  // File extension
                'File_size' => bytesForHuman($fileSize),  // Human-readable file size
                'File_size_byte' => $fileSize  // File size in bytes
            ];
        }
    }

    $recipients = [[
        'Recipient_email' => 'recipient@example.com',  // Email address of the recipient
        'RecipientCode' => 'RECIPIENT_CODE'  // Unique code for the recipient
    ]];

    $fileTransfer = [
        'CompanyCode' => 'COMPANY_CODE',  // Unique identifier for your company
        'SenderId' => 'SENDER_ID',  // Unique identifier for the sender
        'SenderEmail' => 'sender@example.com',  // Sender's email address
        'fileTransfers_Recipients' => $recipients,  // List of recipients for the file transfer
        'fileTransfers_Files' => $fileList,  // List of files to be transferred
        'Create_ts' => date('c'),  // Timestamp of transfer creation
        'Modify_date' => date('c'),  // Timestamp of last modification
        'Subject' => 'Test',  // Email subject
        'Body' => 'Testing',  // Email body content
        'LinkExpire_days' => 1,  // Number of days until the download link expires
        'Download_limit' => 1,  // Maximum number of downloads allowed
        'PrivacyMessage' => '',  // Optional privacy message included in the email
        'Logo_url' => '',  // URL of the company logo for branding
        'Used_space' => (string)$userSpace  // Total storage used by the files in bytes
    ];

    $postData = [
        'fileTransfer' => json_encode($fileTransfer),  // JSON string of transfer details
        'additionalParameter' => 'AdditionalValue'  // Optional additional parameter
    ];

    $ch = curl_init();
    curl_setopt($ch, CURLOPT_URL, $apiUrl);
    curl_setopt($ch, CURLOPT_POST, true);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

    $multipart = [];
    foreach ($postData as $key => $value) {
        $multipart[] = ['name' => $key, 'contents' => $value];
    }

    foreach ($files as $fileName) {
        $filePath = $folderPath . $fileName;
        if (is_file($filePath)) {
            $multipart[] = [
                'name' => 'file',  // Name of the file field
                'contents' => fopen($filePath, 'r'),  // File content
                'filename' => $fileName  // Name of the file
            ];
        }
    }

    curl_setopt($ch, CURLOPT_POSTFIELDS, $multipart);

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

    if ($httpCode == 200) {
        echo "Files uploaded successfully.\n";
    } else {
        echo "Failed to upload files. Status code: $httpCode\n";
    }
}

uploadFiles();
?>

Run the Code: Execute the program. It will:
- Read files from the "UploadFile" directory in your project.
- Create a list of files and recipients.
- Send the data to the Transphurr API endpoint using a multipart form data request.
- Handle the response, indicating success or failure.
Handle Errors: The code includes error handling to catch and display any issues that occur during the API request, such as network failures or invalid data.
Test and Customize: Replace the placeholder values (e.g., COMPANY_CODE, SENDER_ID, recipient@example.com) with your actual Transphurr API credentials and recipient details. Test the integration to ensure it works as expected, and modify the code to fit your specific use case.

Feature Benefit

Using the Transphurr API, you can automate file transfers, integrate with your existing workflows, and streamline operations without manual intervention. This is particularly useful for businesses that need to send files programmatically as part of their processes.