Intelligent chatting made simple

Powered by AltChat

Responsive

Low latency and response times allow for exceptional processing speeds.

Seamless Integration

Integrate between multiple programing languages with ease.

Affordable

Choose one of our high-quality plans without breaking the bank.

Features

Engage in conversations with a randomly generated profile

Chatbot Overview

AltChat is designed to provide end-users with a seamless conversation that bridges the gap between chatbot and human interactions. It achieves this through the following features:

  • Natural Language Understanding (NLU)
  • Natural Language Generation (NLG)
  • Randomized personas
  • Randomized attitudes
  • Randomized behaviors
  • Randomized interests
  • High performance
  • And much more
Explore
Applify - App Landing HTML Template

AltChat Integrations

AltChat products are intended for commercial and non-commercial use, equally. All products use the same API that returns a response in a JSON format, which means most modern-day programming languages may integrate with AltChat.

  • Easily read, manipulate and parse JSON responses.

    Learn More
  • Use AltChat across a large range of programming languages.

    Learn More
  • Work with an easy-to-use API that requires minimal work on your end.

    Learn More
AltChat - Chatbot
AltChat - Chatbot
AltChat - Chatbot
AltChat - Chatbot
AltChat - Chatbot
AltChat - Chatbot
AltChat - Chatbot
AltChat - Chatbot
AltChat - Chatbot
AltChat - Chatbot
AltChat - Chatbot
AltChat - Chatbot

Affordable Plans

*registration is required

API Demonstration

