Getting Started

1. Setup: Ensure that your project references System.Net.Http. You can add this by right-clicking on your project in Visual Studio, selecting "Manage NuGet Packages", and searching for System.Net.Http if it's not already included.
2. Create a Class for the Request Payload: Define classes that mirror the structure of the expected JSON payload.

   public class Source
   {
       public int vid { get; set; }
       public int aid { get; set; }
       public int lid { get; set; }
       public double sendDelay { get; set; }
       public string returnURL { get; set; }
   }
   
   public class Properties
   {
       public string reference { get; set; }
       public bool noSell { get; set; }
       public string orderId { get; set; }
   }
   
   public class Fields
   {
       public string FirstName { get; set; }
       public string LastName { get; set; }
       // Add other fields as needed
   }
   
   public class Lead
   {
       public Properties properties { get; set; }
       public Fields fields { get; set; }
   }
   
   public class InsertRequest
   {
       public Source source { get; set; }
       public List<Lead> leads { get; set; }
   }
   

3. Send the POST Request: Use HttpClient to send the request to the API endpoint.

   using System;
   using System.Collections.Generic;
   using System.Net.Http;
   using System.Net.Http.Headers;
   using System.Text;
   using System.Threading.Tasks;
   using Newtonsoft.Json; // Install Newtonsoft.Json via NuGet
   
   class Program
   {
       static async Task Main(string[] args)
       {
           var client = new HttpClient();
           client.BaseAddress = new Uri("https://leads.leadexec.net");
   
           // Set up request headers
           client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
           client.DefaultRequestHeaders.Add("api-key", "[api-key]");
   
           // Create request payload
           var request = new InsertRequest
           {
               source = new Source
               {
                   vid = 0,
                   aid = 0,
                   lid = 0,
                   sendDelay = 0.0,
                   returnURL = ""
               },
               leads = new List<Lead>
               {
                   new Lead
                   {
                       properties = new Properties
                       {
                           reference = "",
                           noSell = false,
                           orderId = ""
                       },
                       fields = new Fields
                       {
                           FirstName = "",
                           LastName = "",
                           // Populate other fields as needed
                       }
                   }
               }
           };
   
           // Convert request payload to JSON
           var json = JsonConvert.SerializeObject(request);
           var content = new StringContent(json, Encoding.UTF8, "application/json");
   
           try
           {
               // Send POST request
               HttpResponseMessage response = await client.PostAsync("/v2/insert/general", content);
   
               if (response.IsSuccessStatusCode)
               {
                   Console.WriteLine("Request succeeded!");
                   string responseContent = await response.Content.ReadAsStringAsync();
                   Console.WriteLine("Response: " + responseContent);
               }
               else
               {
                   Console.WriteLine("Request failed. Status Code: " + response.StatusCode);
                   string errorContent = await response.Content.ReadAsStringAsync();
                   Console.WriteLine("Error: " + errorContent);
               }
           }
           catch (Exception ex)
           {
               Console.WriteLine("Exception occurred: " + ex.Message);
           }
       }
   }
   

Explanation

• HttpClient: This class is used to send HTTP requests and receive HTTP responses from resource identified by the URI.
• Request Headers: We set the Accept head to application/json to indicate that we expect a JSON response. The Authorization header is set with the Bearer token to authenticate the request.
• Serialization: We use Newtonsoft.Json (also known as Json.NET) to serialize the C# object into a JSON string.
• Error Handling: The code includes basic error handling to catch and display any exceptions that occur during the HTTP request.

Note

• Replace [access_token] with the actual token you are using for authentication.
• Ensure that all necessary fields are filled in according to your API documentation.
• For production use, consider handling exceptions more gracefully and implementing retry logic if needed.

