January 2017 Summaries
107 posts from Twilio
Filter
Month:
Year:
Post Summaries
Back to Blog
Environment variables are variables that describe an environment and can be used in programming languages to make code more flexible and safe by separating configuration values from code. They can be set on macOS and Linux distributions using the `export` command, on Windows using PowerShell, CMD, or the Graphical User Interface (GUI), and in some situations using .env files. Cloud providers such as Heroku, Azure, and AWS also support setting environment variables. Once set, environment variables can be used to access sensitive information like API keys without hardcoding them into code, making it easier to switch between environments and improve security.
Jan 26, 2017
1,825 words in the original blog post.
The Android Things platform is designed to make it easier for developers to build IoT applications using the Android framework and familiar tools. To get started with Android Things, users need a Raspberry Pi 3, an SD card, and the latest Android Things preview image. The process involves flashing the Android Things image to the SD card, booting up the Raspberry Pi, and connecting it to a network. Once connected, users can test Android applications on the device by writing and running a simple application using Android Studio. The platform is designed for IoT development and offers various possibilities for real-life applications such as home automation and security systems.
Jan 25, 2017
1,194 words in the original blog post.
The ESP8266 is a microcontroller that can be used to send SMS and MMS messages using C++ and the Arduino IDE. To start, sign up for a Twilio account and find or purchase an SMS-capable number with either SMS or both SMS and MMS capabilities. The ESP-8266 board has TLS 1.2 support, making it suitable for sending secure messages. A WiFi connection is required to connect to Twilio's REST API, and the SHA1 fingerprint of api.twilio.com must be verified before sending a message. The code uses WiFiClientSecure to create a TLS connection and manually constructs an HTTP POST request to send the message. The code also includes functions for base64 encoding and decoding, as well as creating a Basic Auth field for authentication. Once built, the example can be uploaded to the Arduino IDE and will send a SMS or MMS message to a specified number.
Jan 25, 2017
2,485 words in the original blog post.
This article describes how to use C#, Azure Functions, and Twilio to send daily SMS reminders. The service uses an Azure Table to store phone numbers that have subscribed to receive updates. When a new message is received from Twilio, the function checks if the text contains "subscribe" and adds or updates the phone number in the table accordingly. A second Azure Function runs daily at a specified time using a timer trigger to send SMS reminders to all users who have subscribed. The service uses Twilio's REST client to interact with the Twilio API and send messages.
Jan 24, 2017
1,831 words in the original blog post.
Twilio has released its semi-annual transparency report for the second half of 2016, providing visibility into government requests for information received by Twilio. The purpose of this report is to inform users about the total volume of government requests, how Twilio responded and notified users accordingly. This report aims to establish trust with Twilio's customers by being transparent about these requests.
Jan 20, 2017
134 words in the original blog post.
Building a phone-based jukebox that plays happy SEGA music to relive the feeling of MAGFest is a project that combines Ruby, Sinatra, and Twilio. The project involves creating an Interactive Voice Response (IVR) system that allows users to dial in and listen to their preferred SEGA soundtracks. To build this system, developers need to install dependencies like Twilio-ruby and sinatra, then copy and paste the provided code into a new file called app.rb. The system uses ngrok to generate a custom forwarding URL for public access and configures a phone number to send POST requests to the app whenever it receives a call. Once set up, users can dial in and listen to their preferred SEGA music, creating a nostalgic experience reminiscent of MAGFest.
Jan 18, 2017
857 words in the original blog post.
Twilio has been awarded its ISO 27001 certification, a widely recognized information security standard that validates an organization's Information Security Management System (ISMS). To achieve the certification, Twilio underwent an independent audit and demonstrated a systematic approach to managing and protecting company and customer data. The achievement is part of Twilio's ongoing efforts to improve security for its services, which support over a million developers. This certification follows Authy's recent SOC 2 report for the Security Trust Principle, further solidifying Twilio's commitment to security.
Jan 18, 2017
234 words in the original blog post.
The process of installing Java 8, Apache Maven and Google Web Toolkit on Windows 10 involves downloading and configuring each tool separately. First, the Java Development Kit (JDK) is installed by downloading version 8 of the JDK from the official website, allowing the user to set the `JAVA_HOME` environment variable. Next, Apache Maven is configured by adding its bin directory to the system's PATH environment variable, ensuring that the `mvn` command can be found. Finally, Google Web Toolkit (GWT) is installed and configured by adding its base directory to the PATH variable, allowing the user to use GWT's commands such as `webAppCreator`. With all tools properly set up, the user is now ready to start developing Java web applications using GWT.
Jan 13, 2017
1,212 words in the original blog post.
This post discusses building an IVR (Interactive Voice Response) system using TaskRouter as a state machine, without requiring any code. The author created an abstraction on top of TaskRouter to function as the backbone of the IVR system, utilizing TwiML Bins for hosting XML associated with each state. Each call coming in is represented as a task within TaskRouter, and the task's current attributes are used to determine which state the caller should move to next. The workflow syntax defined by TaskRouter is used to define the flow between different states, making it possible to build complex IVR workflows without writing code. This approach allows for generic, re-usable solutions, easy configuration changes, and automatic number formatting. The author provides an example of how this can be implemented using Node.js and TwiML Bins, and discusses potential applications and future development possibilities.
Jan 12, 2017
1,256 words in the original blog post.
Send SMS and MMS Messages In C++` is a tutorial that guides developers on how to use the Twilio REST API to send SMS and MMS messages using C++. The guide covers setting up a Twilio account, purchasing or finding an SMS-capable number, and building a C++ application using POSIX compliant libraries such as libcurl. The code demonstrates how to instantiate a `Twilio` object with account credentials, set up libcurl for HTTP POST requests, and send messages using the `send_message` method. The tutorial provides examples of running the code from the command line and includes resources for further learning and engagement with the Twilio community.
Jan 12, 2017
1,476 words in the original blog post.
Logrole is an open-source tool built with Go that enables organizations to delegate limited, role-based access to Twilio logs and search them faster and with more granularity. It allows developers to set customizable permissions for their Twilio Logs, limiting access to sensitive data such as SMS & MMS messages and specific dates. The tool is designed to make it easier for teams to search for and work with Twilio data, taking into account time zones and user-specific settings. With its Go-based architecture, Logrole provides a secure and efficient way to manage Twilio logs, making it an attractive solution for developers and organizations looking to streamline their workflow.
Jan 11, 2017
521 words in the original blog post.
Twilio Add-ons are pre-integrated third-party services that can be used with Twilio applications to enhance the responses received from Twilio by including additional data from Twilio's partners. To use an add-on, first enable it in the Twilio Console and then select the recording method and set a callback URL as needed. The add-on data will be included in an "AddOns" field on HTTP requests made to your application. In this guide, we used the IBM Watson Speech to Text Add-on to convert Twilio audio recordings into text using machine intelligence. The generated transcription is pushed to the application through a callback from Twilio, allowing developers to access and utilize the additional data in their PHP applications.
Jan 10, 2017
778 words in the original blog post.
This is a summary of the provided text in one paragraph:
The Ruby on Rails sample application models a typical call center experience for stranded aliens, allowing them to receive instructions on how to get off Earth safely. The application uses Twilio's API to route calls to agents, screen calls, and record voicemails. The code includes routes for screening calls, connecting calls to agents, recording voicemails, and viewing agent voicemails. The application also features a user interface with options for aliens to choose from, including Brodo, Dugobah, and Oober asteroid locations. The code uses TwiML to generate voice responses and dial phone numbers using Twilio's API.
Jan 10, 2017
3,871 words in the original blog post.
This tutorial provides a step-by-step guide on implementing SMS and MMS marketing notifications for a Ruby on Rails application using Twilio's services. The process involves creating a subscriber model, handling incoming messages, processing commands from subscribers, and sending marketing messages to subscribers via SMS or MMS. The implementation requires setting up Twilio account credentials, generating an Active Record model, and defining the logic for managing subscriptions and sending messages. The tutorial concludes with examples of how to implement key features such as receiving incoming messages, handling subscriber opt-in requests, and sending marketing messages.
Jan 10, 2017
1,928 words in the original blog post.
To block spam calls with PHP and Laravel, developers can use Twilio's Add-ons Marketplace to integrate third-party technologies that filter out unwanted callers. The process involves installing an add-on such as Marchex Clean Call or Nomorobo Spam Score, configuring the add-on to work with Twilio's API, and writing custom code in PHP to check the spam score of incoming calls and reject spammers accordingly. The code uses Laravel middleware to handle incoming requests and TwiML responses to control the flow of calls. Once set up, the application can be configured to call a public host or use ngrok for local testing, and developers can test blocked calls using unit tests with dummied-up JSON data.
Jan 10, 2017
1,474 words in the original blog post.
This Ruby on Rails sample application allows users to create a conference line with moderation capabilities, as well as broadcast voice messages to a list of phone numbers. The app uses Twilio's REST API to power its features, including creating a conference number, connecting callers to the conference, and broadcasting recorded messages. The code is written in Ruby and utilizes the Twilio Ruby library to interact with the Twilio API.
Jan 10, 2017
2,778 words in the original blog post.
This summary provides a comprehensive overview of the Automated Survey application built using ASP.NET MVC and Twilio C# helper library. The application allows users to complete surveys via voice calls, with features such as dynamic survey creation from questions stored in a database, gathering diverse types of information, and storing responses for later analysis. The application's routing is handled by controllers that handle incoming calls, gather user input, and store responses in the database. The application also includes routes for displaying survey results and handling webhook requests. Throughout the tutorial, code samples are provided to demonstrate key concepts and steps involved in building the application.
Jan 10, 2017
1,819 words in the original blog post.
This employee directory application uses Ruby on Rails and Twilio to allow users to query for employee information by sending an SMS with the employee's name to a designated Twilio number. The application handles three possible scenarios: finding an exact match, a single partial match, and multiple partial matches. In each scenario, it sends a TwiML response back to Twilio, which then sends an SMS message to the user containing the relevant information or suggestions for further action. The application also uses Twilio Cookies to store search suggestions in the browser's cookies, allowing users to build on previous searches and providing a more seamless experience.
Jan 10, 2017
878 words in the original blog post.
A Ruby-based warm transfer system using Sinatra has been implemented. The system allows for real-time transfers between agents in a call, eliminating disconnections during support calls. It uses Twilio's Voice Web Client to connect and manage the agents, as well as TwiML to provide instructions to clients on how to join conferences. The system also handles warm transfers between agents, allowing them to seamlessly take over calls from each other. With this implementation, developers can create a more efficient and effective support experience for their customers.
Jan 10, 2017
1,753 words in the original blog post.
This tutorial demonstrates how to use Twilio's Programmable SMS service in a PHP and Laravel application to send instant lead alerts for real estate agents. It starts by creating a landing page with a form that collects user contact details, which are then sent to the agent's phone number via an authenticated Twilio REST API client when a new lead is received. The tutorial also covers how to handle HTTP POST requests from the form, format messages with lead information, and send SMS messages using Twilio's REST Client.
Jan 10, 2017
965 words in the original blog post.
The tutorial describes how to create an automated survey using the Twilio API with Ruby on Rails. It covers the flow of a Twilio-powered survey as an interview loop, including configuring a Twilio number, responding to requests from calls and SMS, handling responses, and displaying survey results. The application uses a combination of controllers (SurveysController, QuestionsController, AnswersController) and models (Survey, Question, Answer) to store and process user input. It also includes a sample survey and instructions on how to set up the application for testing.
Jan 10, 2017
1,477 words in the original blog post.
This Java Servlet application demonstrates how to use Twilio to track the effectiveness of different marketing channels by purchasing phone numbers, forwarding incoming calls, and recording statistics. The application consists of three main features: search for available phone numbers, buy a phone number, and display charts showing data about the phone numbers and calls they receive. The backend part of the code creates LeadSources and Twilio Numbers, while the frontend uses JavaScript and Chart.js to visualize statistics.
Jan 10, 2017
2,096 words in the original blog post.
The Express sample application is a call center experience where stranded aliens can call an agent for instructions on how to get off Earth safely. The application allows agents to screen calls, connect with callers, and record voicemails. The code uses Twilio's VoiceResponse API to create an interactive voice response (IVR) system. The IVR includes features such as routing the call to an extension based on the caller's input, dialing the agent's phone number, and displaying recordings of voicemails. The application also handles scenarios where agents are unavailable or have left a message after the beep.
Jan 10, 2017
1,881 words in the original blog post.
The Employee Directory application is a Twilio-based ASP.NET MVC application that allows users to search for employees by name or ID and receive their contact information via SMS. The application uses Entity Framework Code First, C#, and ASP.NET MVC to build the directory. It includes features such as searching by partial names, handling multiple matches, caching employee IDs in cookies, and returning an employee's contact information based on user input.
Jan 10, 2017
2,933 words in the original blog post.
This ASP.NET MVC application uses Twilio to track the effectiveness of different marketing channels by purchasing phone numbers, forwarding incoming calls, and displaying charts showing data about the phone numbers and calls they receive. The application has three main features: searching for available phone numbers, buying phone numbers, and displaying statistics on lead sources. The backend part of the code creates a LeadSource and associates it with a Twilio number, while the frontend uses jQuery to fetch call tracking statistics in JSON from the server and display them in colorful pie charts created with Chart.js.
Jan 10, 2017
1,899 words in the original blog post.
This summary provides an overview of how to block spam calls and robocalls using Java and Twilio's Add-ons Marketplace. The process involves integrating third-party technologies with the Twilio API to filter out spam callers, including Marchex Clean Call and Nomorobo Spam Score. A simple Servlet application is provided as an example code to demonstrate how to check the spam score of a number and block or accept calls based on the result. The application can be configured to use different call handling options, such as rejection or acceptance, and can be tested using unit tests or by calling the Twilio number directly. The Twilio Add-ons Marketplace offers various options for extending Twilio apps, and resources are provided for further learning and support.
Jan 10, 2017
1,328 words in the original blog post.
ETA Notifications with PHP and Laravel` is a tutorial that guides developers through building a notification system for an on-demand laundry service using PHP and Laravel. The system uses Twilio's REST API to send SMS notifications to customers when their orders are picked up or delivered. The tutorial covers setting up the Twilio REST client, sending SMS messages, handling status callbacks from Twilio, and integrating the system with the Laravel application. It provides a basic example of how to implement an on-demand notification service using PHP and Laravel, and can be extended to include additional features such as automated workflows, disposable phone numbers, and more.
Jan 10, 2017
1,437 words in the original blog post.
The text provides a step-by-step guide on implementing warm transfers for support applications using Ruby on Rails and Twilio. Warm transfer allows an agent to join a call in progress, eliminating the need to re-dial a customer's phone number. The process involves setting up a voice web hook, connecting agents to calls, generating capability tokens, handling incoming calls, providing TwiML instructions, dialing agents into calls, and performing warm transfers when necessary. The guide also includes code snippets for various parts of the implementation.
Jan 10, 2017
1,750 words in the original blog post.
This tutorial demonstrates how to send SMS alerts using Ruby and the Sinatra framework with the Twilio REST client. The application first configures the Twilio client by reading account SID and auth token from environment variables, then creates an administrator list in YAML format that contains phone numbers for system administrators. When an exception occurs, the `Notifier` module sends a message to each administrator on the list using the `send_sms` method. This process involves creating a Twilio REST client, handling application exceptions, triggering notifications for each entry in the administrator list, and sending a text message with three required parameters: from, to, and body. The tutorial concludes by highlighting additional features of the Twilio Ruby SDK that can be integrated into applications.
Jan 10, 2017
870 words in the original blog post.
The Spark Java application demonstrates how to send SMS alerts when a server error occurs. The application first reads administrators' phone numbers from a JSON file using the Gson library, then configures the Twilio REST Client to send messages with the phone number of each administrator and a custom message. The application handles exceptions by mapping them to a configured type for all routes and filters, sending alerts to administrators when an exception occurs. A custom alert message is created to include a picture or screenshot, and the application logs requests and responses using a logging filter.
Jan 10, 2017
1,063 words in the original blog post.
This PHP application uses Laravel as its framework and Twilio for sending SMS notifications when an exception occurs on the server. The application allows administrators to be notified in case of a server error, with customizable messages that include details about the error. The system also reads administrators' phone numbers from a JSON file, which is used to send alerts via text message. The code uses Laravel's built-in exception handling mechanism and extends it with custom functionality for sending SMS notifications using Twilio's REST API.
Jan 10, 2017
2,070 words in the original blog post.
This tutorial demonstrates how to create an automated survey using Twilio's PHP SDK and Laravel framework. The survey can be completed over the phone or via SMS, with options for voice recording and transcription. The application stores user responses in a database and provides a visual representation of the results, including playback icons for recorded answers and transcribed voice responses.
Jan 10, 2017
3,089 words in the original blog post.
This summary provides a high-level overview of how to implement SMS and MMS marketing notifications using PHP and Laravel with Twilio. The system allows users to opt-in or out of receiving marketing messages, and administrators can create and send messages to subscribers through a web interface. The process involves creating a Subscriber model to track user preferences, implementing subscribing and opting-out logic in the controller, and setting up business logic for sending marketing messages. The application uses Twilio's REST API to send SMS and MMS messages, requiring account credentials and a phone number to be set up in the `.env` file. The system also includes features such as redirecting users back to the notification creation page after sending a message and providing feedback on messaging attempts.
Jan 10, 2017
2,042 words in the original blog post.
The automated survey system using Java and Spring allows users to take a survey over the phone or via SMS, with the system storing and processing their responses. The system uses Twilio's API to handle incoming calls and texts, and returns TwiML responses to guide the user through the survey. The system stores responses in a database, and provides a display of results for each question in the survey.
Jan 10, 2017
2,820 words in the original blog post.
This Java Servlets tutorial explains how to automatically notify system administrators when something goes wrong on a server using Twilio for SMS and MMS notifications. The tutorial covers the following key points: creating a list of administrators, configuring the Twilio client, handling application exceptions, crafting custom alert messages, loading administrators from a JSON file, and sending text messages. The tutorial provides sample code and examples to help developers implement this functionality in their own applications.
Jan 10, 2017
1,109 words in the original blog post.
This automated survey system uses Twilio's Voice and SMS capabilities to collect structured data from users over the phone or via text message. The system is built using Node.js and Express, with a MongoDB database to store survey responses. The system uses TwiML (Twilio Markup Language) to generate speech and audio prompts for the user. It also handles user input, including recorded speech and DTMF tones, and updates the survey response in real-time. The system provides a way to view survey results, including charts and tables, and allows users to play back recordings of their responses.
Jan 10, 2017
5,497 words in the original blog post.
This ASP.NET MVC sample application demonstrates a call center experience for stranded aliens who need help getting off Earth safely. The application uses Twilio's API to route calls to agents, screen incoming calls, and send voicemails. The code is written in C# and covers various aspects of IVR development, including routing, screening, recording, and playing back voicemails. The application also includes a view for displaying an agent's recordings.
Jan 10, 2017
2,391 words in the original blog post.
This tutorial guides developers on how to use Twilio to send automated server notifications in a Django application. The notification system is designed to alert administrators when the server encounters an error or exception, providing them with essential information about the issue. To implement this system, developers need to create a list of administrators' phone numbers, configure a Twilio REST client, and set up middleware to handle exceptions and send notifications. The tutorial covers key aspects of sending text messages using the Twilio API, including specifying sender, recipient, and message body parameters. By following these steps, developers can build an automated notification system that enhances their application's reliability and responsiveness.
Jan 10, 2017
1,690 words in the original blog post.
The summary is as follows: Implementing warm transfers using Java Servlets with Twilio involves setting up a voice webhook, generating capability tokens, handling incoming calls, providing TwiML instructions, dialing agents into the call, and handling agent disconnections. The process requires configuring a Twilio number, creating a servlet to handle requests, and using Twilio's SDK to connect agents to calls. With this implementation, clients will no longer be disconnected from support calls while being transferred to another agent.
Jan 10, 2017
2,024 words in the original blog post.
This tutorial demonstrates how to implement instant lead alerts for a Python and Flask application using Twilio Programmable SMS. It creates a landing page for a new house on the market and notifies a real estate agent instantly when a potential customer requests information. The application uses environment variables to store Twilio account credentials, initializes an authenticated Twilio REST API client, handles incoming POST requests, and sends SMS messages to the real estate agent's phone number with the lead's name, phone number, and inquiry. The tutorial showcases how to integrate Twilio with Flask to enable instant routing of leads to salespeople using text messages.
Jan 10, 2017
1,112 words in the original blog post.
This Express.js application uses Twilio to track the effectiveness of different marketing channels by purchasing phone numbers from Twilio, forwarding incoming calls to a salesperson, and displaying charts showing data about the phone numbers and calls they receive. The application has three main features: searching for available phone numbers, buying phone numbers, and displaying statistics on lead sources and cities. The client-side JavaScript application fetches call tracking statistics in JSON from the server using jQuery and displays them in colorful pie charts created with Chart.js.
Jan 10, 2017
2,014 words in the original blog post.
In this guide, we'll cover how to combine Twilio Add-ons with Programmable Voice to use data from Twilio's partners in your Express web application. Twilio Add-ons are pre-integrated third party services that enhance the responses your application receives from Twilio by including additional data from Twilio's partners. The sample code uses the Twilio Node SDK and the Express web framework, starting with the IBM Watson Speech to Text Add-on. To use an add-on, first enable it in the Twilio Console, then select the recording method and set a callback URL. In your application, access add-on data within an "AddOns" field on HTTP requests. The guide demonstrates how to use the IBM Watson Speech to Text Add-on to convert Twilio audio recordings into text using machine intelligence.
Jan 10, 2017
774 words in the original blog post.
This tutorial demonstrates how to implement warm transfers using Python and Flask with Twilio. The application allows a customer to call in and be connected with a support agent, who is then able to transfer the call to another available agent, allowing for seamless communication between agents and clients. The code includes various components such as TwiML instructions, capability token generation, and handling of incoming calls, as well as features like dialing the first agent into the call and handling the first agent leaving the call. The tutorial also mentions additional features that Twilio offers to further enhance the application, including survey collection, browser-to-phone and browser-to-browser calls, and more.
Jan 10, 2017
1,952 words in the original blog post.
'Block Spam Calls and Robocalls with Node.js' is a tutorial that guides developers on how to use Twilio's Add-ons Marketplace to block spam calls and robocalls using Node.js. The tutorial covers the basics of setting up an Express application, integrating third-party technologies through Add-ons, checking phone number scores in Node.js, making block call decisions, and configuring a phone number webhook. It also provides examples and tips for testing and debugging the application. The goal is to help developers build a robust system that can effectively filter out spam calls and improve customer service.
Jan 10, 2017
1,325 words in the original blog post.
Automated Survey with Python and Flask` is a tutorial that guides developers through the process of creating an automated survey using Twilio's API. The survey can be answered over phone or SMS, and the responses are stored in a database. The tutorial covers the flow of the survey, including how to configure a Twilio number, handle requests from the user, and redirect them to the next question. It also shows how to build TwiML verbs for different types of questions and handle responses from the user. Finally, it demonstrates how to visualize the results of the survey using Flask and SQLAlchemy. The tutorial provides a comprehensive overview of creating an automated survey with Python and Flask using Twilio's API.
Jan 10, 2017
1,886 words in the original blog post.
This tutorial demonstrates how to use Node.js and Express to send instant lead alerts to a sales team using Twilio Programmable SMS. It covers the setup of a landing page that generates leads, the creation of a Twilio REST API client, and the implementation of a route to handle incoming lead requests. The code allows for the automatic sending of text messages to a designated agent's phone number with the lead's name, phone number, and inquiry details. This enables the sales team to respond promptly to new leads and improve customer engagement.
Jan 10, 2017
1,380 words in the original blog post.
This employee directory application uses Java with servlets to query an employee database via SMS using Twilio. The application can handle three scenarios: finding a single employee match, finding multiple matches, and handling no matches. It also uses cookies to cache search suggestions for future queries. The application is designed to provide a simple way for users to request information about specific employees by sending an SMS to a designated Twilio number.
Jan 10, 2017
1,425 words in the original blog post.
The Twilio Add-ons are pre-integrated third-party services that can be used with a Twilio application to enhance the responses received from Twilio by including additional data from Twilio's partners. The IBM Watson Speech to Text Add-on converts Twilio audio recordings into text using machine intelligence and can be integrated with a Sinatra web application using the Twilio Ruby SDK. To use an add-on, it must be enabled in the Twilio Console, where the user selects the recording method, sets the callback URL and request method, and accepts the Terms of Service. The add-on data is then included in the "AddOns" field on HTTP requests made to the application. An example application demonstrates how to access this data within the application, using the IBM Watson Speech to Text Add-on to retrieve the transcription for a recorded call.
Jan 10, 2017
892 words in the original blog post.
Call Tracking with PHP and Laravel` is a tutorial that demonstrates how to use Twilio to track the effectiveness of different marketing channels using a Laravel web application. The application has three main features: purchasing phone numbers, forwarding incoming calls, and displaying charts showing data about the phone numbers and the calls they receive. The code covers various aspects of building this application, including searching for available phone numbers, creating a LeadSource model to store lead source information, and using Eloquent queries to retrieve statistics about the leads. The tutorial concludes by showcasing how to visualize these statistics with Chart.js.
Jan 10, 2017
2,413 words in the original blog post.
This guide shows how to block spam calls and robocalls using the Twilio Marketplace and Ruby skills. It starts by integrating third-party technologies, such as Marchex Clean Call and Nomorobo Spam Score, into the Twilio API. The code uses these Add-ons to check the phone number score of incoming calls and reject or accept them based on the advice provided by each Add-on. The guide also covers call handling options, rejection options, and configuring a phone number webhook. It provides example code and unit tests to test blocked calls and demonstrates how to use Twilio's Add-ons Marketplace to extend Twilio apps.
Jan 10, 2017
1,174 words in the original blog post.
This tutorial demonstrates how to implement instant lead alerts for a real estate agency using Java and Twilio Programmable SMS. A landing page with a form is created to generate leads, which are then sent to a servlet that populates the data into a JSP template. The servlet uses a helper class to initialize a Twilio REST API client, which is used to send an SMS message to a real estate agent's phone number when a new lead is received. The message includes the lead's name, phone number, and inquiry. The tutorial also provides additional information on how Java and Twilio can be used together, including examples of click-to-call functionality and IVR systems.
Jan 10, 2017
1,078 words in the original blog post.
Ruby on Rails is used to send SMS (Short Message Service) alerts to a list of system administrators if something goes wrong on the server. The application uses the Twilio REST API to send messages. A YAML file is used to store the phone numbers of the administrators. The `rescue_from` method is used to rescue any exception raised in controller actions and trigger SMS alerts when something goes wrong. Custom alert messages can be created using a template, and images can be included with the message for US and Canadian phone numbers. The application also includes features such as sending reminders and reducing no-shows.
Jan 10, 2017
1,285 words in the original blog post.
The implementation of warm transfers using Node.js and Express involves several key components, including the setup of a Twilio-powered voice webhook, the generation of capability tokens for agents, and the use of TwiML to instruct clients on how to join conferences. The code provides a comprehensive example of how to handle incoming calls, warm transfers, and agent connections, using a combination of Node.js, Express, and Twilio's REST API and SDKs.
Jan 10, 2017
2,104 words in the original blog post.
To make an outbound phone call with Delphi, you'll need a voice-capable Twilio phone number, your account credentials, and the TTwilioClient library. You can retrieve your account credentials from the Twilio console and use them to create a new instance of the TTwilioClient. Then, you can use the `Post` method to make an outbound call by passing in parameters such as the "From" phone number, the destination number, and a URL that returns TwiML instructions. The TwiML document defines what actions should be taken when the other party picks up the phone or responds with an SMS message. You can use server-side code to dynamically render TwiML for the outbound call. The example provided uses a static file but shows how TwiML can be used in various scenarios, including inbound calls and server-generated responses.
Jan 10, 2017
685 words in the original blog post.
The application allows users to purchase phone numbers from Twilio for use in marketing campaigns, forward incoming calls to a salesperson, and display charts showing data about the phone numbers and calls they receive. The backend code is written in Python and Django, with a custom utility module used to search for available phone numbers, purchase new numbers, and associate them with lead sources. The frontend code is a simple JavaScript application that fetches call tracking statistics in JSON from the server and displays them in colorful pie charts using Chart.js.
Jan 10, 2017
3,717 words in the original blog post.
SMS and MMS marketing notifications with Java and Servlets` is a tutorial that guides developers on how to implement an opt-in process and an administrative interface to run SMS and MMS marketing campaigns using Twilio's API and Java. The tutorial covers the building blocks of the system, including the Subscriber model, handling incoming messages, managing user subscriptions, sending notifications out, and sending SMS or MMS notifications. It also provides a closer look at how to send SMS or MMS notifications using the Twilio Message API client. The tutorial concludes by highlighting related resources and encouraging developers to check out other excellent tutorials on Java development with Twilio.
Jan 10, 2017
1,509 words in the original blog post.
This Flask application uses Twilio to connect incoming phone calls to other phone numbers based on where the caller lives. When a user dials in, we look up some information based upon their assumed location and trigger actions inside our application. The application connects callers to the offices of their U.S. senators. Communication can be a powerful force for change, and this sample application demonstrates how civic engagement tools can increase participation in democracy. To run this sample app, download the code and follow the README instructions on Github. The application uses Twilio's Python Helper Library to interact with the Twilio API, sets up a Twilio account and Flask application, configures a webhook endpoint for accepting inbound calls, handles the inbound Twilio request, builds out a TwiML response to welcome the caller and ask for confirmation of their state of residence, connects the caller to their first senator, forwards the call to the next senator, and ends the call with a message thanking the user. The application is not production-ready and requires further development to flesh out its functionality. However, it demonstrates how civic engagement tools can be built using Twilio's APIs and Flask.
Jan 10, 2017
3,391 words in the original blog post.
This ASP.NET application uses Twilio to connect incoming phone calls to other phone numbers based on the caller's location. The application allows users to dial in and be routed to a regional office or directed to a survey after their interaction with customer service. In this tutorial, we've learned how to build a call forwarding system using C# and ASP.NET MVC, with Twilio as the API provider. We've covered key points such as setting up a Twilio account, configuring the application, handling incoming calls, verifying state information, and routing users to their senators' offices. The application is built using a combination of Razor views, controllers, models, repositories, and TwiML endpoints. We've also seen how to handle missing state information, forward calls to multiple senators, and end calls with a thank-you message. With this tutorial, developers can create their own call forwarding systems that seamlessly route users to the right resources based on their location.
Jan 10, 2017
3,802 words in the original blog post.
A C# and ASP.NET MVC application can be used to implement SMS and MMS marketing notifications using Twilio tools. The application requires a Subscriber model to keep track of users who have requested to receive messages, and a MessageCreator abstraction that produces the message to be returned to the sender. The application also includes logic for managing incoming messages, creating new subscribers, and sending out messages via Twilio's REST API. The controller handles form submissions, validates user input, and updates subscriber status accordingly. The NotificationService class is responsible for sending SMS or MMS notifications using Twilio's Message API. With this implementation, a marketing team can use the application to send perfectly crafted messages to subscribers, who have opted-in to receive notifications via text or MMS.
Jan 10, 2017
1,638 words in the original blog post.
This tutorial guides you through building an automated survey for Voice or SMS using the Twilio Python SDK and Django. The application allows users to take a survey by calling or sending an SMS to a configured phone number, with each question answered either via voice input or text message response. The survey's progress is tracked using a session ID, and responses are stored in the database for later analysis. The system includes endpoints for displaying the survey results, redirecting to the next question, and handling incoming Twilio requests to process user inputs. With this application, you can create a simple automated survey with a user-friendly interface, making it easy to collect data from your users.
Jan 10, 2017
2,327 words in the original blog post.
This Spark application uses the Twilio API to create an automated survey conducted over SMS or phone call. The application reads a JSON object with questions into a Java object using Google's Gson library. It then interacts with Twilio and uses a factory-based approach to build TwiML responses, which are used to guide the user through the survey. The application stores the caller's response in MongoDB and displays the survey results on a dynamic dashboard. The code is well-structured and follows good object-oriented design principles.
Jan 10, 2017
2,263 words in the original blog post.
In this guide, Twilio Add-ons are introduced as pre-integrated third-party services that enhance the responses from Twilio by including additional data from partners. The IBM Watson Speech to Text Add-on is used in an example to convert audio recordings into text using machine intelligence. To use an add-on, it must be installed on a Twilio account and configured with a callback URL. Once installed, the add-on's data can be accessed within an HTTP request made to the application. The guide also provides information on how to enable add-ons in the Twilio Console and how to use their data in a C# (ASP.NET MVC) web application.
Jan 10, 2017
671 words in the original blog post.
This Laravel sample application demonstrates the implementation of a call center experience using Twilio's IVR capabilities. The application allows stranded aliens to call an agent and receive instructions on how to get off Earth safely, while also providing a screening process for the agents to interact with the calls. The system includes features such as call routing, voicemail recording, and transcription, as well as displaying recordings for each agent. The application uses Laravel and Twilio's PHP library to build this interactive voice response (IVR) system.
Jan 10, 2017
2,211 words in the original blog post.
This tutorial demonstrates how to implement a notification system for an on-demand laundry service using Java and Twilio. The system sends SMS notifications to customers when their orders are picked up or arriving, providing real-time updates on the status of their laundry delivery. The implementation involves creating two servlets: `OrderDeliverServlet` and `OrderPickupServlet`, which handle HTTP POST requests triggered by the delivery person. These servlets use the Twilio REST API Client to send SMS messages to customers' phone numbers, with optional media attachments. Additionally, the system provides a mechanism for handling message status updates from Twilio, allowing for real-time tracking of notification delivery and resending failed messages or sending automated surveys. The tutorial concludes by highlighting other Java Servlets tutorials that showcase the potential of integrating Java and Twilio for building scalable communication workflows.
Jan 10, 2017
1,143 words in the original blog post.
This Ruby on Rails application demonstrates how to use Twilio for call tracking with marketing channels. The application allows users to search for available phone numbers, purchase them, forward incoming calls to a salesperson, and display charts showing data about the phone numbers and calls they receive. The backend part of the code creates a LeadSource as well as a Twilio Number and associates it with a lead source in the database. The frontend uses jQuery and Chart.js to fetch call tracking statistics from the server and display them in colorful pie charts.
Jan 10, 2017
1,464 words in the original blog post.
Automating the testing of C# applications that use third-party APIs like Twilio can be complex, but utilizing the Moq framework simplifies the process by allowing developers to create mock objects for testing purposes. The guide outlines how to structure a C# app and create a test project using Visual Studio, while Moq facilitates isolated testing by decoupling code that interacts with external APIs, such as Twilio, into separate services like a NotificationService. This separation enhances testability and ensures that application logic can be tested without directly invoking the external API. The guide also emphasizes decoupling API credential configurations using a NotificationConfiguration class, which can be mocked to test different scenarios during development. By employing Moq, developers can test the logic of methods like ProcessOrder by verifying interactions with the NotificationService, while Twilio's test credentials enable testing of SMS and phone call functionalities without incurring real charges. The tutorial provides a comprehensive walkthrough of setting up and executing these tests, ensuring that developers can maintain robust, reliable applications that integrate with Twilio's services.
Jan 10, 2017
1,888 words in the original blog post.
This tutorial demonstrates the implementation of a notification system for an on-demand laundry service using C# and ASP.NET MVC. The system sends SMS notifications to customers when their orders are picked up or arriving at their doorstep. The notification process involves triggering HTTP POST requests, sending messages through Twilio's REST API, and handling status callbacks to update notification statuses in the database. The code provides a basic example of how to build such a system, but also mentions additional features that can be easily added, such as automating workflows and protecting user privacy.
Jan 10, 2017
1,621 words in the original blog post.
Using Twilio Add-ons with Programmable Voice allows developers to combine pre-integrated third-party services into their applications, enhancing responses from Twilio by including additional data from partners. To use an add-on, developers must enable it in the Twilio Console, select recording methods, and set a callback URL. Once installed, Twilio includes add-on data in HTTP requests to the application, which can be accessed using various programming languages such as Python. The provided example uses Flask and the Twilio Python SDK to demonstrate how to access add-on data from an IBM Watson Speech to Text Add-on, which converts audio recordings into text using machine intelligence. By integrating add-ons with Programmable Voice, developers can build applications that provide more valuable insights and experiences for users.
Jan 10, 2017
763 words in the original blog post.
This tutorial demonstrates how to implement instant lead alerts for a fictional real estate agency using Ruby on Rails and Twilio Programmable SMS. The application creates a landing page with a form that users can fill out to request information, and when the form is submitted, it sends an SMS message to a designated real estate agent's phone number with the user's contact information and inquiry details. The tutorial covers setting up the Twilio REST API client, handling incoming lead POST requests, and integrating the messaging functionality into the application.
Jan 10, 2017
959 words in the original blog post.
This Spark application uses Twilio to connect incoming phone calls to other phone numbers based on where the caller lives. The application verifies or collects state information from the user before connecting them with their senators' offices. It builds a response with TwiML, handles missing state information, and forwards the caller to their second senator after the first call ends. The application is currently seeded with placeholder data but can be extended by using ProPublica's API for government data or other resources.
Jan 10, 2017
4,084 words in the original blog post.
This is a summary of the text in one paragraph:
The article describes how to create an automated survey using Twilio API and Java Servlets. The survey can be taken over phone or SMS, and the user's input is stored in a database after each question. The server responds with instructions on how to proceed, such as redirecting the user to the next question or finishing the survey. The article provides code examples for creating the survey, handling responses from Twilio, and displaying the results of the survey. It also covers topics such as building TwiML verbs, handling responses, and displaying survey results in a JSP page.
Jan 10, 2017
3,429 words in the original blog post.
This tutorial demonstrates how to implement an on-demand notification system for a fake laundry service using Node.js and Express. The system allows delivery drivers to trigger notifications when picking up or delivering orders, which are then sent via Twilio's SMS API. The system also handles incoming Twilio callbacks to update the notification status of each order, allowing for automation and business logic to be applied as needed. The tutorial covers key concepts such as routing, middleware, and model methods, providing a comprehensive overview of how to build a scalable and reliable notification system using Node.js and Express.
Jan 10, 2017
1,359 words in the original blog post.
To block spam calls and robocalls using Python with Twilio, you need to integrate third-party technologies such as Marchex Clean Call and Nomorobo Spam Score into your Twilio application. You can use these add-ons through the Twilio Console and configure them to send data to your webhook, which then checks the spam score of the caller and rejects or accepts the call accordingly. The decision-making process is based on a majority vote among the add-ons, with any single add-on advising against blocking being overridden by another. You can customize the call handling options, such as rejection or acceptance, using TwiML tags. Once configured, you can test your application by calling your Twilio number and verifying that it handles spam calls correctly.
Jan 10, 2017
1,405 words in the original blog post.
This Java Servlets sample application models a typical call center experience with stranded aliens receiving instructions on how to get off Earth safely. The application allows agents to screen calls, connect calls, and record voicemails. It also includes features such as call screening, agent availability checks, and voicemail playback. The application uses Twilio's Voice API to handle phone calls, text messages, and recordings.
Jan 10, 2017
1,783 words in the original blog post.
This employee directory system allows users to query for an employee's information by sending a text message with the employee's name to a Twilio number. The system handles three possible scenarios: single partial match, multiple partial matches, and no match. It uses Twilio Cookies and Laravel Sessions to store search suggestions and cache previous searches. The system is implemented using PHP and Laravel, with a focus on developer experience and ease of use.
Jan 10, 2017
1,450 words in the original blog post.
Adding notifications on server exceptions to a C# ASP.NET MVC application allows administrators to be notified in case of any issues with the server. The application uses the Twilio REST client to send SMS and MMS notifications, and it handles application-wide errors by forwarding them to a list of administrators who have provided their phone numbers. The notification system is configured using a CSV file that contains the administrator's names and phone numbers. The error handling process captures application-wide errors and sends a custom alert message to each administrator in the list, including the exception details and a link to New Relic for further details.
Jan 10, 2017
1,003 words in the original blog post.
This Spark sample application is a Rapid Response Kit built by Twilio that enables aid workers to communicate immediately with a large group of volunteers in disastrous situations. The app uses the Twilio Java library to generate TwiML responses for conference calls, moderated conferences, and voice broadcasts. The application allows users to create conference numbers, join or connect to conferences, broadcast messages to phone numbers, and record new messages. The code is written in Java and utilizes Spark as a web framework.
Jan 10, 2017
3,757 words in the original blog post.
The tutorial explains how to implement a notification system for an on-demand laundry service using Ruby on Rails and Twilio's SMS service. The system sends notifications when the order is picked up or arriving, and also handles callbacks from Twilio to update the notification status of the order. The notification system uses a MessageSender class to send SMS messages with optional media attachments. The tutorial provides an example implementation for sending an SMS message with a picture attachment. Additionally, it discusses how to handle callback requests from Twilio to update the notification status and add logic to resend the message if it fails or send out an automated survey soon after delivery.
Jan 10, 2017
1,195 words in the original blog post.
The tutorial describes how to implement warm transfers in a PHP and Laravel application using Twilio's Voice Web Client. The key points include setting up the voice web hook, generating a capability token, handling incoming calls, providing TwiML instructions to the client, dialing the first agent into the call, dialing the second agent into the call, and letting the first agent leave the call. The application uses Laravel's routing system to handle requests from the client and Twilio's REST API to create and manage phone calls. The tutorial provides a sample implementation that can be used as a starting point for building a similar system.
Jan 10, 2017
2,794 words in the original blog post.
This tutorial provides a comprehensive guide on implementing warm transfers using ASP.NET MVC and Twilio for a support call center. The implementation involves setting up a voice webhook, generating capability tokens, handling incoming calls, providing TwiML instructions to the client, dialing agents into the call, and handling the first agent leaving the call. The code samples provided demonstrate how to use Twilio's REST API and SDKs to create a seamless warm transfer experience for clients.
Jan 10, 2017
2,161 words in the original blog post.
The application uses Twilio to connect incoming phone calls to other phone numbers based on the caller's location. It provides a sample use case for automatically routing customers to regional offices or directing callers to surveys after interacting with customer service. The code sets up a Twilio account and Sinatra application, configures the webhook endpoint, handles inbound Twilio requests, builds TwiML responses, and forwards calls to senators' offices. The application uses data mapping helpers to interact with a local database and seed it with sample data for testing and development purposes. Once the call with the second senator ends, the user hears a thank-you message and the call is ended with `<Hangup>`.
Jan 10, 2017
2,897 words in the original blog post.
This Express application uses Twilio to connect incoming phone calls to other phone numbers based on where the caller lives. When a user dials in, the application looks up some information based upon their assumed location and triggers actions inside the application. The application is designed to automatically route customers to a regional office or direct callers to a survey after their interaction with customer service. In this sample application, the users' senators' offices are connected. The application uses Twilio's Node Helper Library to interact with the Twilio API and set up a Twilio account and the Express application itself. A webhook endpoint is created for the application to accept inbound calls, and the `action` attribute is used to redirect the call to another route when the first senator ends the call. The application also includes a thank-you message and an end to the call with `<Hangup>`. To run this sample app, you need to download the code and follow the README instructions on Github.
Jan 10, 2017
3,768 words in the original blog post.
This PHP application uses Twilio to connect incoming phone calls to other phone numbers based on the caller's location. The application allows users to call their senators by providing their 5-digit zip code, and then connects them with both of their senator's offices. The application uses TwiML to build a response that welcomes the caller, asks for confirmation of their state of residence, and redirects them to either the first or second senator based on the user's input. If the user's state is not recognized, they are prompted to enter their 5-digit zip code again. Once the call with the first senator ends, the caller is forwarded to the second senator. The application uses a webhook endpoint to accept inbound calls and trigger actions inside the application. The application also includes a `setState` function that sets the user's state from confirmation or user-provided Zip.
Jan 10, 2017
3,115 words in the original blog post.
This is a summary of the provided text in one paragraph:
A Django sample application models an IVR experience for stranded aliens trying to call an agent for instructions on how to get off Earth safely. The application uses Twilio's API to route calls, record voicemails, and send transcriptions to agents. Agents can screen calls, receive recordings of caller messages, and leave voicemails. The application provides a user-friendly interface for agents to interact with callers, including options for call screening, recording, and voicemail setup. The code is written in Python and uses Django as the web framework, Twilio's API for voice and SMS services, and various libraries for model management and data storage.
Jan 10, 2017
3,559 words in the original blog post.
SMS and MMS Notifications with PHP` is a tutorial that guides developers on how to set up an automated server notification system using PHP and Twilio's REST API. The system sends SMS notifications to a list of administrators when a server error occurs, providing a convenient way for them to stay informed about issues affecting the application. The tutorial covers key aspects such as setting up the Twilio client, handling exceptions, creating custom messages, and sending text messages using the Twilio REST API. By following this guide, developers can implement a robust notification system that enhances their application's reliability and responsiveness.
Jan 10, 2017
1,533 words in the original blog post.
The text discusses the implementation of SMS and MMS marketing notifications in a Ruby and Sinatra application using Twilio. The system allows users to opt-in for receiving updates via SMS/MMS, manage their subscription status, and send messages to subscribers. The code uses DataMapper, Sinatra, and Twilio-Ruby to interact with the database and send messages. The implementation provides an administrative interface for administrators to craft messages and manage subscriptions.
Jan 10, 2017
1,726 words in the original blog post.
The Java and Spring sample application demonstrates how to push SMS alerts on server exceptions using the Twilio REST API. The application handles all application exceptions globally, sending a custom message to a list of administrators via SMS when something goes unexpectedly wrong. The list of administrators is loaded from a JSON file using the Gson library. The application uses the Twilio REST client to send messages and includes features such as error logging and exception handling.
Jan 10, 2017
1,003 words in the original blog post.
This PHP-Laravel sample application is a Rapid Response Kit built by Twilio for organizations that need to act quickly in disastrous situations. It allows aid workers to communicate immediately with volunteers, spin up conference lines, and broadcast spoken messages to phone numbers. The app uses Twilio's REST API and PHP library to generate TwiML responses, which are then sent back to Twilio's servers. The application includes features such as moderating conferences, recording and playing back messages, and broadcasting messages to phone numbers. It also includes a webform for organizing volunteers and selecting roles. The app uses Laravel's routing system and Twilio's PHP library to handle incoming calls and requests.
Jan 10, 2017
2,479 words in the original blog post.
The guide explains how to combine Twilio Add-ons with Programmable Voice to use data from Twilio's partners in a Spring MVC web application. An add-on is a pre-integrated third-party service that enhances responses received from Twilio by including additional data from Twilio's partners. The IBM Watson Speech to Text Add-on can convert Twilio audio recordings into text using machine intelligence, and its data can be accessed through the "AddOns" field in HTTP requests made to an application. To use an add-on, it must be enabled in the Twilio Console, where users can select the add-on they want to install and set the callback URL and request method. The guide provides a sample code example that demonstrates how to access add-on data within a Spring MVC application, using the IBM Watson Speech to Text Add-on to generate transcription for recorded calls.
Jan 10, 2017
895 words in the original blog post.
**
Spam calls and robocalls are a significant issue for high-volume customer service centers, impacting their bottom line. The Twilio Marketplace offers third-party technologies to integrate with the Twilio API, such as Marchex Clean Call, Nomorobo Spam Score, and Whitepages Bad Reputation. These Add-ons can be integrated into the Twilio Console and used in C# code to block spam callers, robocallers, and scammers. The code checks the spam score of the number and handles the call differently depending on whether the Add-on considers the caller to be a spammer or not. The `IsBlockedByNomorobo`, `IsBlockedByWhitepages`, and `IsBlockedByMarchex` methods handle the data from each Add-on, returning a `<Reject>` TwiML tag to send spammers packing or a `<Say>` TwiML tag to welcome legit callers. The code is flexible and can be modified to handle missing data in the JSON response. To test the blocked call, unit tests can be written with dummied up JSON to ensure the call goes through as expected.
Jan 10, 2017
1,280 words in the original blog post.
A high-level summary of the provided text is as follows: The article guides through implementing SMS and MMS marketing notifications using Python and Flask. It covers the building blocks required for this implementation, including TwiML and the Messages Resource. The article then dives into creating a Subscriber model to manage subscribers and their notification preferences, handling incoming messages, replying to received messages, managing subscriptions, sending marketing notifications, and finally, sending SMS or MMS notifications using the Twilio API. The guide concludes by highlighting additional features that can be integrated into the application to further enhance its functionality.
Jan 10, 2017
1,603 words in the original blog post.
This ASP.NET MVC sample application is a part of the Rapid Response Kit, built by Twilio, used by organizations to act quickly in disastrous situations. The app allows aid workers to communicate immediately with volunteers using a conference line or broadcast a spoken message to a list of phone numbers. The application uses Twilio's C# library to generate TwiML that tells Twilio how to handle incoming voice calls. The code includes routes for creating and managing conferences, recording new messages, and broadcasting recorded messages. The app uses Twilio's REST API to initiate phone calls and play recordings.
Jan 10, 2017
2,360 words in the original blog post.
This Sinatra application is an Employee Directory that can be used from any SMS client to find an employee's contact information. The application creates an Employee model, receives incoming SMS messages, searches for employees by name or ID, and responds with an outgoing MMS containing the employee's contact information. If no employee or multiple employees match a search query, the application returns a "Not found" message or a list of matching employees' names along with an ID number, respectively. The application uses Twilio to handle incoming SMS messages and send responses.
Jan 10, 2017
888 words in the original blog post.
This tutorial demonstrates how to implement instant lead alerts for a real estate application using C# and ASP.NET MVC with Twilio Programmable SMS. The system allows users to request more information about a house on the market, and upon submission of their form data, sends a text message to a designated real estate agent's phone number with the user's name, phone number, and inquiry details. The agent can then immediately follow up with the lead. The application utilizes Twilio's REST API client to send messages and integrates with ASP.NET MVC for routing and handling HTTP requests.
Jan 10, 2017
1,115 words in the original blog post.
A successful on-demand laundry service like Laundr.io can benefit from an ETA notification system that alerts customers when their order is picked up or arriving. The system uses Python and Flask to trigger notifications, Twilio's REST client to send SMS messages, and a status callback to update the notification status of orders. The code demonstrates how to implement this system, including setting up the Twilio account, sending SMS notifications, and handling the status callback. This tutorial provides a simple way for developers to add an ETA notification service to their own applications.
Jan 10, 2017
1,442 words in the original blog post.
This Sinatra-based survey application uses Twilio for automated surveys. The application handles both voice calls and SMS responses. It stores answers in a database using DataMapper and generates TwiML instructions for each question based on the user's input. The application also displays survey results, including panel views for every question in the survey, listing responses from different calls.
Jan 10, 2017
2,857 words in the original blog post.
The key points of the text can be summarized in a neutral and interesting paragraph as follows:
Implementing SMS and MMS marketing notifications involves creating a subscriber model to track users who opt-in to receive updates, handling incoming messages from Twilio webhook requests, and sending messages to all subscribers via the Twilio API. The application uses Node.js and Express to handle form submissions, authenticate with Twilio, and send messages to subscribers. A static function on the Subscriber model sends messages to all active subscribers based on parameters sent in from the controller. The application also includes a route for administrators to craft campaign messages, a function to process incoming message commands, and logic to manage user subscriptions. With this implementation, an administrator can use a web form to send MMS notifications to subscribers, while users can opt-in or opt-out of receiving updates via SMS or MMS.
Jan 10, 2017
5,099 words in the original blog post.
This tutorial provides a comprehensive guide on implementing an employee directory using Node.js and Express with Twilio as the SMS service provider. The application allows users to search for employees by name or ID, and returns valuable information over SMS. The implementation includes caching the list of possible matches to improve performance, parsing user input to determine what to do next, and handling multiple or no results. The application also uses Twilio's Node.js Helper Library to simplify the process of generating and sending SMS messages. Overall, this tutorial provides a practical example of building a communication-focused application using Express, Node.js, and Twilio.
Jan 10, 2017
1,559 words in the original blog post.
This tutorial demonstrates how to implement an employee directory using Flask and Twilio. The application allows users to query for employee information by sending an SMS with their name to a designated Twilio number. The system handles three possible scenarios: single partial match, multiple partial matches, and no match. When a user receives a response from the system, they can reply with a number that references one of the suggestions, allowing them to narrow down their search results. The application uses Twilio Cookies and Flask Sessions to store search suggestions, enabling users to continue searching without entering the query again. By following this tutorial, developers can create an efficient and user-friendly employee directory solution using Python and Twilio.
Jan 10, 2017
1,239 words in the original blog post.
This guide provides instructions for using Twilio's Programmable Voice API to make outbound phone calls from Delphi applications, requiring a voice-capable Twilio phone number and account credentials. It demonstrates how to use the TTwilioClient class to encapsulate HTTP calls to the Twilio REST API, with code snippets available on GitHub. The process involves setting up environment variables for Twilio credentials, specifying the "From" and "To" phone numbers, and implementing TwiML (Twilio Markup Language) to define actions like making calls or sending SMS messages. TwiML, an XML-based language, allows users to specify actions such as saying a greeting or playing a message, with dynamic server-side generation possible for more complex interactions. The guide also references additional resources and related posts for further exploration of Twilio's capabilities.
Jan 10, 2017
851 words in the original blog post.
In a detailed tutorial, Mario Celi explains how to build a call tracking application using PHP and Laravel, integrating Twilio's API to monitor the effectiveness of various marketing channels. The application involves purchasing phone numbers from Twilio for different campaigns and forwards incoming calls to sales representatives while displaying data on these calls through charts. It outlines the process of searching and purchasing phone numbers via Twilio's PHP helper library, associating them with specific lead sources, and handling incoming calls using webhooks to forward calls and create leads. The tutorial covers the backend structure, including the LeadSource and Lead models, to track and associate calls with lead sources, and uses Eloquent queries to generate statistics on call activity. The frontend aspect employs JavaScript and Chart.js to visualize statistics in pie charts, providing insights into call distribution by lead source and city. The tutorial also offers additional resources and related tutorials for PHP developers interested in enhancing their applications with Twilio functionalities.
Jan 10, 2017
2,611 words in the original blog post.
This application uses Node.js and the Express framework to send automatic server notifications through SMS and MMS when an exception occurs. To do this, it sets up a Twilio REST client with account SID, auth token, and sending number from environmental variables. It then creates a JSON formatted list of administrators who should be notified in case of emergency and implements error handling and message delivery as a piece of Express.js middleware. The middleware reads the administrator's phone numbers, formats an error message, sends the SMS using Twilio's REST API, and calls the next middleware in the chain with the error object.
Jan 09, 2017
1,166 words in the original blog post.
Multi-Factor Authentication (MFA) has been around for decades, but the devices used in this process have evolved significantly. With smartphones, laptops, tablets, and even wearable computers becoming commonplace, it's essential to ensure that MFA systems can accommodate multiple devices without compromising security. Authy, a two-factor authentication platform, has tackled this issue by allowing users to add more devices while minimizing vulnerability. The platform uses an intelligent multi-key system and offers features like 'inherited trust,' which allows a trusted device to authorize another device, and de-authorization, which enables quick removal of devices. These measures help protect against persistence attacks and enhance the overall security of MFA systems.
Jan 07, 2017
1,629 words in the original blog post.
Building callback capability isn't hard, and developers can use tools like Stamplay, Twilio, and Unbounce to achieve this. The process starts by configuring an Unbounce landing page with a Phone Number field, then setting up a Twilio account and connecting it to the Unbounce form. A Blueprint template provides a pre-built solution for integrating these services, guiding users through a walkthrough wizard to connect their accounts and configure the callback flow. Behind the scenes, the blueprint triggers an API flow when the Unbounce landing page is accessed, which collects information from the form and passes it to Twilio, generating a TwiML response that instructs Twilio to make a call using a specified phone number and URL. The NodeJS Code Block responds with a customized message and connects the Unbounce lead with the customer team. With this setup, developers can spare their customers from frustrating wait times like those experienced by the author during a delayed flight.
Jan 06, 2017
797 words in the original blog post.
This guide provides a C program that uses libcurl to send SMS and MMS messages using the Twilio REST API, allowing developers to easily integrate this functionality into their applications. The guide assumes a POSIX-compliant environment and requires the installation of libcurl and the use of a Twilio phone number with SMS capabilities. The example Makefile is provided for building the program on various platforms, including Mac OSX, Raspbian, and Windows 7. The `twilio_send_message` function is explained in detail, demonstrating how to prepare account credentials, HTTP parameters, and libcurl settings to execute a POST request to the Twilio API. The guide also includes an example of running the program from the command line, passing in account credentials, from and to numbers, and a message body.
Jan 06, 2017
1,016 words in the original blog post.
Twilio is a cloud communication platform that enables developers to build and deploy real-time communication applications. In this article, Dominik Kundel demonstrates how to build a basic call center in just 10 minutes using TwiML Bins, a feature of the Twilio platform. The author creates two TwiML Bins: "Join Queue" to add callers to the queue and "Work Off Queue" to connect them with an available agent. Using the Twilio Node.js helper library, the author builds a script that initiates a call from one phone number to another using the second TwiML Bin. The script is executed by passing in the recipient's phone number as a command-line argument, allowing users to build and test their own call centers with minimal setup.
Jan 04, 2017
776 words in the original blog post.
You can redact or delete SMS messages as they arrive with Node.js using Twilio's webhooks. To do this, you'll need a Twilio account, a Twilio phone number, Node.js, and ngrok to expose your development server to Twilio's webhooks. You'll also need to install the Express framework, body-parser, and the Twilio Node.js helper library. Once you've set up your application, you can create a webhook endpoint that receives POST requests from Twilio whenever your Twilio number receives a message. In this endpoint, you can log the incoming message or redact its text by using the Twilio REST API to update the message resource with an empty body. If you want to delete the message completely, you'll need to check its status and wait until it's marked as "received" before deleting it. With these steps, you can keep your messages under the sole control of your system and maintain message privacy.
Jan 04, 2017
1,049 words in the original blog post.