AltChat returns all responses in a JSON format, which makes data processing very simple. Below you will find a few different ways to handle the JSON response.

                                  
                                    $email = 'EMAIL';
                                    $apiKey = 'API_KEY';
                                    $url = 'https://api.altchat.app/login';
                                    
                                    $token = login($url, $email, $apiKey);
                                    
                                    function login($url, $userEmail, $userApiKey)
                                    {
                                        $ch = curl_init($url);
                                        curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
                                        curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
                                        curl_setopt($ch, CURLOPT_HTTPAUTH, CURLAUTH_BASIC);
                                        curl_setopt($ch, CURLOPT_USERPWD, "$userEmail:$userApiKey");
                                        $result = curl_exec($ch);
                                        $a = explode(":", $result);
                                        $b = str_replace("}", "", $a[1]);
                                        $token = str_replace("\"", "", $b);
                                        curl_close($ch);
                                        return $token;
                                    }
                                    
                                    function chat($url, $msg)
                                    {
                                        $ch = curl_init($url);
                                        $jsonData = array(
                                            'message' => $msg
                                        );
                                        $jsonDataEncoded = json_encode($jsonData);
                                        curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
                                        curl_setopt($ch, CURLOPT_POST, 1);
                                        curl_setopt($ch, CURLOPT_POSTFIELDS, $jsonDataEncoded);
                                        curl_setopt($ch, CURLOPT_HTTPHEADER, array(
                                            'Content-Type: application/json'
                                        ));
                                        $result = curl_exec($ch);
                                        curl_close($ch);
                                        return $result;
                                    }
                                    
                                    #$token is retrived via login function above
                                    $url1 = 'https://api.altchat.app/' . $token;
                                    
                                    echo chat($url1, "Hello, how are you doing?");
                                  
                              
                                  
                                        import requests
                                        import json
                                        
                                        resp = requests.get('https://api.altchat.app/login', auth = ('EMAIL', 'API_KEY'), verify = False)
                                        y = json.loads(resp.text)
                                        myToken = y["token"]
                                        postUrl = 'https://api.altchat.app/' + myToken
                                        
                                        while True:
                                            sent = input("you:")
                                            myObj = "{\"message\": \"" + sent + "\"}"
                                            r = requests.post(postUrl, data = myObj, headers = {
                                                "Content-Type": "application/json"
                                            }, verify = False)
                                            z = json.loads(r.text)
                                            myResult = z["result"]
                                            print(f "chatbot:{myResult}")
                                            
                                            if sent.strip() == 'terminate':
                                                break
                                  
                              
                                  
                                        
                                    import java.io.BufferedReader;
                                    import java.io.IOException;
                                    import java.io.InputStreamReader;
                                    import java.io.OutputStream;
                                    import java.net.HttpURLConnection;
                                    import java.net.URL;
                                    import java.util.Base64;
                                    
                                    public class API {
                                    
                                    	public static void main(String[] args) throws IOException {
                                    		String message = "Hello, how are you?";
                                    		String email = "EMAIL";
                                    		String apiKey = "API_KEY";
                                    		String token = authenticate(email + ":" + apiKey);
                                    
                                    		System.out.println("provided token:" + token);
                                    		System.out.println("please type exit to terminate chat");
                                    		System.out.println("chatbot:" + chat(token, message));
                                    	}
                                    
                                    	public static String authenticate(String usrCredit) {
                                    		String userAuth = usrCredit;
                                    		String basicAuthPayload = "Basic " + Base64.getEncoder().encodeToString(userAuth.getBytes());
                                    
                                    		BufferedReader httpResponseReader = null;
                                    		String result = "";
                                    		try {
                                    
                                    			// Connect to the web server endpoint
                                    			URL serverUrl = new URL("http://api.altchat.app/login");
                                    
                                    			HttpURLConnection urlConnection = (HttpURLConnection) serverUrl.openConnection();
                                    
                                    			// Set HTTP method as GET
                                    			urlConnection.setRequestMethod("GET");
                                    
                                    			// Include the HTTP Basic Authentication payload
                                    			urlConnection.addRequestProperty("Authorization", basicAuthPayload);
                                    
                                    			// Read response from web server, which will trigger HTTP Basic Authentication
                                    			// request to be sent.
                                    			httpResponseReader = new BufferedReader(new InputStreamReader(urlConnection.getInputStream()));
                                    			String lineRead;
                                    			while ((lineRead = httpResponseReader.readLine()) != null) {
                                    				result = result + lineRead;
                                    			}
                                    
                                    		} catch (IOException e) {
                                    			e.printStackTrace();
                                    		} finally {
                                    			if (httpResponseReader != null) {
                                    				try {
                                    					httpResponseReader.close();
                                    				} catch (IOException e) {
                                    					e.printStackTrace();
                                    				}
                                    			}
                                    		}
                                    
                                    		result = result.split(":")[1];
                                    		result = result.replaceAll("}", "");
                                    		result = result.replaceAll("\"", "");
                                    		return result;
                                    	}
                                    
                                    	public static String chat(String token, String sent) throws IOException {
                                    		URL url = new URL("http://api.altchat.app/" + token);
                                    		HttpURLConnection con = (HttpURLConnection) url.openConnection();
                                    		con.setRequestMethod("POST");
                                    		con.setRequestProperty("Content-Type", "application/json; utf-8");
                                    		con.setRequestProperty("Accept", "application/json");
                                    		con.setDoOutput(true);
                                    		String result = "";
                                    		String jsonInputString = "{\"message\": \"" + sent + "\"}";
                                    		
                                    		try (OutputStream os = con.getOutputStream()) {
                                    			byte[] input = jsonInputString.getBytes("utf-8");
                                    			os.write(input, 0, input.length);
                                    		}
                                    		
                                    		try (BufferedReader br = new BufferedReader(new InputStreamReader(con.getInputStream(), "utf-8"))) {
                                    			StringBuilder response = new StringBuilder();
                                    			String responseLine = null;
                                    			while ((responseLine = br.readLine()) != null) {
                                    				response.append(responseLine.trim());
                                    			}
                                    
                                    			result = response.toString();
                                    		}
                                    		return result;
                                    	}
                                    }
                                  
                              
                                  
                                      
                                    using System;
                                    using System.IO;
                                    using System.Net;
                                    using System.Net.Http;
                                    
                                    namespace ConsoleApp7
                                    {
                                        class Program
                                        {
                                            static void Main(string[] args)
                                            {
                                                string token = authenticate("EMAIL", "API_KEY", "http://api.altchat.app/login");
                                                Console.WriteLine(token);
                                                Console.WriteLine("Type exit to terminate");
                                                while (true)
                                                {
                                                    Console.Write("You:");
                                                    string sent = Console.ReadLine();
                                                    
                                                    if (sent.Equals("exit"))
                                                    {
                                                        Console.WriteLine(chat("terminate", "http://api.altchat.app/" + token));
                                                        break;
                                                    }
                                                    Console.WriteLine(chat(sent,"http://api.altchat.app/"+token));
                                                }
                                            }
                                            public static string chat(string msg, string url)
                                            {
                                                
                                                var httpWebRequest = (HttpWebRequest)WebRequest.Create(url);
                                                httpWebRequest.ContentType = "application/json";
                                                httpWebRequest.Method = "POST";
                                                using (var streamWriter = new
                                    
                                                StreamWriter(httpWebRequest.GetRequestStream()))
                                                {
                                                    string myJson = "{\"message\":\""+msg+"\"}";
                                                    streamWriter.Write(myJson);
                                                }
                                                var httpResponse = (HttpWebResponse)httpWebRequest.GetResponse();
                                                string result;
                                                using (var streamReader = new StreamReader(httpResponse.GetResponseStream()))
                                                {
                                                    result = streamReader.ReadToEnd().ToString();
                                                }
                                                return result;
                                            }
                                            public static string authenticate(string email, string apiKey, string url)
                                            {
                                                HttpWebRequest requestObj = (HttpWebRequest)WebRequest.Create(url);
                                                HttpMessageHandler handler = new HttpClientHandler()
                                                {
                                                };
                                    
                                                var httpClient = new HttpClient(handler)
                                                {
                                                    BaseAddress = new Uri(url),
                                                    Timeout = new TimeSpan(0, 2, 0)
                                                };
                                    
                                                httpClient.DefaultRequestHeaders.Add("ContentType", "application/json");
                                                string userAuth = email + ":" + apiKey;
                                                 
                                                var plainTextBytes = System.Text.Encoding.UTF8.GetBytes(userAuth);
                                                string val = System.Convert.ToBase64String(plainTextBytes);
                                                httpClient.DefaultRequestHeaders.Add("Authorization", "Basic " + val);
                                    
                                                var method = new HttpMethod("GET");
                                    
                                                HttpResponseMessage response = httpClient.GetAsync(url).Result;
                                                string content = string.Empty;
                                    
                                                using (StreamReader stream = new StreamReader(response.Content.ReadAsStreamAsync().Result, System.Text.Encoding.GetEncoding("utf-8")))
                                                {
                                                    content = stream.ReadToEnd();
                                                }
                                    
                                                return jsonToString(content)[1];
                                            }
                                            public static string[] jsonToString(String jStr)
                                            {
                                                String retStr = jStr.Replace("{","");
                                                retStr = retStr.Replace("}", "");
                                                retStr = retStr.Replace("\"", "");
                                                Console.WriteLine(retStr);
                                                return retStr.Split(':');
                                            }
                                        }
                                    }
                                  
                              