1. Setup: Ensure that your server supports classic ASP and has the necessary permissions to make HTTP requests.
2. Create an ASP Page to Make the HTTP POST Request: Here's a sample ASP code to make a POST request to the endpoint:

   <%
   Dim xmlhttp, url, authToken, postData
   
   ' Initialize the XMLHTTP object
   Set xmlhttp = Server.CreateObject("MSXML2.ServerXMLHTTP.6.0")
   
   ' Set the request URL
   url = "https://leads.leadexec.net/v2/insert/general"
   
   ' Set the Bearer token for authorization
   api-key = "[api-key]" ' Replace [api-key] with your actual token
   
   ' Create the JSON payload
   postData = "{" & _
       """source"": {" & _
           """vid"": 0," & _
           """aid"": 0," & _
           """lid"": 0," & _
           """sendDelay"": 0.0," & _
           """returnURL"": """"}," & _
       """leads"": [{" & _
           """properties"": {" & _
               """reference"": """"," & _
               """noSell"": false," & _
               """orderId"": """"}," & _
           """fields"": {" & _
               """FirstName"": """"," & _
               """LastName"": """"," & _
               """Email"": """"," & _
               """Phone"": """" " & _
           "}" & _
       "}]" & _
   "}"
   
   ' Open a connection to the server
   xmlhttp.Open "POST", url, False
   
   ' Set request headers
   xmlhttp.setRequestHeader "Content-Type", "application/json"
   xmlhttp.setRequestHeader "Accept", "application/json"
   xmlhttp.setRequestHeader "Authorization", authToken
   
   ' Send the request with the JSON payload
   xmlhttp.Send postData
   
   ' Get the response
   If xmlhttp.Status = 200 Then
       Response.Write "Request succeeded!<br>"
       Response.Write "Response: " & xmlhttp.responseText
   Else
       Response.Write "Request failed. Status Code: " & xmlhttp.Status & "<br>"
       Response.Write "Error: " & xmlhttp.responseText
   End If
   
   ' Clean up
   Set xmlhttp = Nothing
   %>
   

Explanation

• ServerXMLHTTP: The ServerXMLHTTP object allows you to send HTTP requests and handle server responses. It is more suitable for server-side operations in ASP compared to the XMLHTTP object.
• Request Headers: The headers Content-Type, Accept, and Authorization are set to ensure the server correctly processes the request and authenticates it.
• JSON Payload: The postData variable contains the JSON payload formatted as a string. Ensure the JSON structure matches what the API expects.
• Response Handling: The code checks the Status property of the xmlhttp object to determine if the request was successful (HTTP 200 OK). It outputs the server's response or an error message accordingly.

Note

• Replace [access_token] with the actual token you are using for authentication.
• Security Considerations: Classic ASP is an older technology; ensure that your server is secure and up-to-date. Avoid exposing sensitive data unnecessarily.

1. Ensure cURL is Enabled: Most PHP installations have cURL enabled by default. If it's not enabled, you need to install it or enable it in your php.ini file.
2. Create a PHP Script to Make the HTTP POST Request: Here's a sample PHP code to make a POST request to your endpoint:

   <?php
   
   // The URL of the API endpoint
   $url = "https://leads.leadexec.net/v2/insert/general";
   
   // The Bearer token for authorization
   $apiKey = "[api-key]"; // Replace [api-key] with your actual token
   
   // Create the JSON payload
   $data = array(
       "source" => array(
           "vid" => 0,
           "aid" => 0,
           "lid" => 0,
           "sendDelay" => 0.0,
           "returnURL" => ""
       ),
       "leads" => array(
           array(
               "properties" => array(
                   "reference" => "",
                   "noSell" => false,
                   "orderId" => ""
               ),
               "fields" => array(
                   "FirstName" => "",
                   "LastName" => "",
                   "Email" => "",
                   "Phone" => ""
                   // Add other fields as needed
               )
           )
       )
   );
   
   // Encode the array into a JSON string
   $jsonData = json_encode($data);
   
   // Initialize cURL session
   $ch = curl_init($url);
   
   // Set cURL options
   curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
   curl_setopt($ch, CURLOPT_HTTPHEADER, array(
       'Content-Type: application/json',
       'Accept: application/json',
       'api-key: $apiKey
   ));
   curl_setopt($ch, CURLOPT_POST, true);
   curl_setopt($ch, CURLOPT_POSTFIELDS, $jsonData);
   
   // Execute the POST request
   $response = curl_exec($ch);
   
   // Check for cURL errors
   if ($response === false) {
       echo 'Curl error: ' . curl_error($ch);
   } else {
       // Check HTTP response status code
       $httpStatus = curl_getinfo($ch, CURLINFO_HTTP_CODE);
       if ($httpStatus == 200) {
           echo "Request succeeded!<br>";
           echo "Response: " . $response;
       } else {
           echo "Request failed. Status Code: " . $httpStatus . "<br>";
           echo "Error: " . $response;
       }
   }
   
   // Close cURL session
   curl_close($ch);
   
   ?>
   

Explanation

• cURL Initialization: curl_init() initializes a new cURL session
• Setting cURL Options:
  • CURLOPT_RETURNTRANSFER ensures the response is returned as a string instead of outputting it directly.
  • CURLOPT_HTTPHEADER sets the necessary headers for the request, including Content-Type, Accept, and Authorization headers.
  • CURLOPT_POST indicates that this is a POST request.
  • CURLOPT_POSTFIELDS sets the JSON-encoded data as the POST body.
• Error Handling: The script checks if the cURL execution was successful. If not, it prints the cURL error. If successful, it checks the HTTP response status code to determine whether the request was successful.

Note

• Replace [access_token] with the actual token you are using for authentication.
• JSON Encoding: Ensure that the data structure matches the API's expected format. Use json_encode() to convert PHP arrays to JSON strings.
• Security Considerations: Make sure to handle sensitive data securely and follow best practices for error handling and logging.
• PHP Version: This script is compatible with most PHP versions that support cURL, typically PHP 5.1.3 and later.

1. Setup: Ensure you have Python installed on your system. Install the requests library if it is not already installed:

   pip install requests

2. Create a Python Script to Make the HTTP POST Request:

   Here's a sample Python code to make a POST request to your endpoint:

   import requests
   import json
   
   # The URL of the API endpoint
   url = "https://leads.leadexec.net/v2/insert/general"
   
   # The Bearer token for authorization
   apiKey = "[api-key]"  # Replace [api-key] with your actual token
   
   # Create the JSON payload
   data = {
       "source": {
           "vid": 0,
           "aid": 0,
           "lid": 0,
           "sendDelay": 0.0,
           "returnURL": ""
       },
       "leads": [
           {
               "properties": {
                   "reference": "",
                   "noSell": False,
                   "orderId": ""
               },
               "fields": {
                   "FirstName": "",
                   "LastName": "",
                   "Email": "",
                   "Phone": ""
                   # Add other fields as needed
               }
           }
       ]
   }
   
   # Convert the data to a JSON string
   json_data = json.dumps(data)
   
   # Set the headers for the request
   headers = {
       "Content-Type": "application/json",
       "Accept": "application/json",
       "api-key": apiKey
   }
   
   # Send the POST request
   response = requests.post(url, headers=headers, data=json_data)
   
   # Check the response
   if response.status_code == 200:
       print("Request succeeded!")
       print("Response:", response.json())
   else:
       print(f"Request failed. Status Code: {response.status_code}")
       print("Error:", response.text)
   

Explanation

• Requests Library: The requests library simplifies making HTTP requests in Python. It provides methods like requests.post() for POST requests.
• JSON Payload: The data dictionary represents the JSON payload to be sent in the request. It is converted to a JSON string using json.dumps().
• Headers: The headers dictionary specifies the Content-Type, Accept, and Authorization headers to be included in the request.
• Sending the Request: The requests.post() method sends the POST request to the specified URL with the given headers and JSON payload.
• Response Handling: The script checks the status_code of the response to determine if the request was successful (HTTP 200 OK). It prints the response content or error message accordingly.

Note

• Replace [access_token] with the actual token you are using for authentication.
• Error Handling: The script checks for HTTP status codes to handle errors. You can further improve error handling by catching exceptions (e.g., network errors) using a try-except block.
• Python Version: This script is compatible with Python 3.x. Ensure you're using an up-to-date version of Python.

1. Setup: Ensure that Perl is install on the system and the LWP::UserAgent module is available.

   You can install it using CPAN if needed:

   cpan install LWP::UserAgent

2. Create a Perl Script to Make the HTTP POST Request:

   Here's a sample Perl code to make a POST request to your endpoint:

   use strict;
   use warnings;
   use LWP::UserAgent;
   use HTTP::Request;
   use JSON;
   
   # Initialize the user agent
   my $ua = LWP::UserAgent->new;
   
   # The URL of the API endpoint
   my $url = 'https://leads.leadexec.net/v2/insert/general';
   
   # The Bearer token for authorization
   my $api_key = '[api-key]'; # Replace [api-key] with your actual token
   
   # Create the JSON payload
   my $data = {
       source => {
           vid       => 0,
           aid       => 0,
           lid       => 0,
           sendDelay => 0.0,
           returnURL => ''
       },
       leads => [
           {
               properties => {
                   reference => '',
                   noSell    => \0,  # Use a reference to scalar to represent a JSON boolean
                   orderId   => ''
               },
               fields => {
                   FirstName => '',
                   LastName  => '',
                   Email     => '',
                   Phone     => ''
                   # Add other fields as needed
               }
           }
       ]
   };
   
   # Convert the Perl data structure to a JSON string
   my $json_data = encode_json($data);
   
   # Create the HTTP request object
   my $req = HTTP::Request->new(POST => $url);
   $req->header('Content-Type'  => 'application/json');
   $req->header('Accept'        => 'application/json');
   $req->header('api-key' => "$api_key");
   $req->content($json_data);
   
   # Send the request
   my $response = $ua->request($req);
   
   # Check the response
   if ($response->is_success) {
       print "Request succeeded!\n";
       print "Response: " . $response->decoded_content . "\n";
   } else {
       print "Request failed. Status Code: " . $response->code . "\n";
       print "Error: " . $response->message . "\n";
   }
   

Explanation

• LWP::UserAgent: This module provides a user agent object that can be used to make HTTP requests. It's part of the LWP (Library for WWW in Perl) suite.
• HTTP::Reques: This module represents an HTTP request. It is used to build the request with the appropriate HTTP method (POST) and headers.
• JSON: This module is used to encode the Perl data structure into a JSON string. It provides functions for converting between JSON strings and Perl data structures.
• Request Headers: The headers Content-Type, Accept, and Authorization are set to ensure the server correctly processes the request and authenticates it.
• Error Handling: The code checks if the request was successful using $response->is_success. If not, it prints the HTTP status code and error message.

Note

• Replace [access_token] with the actual token you are using for authentication.
• JSON Boolean Representation: In Perl, JSON booleans can be represented using references to scalar values (\1 for true, \0 for false).
• Security Considerations: Ensure to handle sensitive data securely and follow best practices for error handling and logging.
• Perl Version: This script is compatible with most versions of Perl that support LWP::UserAgent and JSON.

Using HttpURLConnection (Java 8 and earlier)

1. Setup: Ensure you have Java Development Kit (JDK) installed.
2. Create a Java Class to Make the HTTP POST Request: Here's a sample Java code using HttpURLConnection:

   import java.io.OutputStream;
   import java.net.HttpURLConnection;
   import java.net.URL;
   import java.nio.charset.StandardCharsets;
   
   public class ApiPostRequest {
       public static void main(String[] args) {
           try {
               // The URL of the API endpoint
               URL url = new URL("https://leads.leadexec.net/v2/insert/general");
   
               // Open a connection to the URL
               HttpURLConnection conn = (HttpURLConnection) url.openConnection();
   
               // Set the request method to POST
               conn.setRequestMethod("POST");
   
               // Set request headers
               conn.setRequestProperty("Content-Type", "application/json");
               conn.setRequestProperty("Accept", "application/json");
               conn.setRequestProperty("api-key", "[api-key]"); // Replace [api-key] with your actual token
   
               // Enable input and output streams
               conn.setDoOutput(true);
   
               // Create the JSON payload
               String jsonInputString = "{"
                       + "\"source\": {"
                       + "\"vid\": 0,"
                       + "\"aid\": 0,"
                       + "\"lid\": 0,"
                       + "\"sendDelay\": 0.0,"
                       + "\"returnURL\": \"\""
                       + "},"
                       + "\"leads\": ["
                       + "{"
                       + "\"properties\": {"
                       + "\"reference\": \"\","
                       + "\"noSell\": false,"
                       + "\"orderId\": \"\""
                       + "},"
                       + "\"fields\": {"
                       + "\"FirstName\": \"\","
                       + "\"LastName\": \"\","
                       + "\"Email\": \"\","
                       + "\"Phone\": \"\""
                       + "}"
                       + "}"
                       + "]"
                       + "}";
   
               // Write JSON data to the output stream
               try (OutputStream os = conn.getOutputStream()) {
                   byte[] input = jsonInputString.getBytes(StandardCharsets.UTF_8);
                   os.write(input, 0, input.length);
               }
   
               // Get the response code
               int responseCode = conn.getResponseCode();
               System.out.println("Response Code: " + responseCode);
   
               // Read the response
               if (responseCode == HttpURLConnection.HTTP_OK) { // success
                   try (var reader = new java.io.BufferedReader(
                           new java.io.InputStreamReader(conn.getInputStream(), StandardCharsets.UTF_8))) {
                       StringBuilder response = new StringBuilder();
                       String responseLine;
                       while ((responseLine = reader.readLine()) != null) {
                           response.append(responseLine.trim());
                       }
                       System.out.println("Response: " + response.toString());
                   }
               } else {
                   System.out.println("Request failed. Response Code: " + responseCode);
               }
   
               // Close the connection
               conn.disconnect();
   
           } catch (Exception e) {
               e.printStackTrace();
           }
       }
   }
   

Explanation

• HttpURLConnection: This class allows you to send HTTP requests and receive responses from a URL.
• Setting Request Headers: The setRequestProperty method sets the request headers for Content-Type, Accept, and Authorization.
• Sending Data: The setDoOutput(true) method enables the output stream, and OutputStream is used to write the JSON payload to the server.
• Reading Reaponse: The input stream reads the server's response, which is handled using a BufferedReader.
• Error Handling: The script checks the response code to determine whether the request was successful (HTTP 200 OK).

Using HttpClient (Java 11 and later)

1. Setup: Ensure you are using JDK 11 or later.
2. Create a Java Class to Make the HTTP POST Request: Here's a sample Java code using HttpClient:

   import java.net.URI;
   import java.net.http.HttpClient;
   import java.net.http.HttpRequest;
   import java.net.http.HttpResponse;
   import java.net.http.HttpRequest.BodyPublishers;
   import java.net.http.HttpResponse.BodyHandlers;
   
   public class ApiPostRequest {
       public static void main(String[] args) {
           try {
               // The URL of the API endpoint
               URI uri = new URI("https://leads.leadexec.net/v2/insert/general");
   
               // Create the JSON payload
               String jsonInputString = "{"
                       + "\"source\": {"
                       + "\"vid\": 0,"
                       + "\"aid\": 0,"
                       + "\"lid\": 0,"
                       + "\"sendDelay\": 0.0,"
                       + "\"returnURL\": \"\""
                       + "},"
                       + "\"leads\": ["
                       + "{"
                       + "\"properties\": {"
                       + "\"reference\": \"\","
                       + "\"noSell\": false,"
                       + "\"orderId\": \"\""
                       + "},"
                       + "\"fields\": {"
                       + "\"FirstName\": \"\","
                       + "\"LastName\": \"\","
                       + "\"Email\": \"\","
                       + "\"Phone\": \"\""
                       + "}"
                       + "}"
                       + "]"
                       + "}";
   
               // Create the HttpClient
               HttpClient client = HttpClient.newHttpClient();
   
               // Create the HttpRequest
               HttpRequest request = HttpRequest.newBuilder()
                       .uri(uri)
                       .header("Content-Type", "application/json")
                       .header("Accept", "application/json")
                       .header("Authorization", "Bearer [access_token]") // Replace [access_token] with your actual token
                       .POST(BodyPublishers.ofString(jsonInputString))
                       .build();
   
               // Send the request and get the response
               HttpResponse<String> response = client.send(request, BodyHandlers.ofString());
   
               // Print the response
               if (response.statusCode() == 200) {
                   System.out.println("Request succeeded!");
                   System.out.println("Response: " + response.body());
               } else {
                   System.out.println("Request failed. Status Code: " + response.statusCode());
                   System.out.println("Error: " + response.body());
               }
   
           } catch (Exception e) {
               e.printStackTrace();
           }
       }
   }
   

Explanation

• HttpClient: The HttpClient class provides a more modern and easier-to-use API for making HTTP requests.
• HttpRequest: The HttpRequest class is used to build the request, set the headers, and specify the HTTP method and payload.
• HttpResponse: The HttpResponse class is used to handle the response from the server.
• Error Handling: The code checks the status code of the response to determine success or failure.

Notes

• Replace [access_token] with your actual Bearer token for authentication.
• JSON Payload: Ensure the JSON structure matches the API requirements.
• Java Version: Use HttpURLConnection for Java 8 and earlier and HttpClient for Java 11 and later for a more modern approach.