Important Notice

All conversations are automatically terminated after 10 minutes of inactivity.

If you are a developer, please keep an eye out for any of the following error codes listed below.

Error Codes:
  • 401: Authorization failed due to a missing, or invalid, email address, API key or POST request
  • 403: Insufficient API calls remaining on AltChat account
  • 404: Unsupported POST method
  • 405: Temporarily blocked due to an excessive amount of failed requests
  • 406: Too many requests sent in a short amount of time
  • 407: Email address and API key may not be empty
  • 413: Too many words sent in the request, maximum size is 20 words
  • 414: Internal error has occurred, please try logging in again
  • 500: Server error has occured, please contact our support team for assistance
  • Frequently Asked

    Below is a list of frequestly asked questions. If your question does not appear on the list, please do not hesitate to reach out to us. Learn more.

    1. Are there any contracts?

    All services provided come with a no-contract policy, which means you may cancel your service at any time.

    2. Do my API calls rollover to the next month?

    If you do not use all of your allotted API calls for the month, they do not roll over. Each month, your allotted API calls reset.

    3. Where may I find my API key?

    Once you register for an account and log in, you will see a tab labeled, "API". Simply click on the tab and your API key will be visible.

    4. How may I cancel my subscription?

    Payment via PayPal:
    To cancel your subscription via PayPal, you will need to remove it from the "Preapproved Payments" page. You may find this page by logging in to your PayPal account and going to your "Profile". From here, you should click "Preapproved payments" under Payment settings. Now you may remove your subscription from the list of payments so you will not be charged anymore.

    Payment via Stripe:
    To cancel your subscription via Stripe, simply log in to your AltChat account and select, "Profile". From here, scroll to the bottom of the page and select the button to cancel your subscription.

    Applify - App Landing Page HTML Template

    Contact Us

    Send a message

    Please send us a message and we will get back to you shortly!

    Contact Info

    • Hours:

      • Monday - 10:00am - 5:00pm

      • Tuesday - 10:00am - 5:00pm

      • Wednesday - 10:00am - 5:00pm

      • Thursday - 10:00am - 5:00pm

      • Friday - 10:00am - 5:00pm

      • Saturday - 10:00am - 12:00pm

      • Sunday - CLOSED

    • United States - Eastern Timezone

    Applify - App Landing HTML Template