How does whatsapp work technically
Understanding WhatsApp's Architecture & System Design
Which app has over 2.5 billion active users, over 5 billion downloads, and is the most popular app in over 100 countries?
Hint: check the article title.
Yes, that’s right. WhatsApp is the most popular messaging service in the world. According to Mark Zuckerberg, over 100 billion messages are sent over WhatsApp every day.
With such almost-astronomical traffic, one can’t help but wonder how WhatsApp works - its system design, server architecture, technology . How does it handle so many concurrent users and messages? What kind of frameworks and programming languages enable that kind of scale? How do they keep all that data secure? So many questions!
In this article, we are going to take a deep dive into WhatsApp’s architecture and system design. We’ll answer all the above-mentioned questions and more.
If you’ve ever wondered about the top dog in the chat app world, keep reading.
Disclaimer: We scoured the internet to collect every resource on WhatsApp architecture design and have compiled and summarized it here. To the best of our knowledge, this information is accurate. However, as companies do update their tech stack frequently, this information is subject to change.
WhatsApp Front-End Tech Stack
Let’s start with the frontend and work our way to the hardware on the backend.
The first part of the WhatsApp system design that a user interacts with is the mobile or web app. WhatsApp supports nearly all platforms. It has an iOS app, Android app, desktop app, web app, and Windows Phone app. Up until 2017, you could even use WhatsApp on a BlackBerry.
With so many supported platforms, you may have guessed that WhatsApp would be a hybrid app. But, in fact, it’s not. They actually built a native app for each platform. Here's a list of all the supported platforms with the front-end language(s) that were used to build each one:
- Android: Java
- iOS: Swift
- Windows Phone: C#
- Web app: JavaScript/HTML/CSS/
- Mac Desktop app: Swift/Objective-C
- PC Desktop app: C/C#/Java
How WhatsApp Stores Chat Locally
In addition to the programming language itself, another important technology that WhatsApp uses on the frontend is an SQLite database.
SQLite is a stand-alone, self-contained, relational database that is meant to be embedded into applications—which means it lives on your device. WhatsApp uses it to store conversations. Since it would be a waste of resources to download all the messages from the cloud every time you open the app, WhatsApp chooses to store the messages locally. In fact, WhatsApp only stores messages until they are received at which point they get removed.
Which Messaging Protocols Does WhatsApp Use?
WhatsApp uses a highly modified version of XMPP on an Ejabberd server (more on that later) to communicate with the clients.
The XMPP on the client opens an SSL socket to the WhatsApp servers. All the sent messages are queued on the servers until the client opens or reconnects to this socket to retrieve the messages. Once a message is successfully retrieved by the client, a success status is sent back to the WhatsApp server. The server then forwards this status to the original sender; letting them know that the message was received by adding the “checkmark” icon next to the successfully sent message.
Keep in mind that, while XMPP is one of the most popular messaging protocols for chat apps, it is definitely not the only option for choosing a messaging protocol.
WhatsApp uses end-to-end encryption. Ideally, this means that only the original sender and the true recipient of the message can read the message in plain text.
When you send a message, it gets encrypted using a specific encryption protocol (more on that next). WhatsApp then stores this encrypted message on their servers until it’s delivered to the recipient. Upon delivery, the recipient's device decrypts the message back into a readable, plaintext message using a unique cryptographic key. Across this entire process, WhatsApp never knows the content of your message.
WhatsApp’s encryption technology is called Signal Encryption Protocol, which was developed by Open System Whispers to be a modern, open-source, strong encryption protocol for asynchronous messaging systems.
While end-to-end encryption may make you feel safe in theory. In practice, end-to-end encryption isn’t as privacy-protecting as one would hope.
WhatsApp Back-End Tech Stack
Let’s move on to the backend.
To the best of our knowledge, the current WhatsApp back-end system design looks like this:
- Erlang is the main programming language
- FreeBSD is the operating system
- Ejabberd is the XMPP application server
- BEAM is the Erlang-based virtual machine
- Mnesia is their Erlang-based database
- YAWS is their multimedia web server
Let’s explore some of the more interesting aspects of WhatsApp’s back-end architecture:
WhatsApp's choice of programming language is in large part what allows it to work on such a colossal scale.
Erlang is a functional programming language that is oriented towards building concurrent, scalable, and reliable systems.
It uses a process-based model called the “actor model” in which small, isolated processes communicate with each other through messages. These processes can create new processes, send messages and modify their state in response to receiving messages.
Its process-based property gives Erlang its extremely high concurrency, scalability, and reliability.
These processes can also communicate with processes outside of the core on which it runs. This makes it easy to scale the system horizontally (by adding more machines) or vertically (by adding more cores). Lastly, since the processes can communicate with each other and, more importantly, restart each other, it’s easy to build self-healing systems. If a bug crashes a process, another process can restart it.
FreeBSD
An interesting technical choice by WhatsApp's founders was picking FreeBSD as an operating system instead of a more widely used system (like Linux).
Brian Acton, one of the cofounders of WhatsApp, said this in an interview with Wired about the decision:
“Linux is a beast of complexity.
FreeBSD has the advantage of being a single distribution with an extraordinarily good ports collection.”
Also, when it comes to raw performance, especially in regards to system load per packet, no other operating system can beat FreeBSD.
However, when it comes down to it, the real reason that they decided to use FreeBSD is probably because both co-founders had a long history of working with it at Yahoo!.
Ejabberd
Ejabberd is an open-source XMPP server that is written in Erlang. WhatsApp uses a modified version of XMPP as its protocol for handling message delivery. Even the Ejabberd server that WhatsApp uses is heavily customized to optimize for server performance.
What’s the purpose of Ejabberd?
Well, it handles the message routing, deliverability, and general instant messaging aspects of the app. Features of Ejabberd include:
- One-on-one messaging
- Group chat
- Storing and forwarding offline messages
- Contact list and presence
Mnesia
To store data and temporary messages, WhatsApp uses an Erlang-based, distributed DBMS (Database Management System) called Mnesia.
This DBMS provides benefits that many traditional databases don’t such as:
- Real-time key/value lookup
- High fault tolerance
- Dynamic reconfiguration
- Complex objects
Mnesia is also the only DBMS that’s written in Erlang. This in itself is a benefit because there are no data structure differences between Erlang in the application and Erlang in the DBMS. Coding is, therefore, quicker and more explicit.
BEAM
BEAM, short for “Bogdan’s Erlang Abstract Machine”, is a virtual machine that compiles and executes Erlang source code. The BEAM is designed specifically for highly concurrent applications - perfect for WhatsApp’s use case. BEAM’s secret sauce is light-weight processes that don’t share memory and are managed by schedulers. These schedulers can manage millions of processes across multiple cores. This makes BEAM highly scalable and resistant to failures, such as those caused by high traffic loads, system updates, and network outages.
BEAM is so crucial to the WhatsApp system design that the WhatsApp team has published many patches and fixes to the core source code.
YAWS
YAWS (Yet Another Web Server) is an Erlang-based web server that's ideal for dynamic content. WhatsApp uses YAWS for storing multimedia data. YAWS itself uses HTML5 WebSockets that simplify two-way communication by establishing a reliable and fast connection between the server and the app. Through the use of this technology, WhatsApp is able to send and receive multimedia data across billions of devices—in near real time.
WhatsApp Hardware Components
In 2017, four years after being acquired by Facebook, WhatsApp was taken off of IBM SoftLayer’s cloud and brought into Facebook’s proprietary data centers.
What we do know is that in 2014 WhatsApp required around 550 servers and over 11,000 cores that ran Erlang. We also know that WhatsApp’s user base was "only" around half a billion in 2014 compared to the more than 2 billion users it reached in 2020.
So, with that data in mind, we'll let you imagine how many servers and cores WhatsApp now requires. We imagine it's a lot.
WhatsApp Architecture Diagram
The easiest way to get a full understanding of WhatsApp’s architecture design is, of course, through a WhatsApp architecture diagram.
Starting from the left side we have multiple different clients (mobile and web apps), each of which hosts a local SQLite database for storing conversations.
The clients use HTTP WebSockets to send and retrieve multimedia data like images and videos from the YAWS web server. But, as you can see, XMPP is used to actually send those files and other messages to other users.
When an XMPP message is sent, it goes through the series of steps depicted above. First, it gets sent to WhatsApp’s custom Ejabberd server which runs on BEAM and FreeBSD. The Ejabberd server saves the message in a Mnesia database table where it gets put into a queue. When the receiving user opens the app, thereby reconnecting to the socket, the message in the queue gets routed through the Ejabberd server and delivered to the recipient.
Once successful delivery can be confirmed, the message gets deleted from the Mnesia database.
Conclusion
While we don’t know the exact specifications of WhatsApp’s technical architecture and system design, we can get a good idea based on the technologies that WhatsApp employs. We hope this article, exploring the WhatsApp architecture design, has answered your burning questions. Now that you've gained an understanding of how the WhatsApp server works, learned what the WhatsApp tech stack looks like, and even scanned a WhatsApp architecture diagram...maybe you're feeling empowered to take on a chat app project of your own.
If you’re ready to give WhatsApp a run for their money, sign up to our developer dashboard and start building your chat app for free.
But keep in mind that many of the technologies in the WhatsApp technology stack were specifically chosen for their ability to scale and handle extremely high concurrency.
If you’re trying to build a dating app or telemedicine, (or anything that doesn’t need almost the entire world to be online at the same time), you may not need the amount of scale that WhatsApp does.
In other words, the WhatsApp tech stack, while perfect for WhatsApp, may not be the best solution for you. To learn about the ideal architecture and tech stack for a chat app, head to this article.
If you still have questions about what IS right for you, feel free to talk to our experts and before you start building your own chat app.
Just hungry for more? Here are some more great resources to dive into:
- The Myth of End-to-End Encryption in Messaging Apps
- Understanding the Architecture & System Design of a Chat Application
- 11 Silly Mistake Developers Make When Building a Chat Application
About the Author
Cosette Cressler is a passionate content marketer specializing in SaaS, technology, careers, productivity, entrepreneurship and self-development. She helps grow businesses of all sizes by creating consistent, digestible content that captures attention and drives action.
How to Build a Chat App like WhatsApp in Android, iOS & Web?
WhatsApp is the most sought after messaging application that has revolutionized the messaging app market. Several attempts have been made in vain to clone WhatsApp as a chat app, but none of them yielded the result. Despite introducing similar functionalities, no chat app has ever been able to topple WhatsApp’s supremacy as a chat app.
In order to build chat app like whatsapp, one should have a detailed understanding of its functioning mechanism and technicalities.
Table of Contents
How Whatsapp Messaging App is Working Technically?
WhatsApp uses Ejabberd (XMPP) server which facilitates instant message transfer between two or many users on a real-time basis. High reliability and sustainability even under peak traffic the reason why WhatsApp developers chose Ejabberd above anything else.
ERLANG is the programming language used to code WhatsApp.
Code restructuring and some important changes were made to the Ejabberd server to achieve optimal server performance.
Further, Erlang is agile to adapting to instant updates and hot fixes. This is what helps WhatsApp to quickly push the changes to live implementation without requiring restarts.
1. Insights on data transfer in WhatsApp
WhatsApp manages over 50 billion messages a day. The key to smooth data processing lies with the message queue length. The length of the message queue of all the processes associated with a node is monitored.
In case of multimedia messages, contents (audio, video, or image) are uploaded into a HTTP server and are linked with the content and then sent to the receiving node (receiver) in the form of a thumbnail. Based on the user’s preference the content can either be viewed or discarded.
2. Protocol used by WhatsApp
The primary protocol in use is XMPP (Extensible Messaging and Presence Protocol).
DSL ensures network security and also helps in preventing private data transfer.
As and when message is sent, it is queued on the server. The message waits in the queue until the recipient reconnects to receive the message. As and when a message is delivered the sender gets notified by a double check mark near the message. After the delivery the messages are instantly deleted from the server memory.
This instant deletion from server memory helps WhatsApp keep its resources to a bare minimum.
Additionally, Whatsapp uses HTML5 WebSockets which communication technology which facilitates two-way communication.
3. Registration process of WhatsApp
Users can register for WhatsApp by entering their mobile number. On entering the number, the user will be sent a OTP which once verified by the device will initiate the user to the chat screen.
4. Database management
Mnesia DB handles the heavy-duty task of database management.
Mnesia is a multiuser distributed DBMS which also happens to be the default DB of ERLANG. Mnesia helps achieve quicker request responses, thereby improving the overall efficiency.
FreeBSD is the OS upon which WhatsApp is built. Improvising on the ERLANG based applications and optimizing FreeBSD, WhatsApp is able to achieve better performance. For storing multimedia files, the app uses an exclusive web server YAWS.
Build a Whatsapp like Messaging App with Contus Fly
Having discussed the technicalities of WhatsApp it is time to shift gears over analyzing the possibilities of creating a whatsApp alternative. There are plenty of secure messaging app in the market that appear to be perfect WhatsApp clones. The reality is many of the attempts of building WhatsApp like apps are failing because they do not follow the technical aspects.
Well, if we take such apps as an example, it might be quite difficult to understand as they are completely built products.
Instead a ready made solution that can help in creating a WhatsApp clone app would be a better learning material.
Contus Fly is a framework that catalyses the build a chat platform. Contus Fly can be used to develop WhatsApp clone app for Android app, iOS and Website platforms as it has the SDK ready for these widely preferred mobile operating systems. Since native coding has been used by Contus Fly to achieve better speed, it can be handy in developing a WhatsApp like native app.
Framework & Architecture of Contus Fly
Ejabberd
Ejabberd, the open source Jabber server has been customized by Contus Fly to improve operational efficiency. The XMPP protocol has also been customized to speedup signing in and re-signing in sessions. To protect the app from DDOS attacks and to prevent account spoofing, this mobile chat app solution has been encrypted with HMAC.
Mnesia and MySQL
For data storing, Contus Fly makes use of both Mnesia and MySQL.
While Mnesia is used to maintain user login sessions, MySQL contributes in maintaining the user details, right from account credentials to other personal data.
Cassandra database
Chat logs are a key for instant messaging applications. In order to save chat history between several nodes, Contus Fly has deployed . This database offers a good read write speed thus helping users to retrieve chat logs as and when they need.
Amazon S3 bucket
Multimedia messages including audio, image, video are saved in Amazon S3 bucket. Registration for the app usage can be done in multiple ways including mobile number, email, user name password and social login.
WebRTC
WebRTC is a source code that is used to build real-time communication (RTC) in browsers and mobile app. Contus Fly has inbuilt WebRTC that allows its users to have VOIP (voice over the internet protocol) voice/video calls in their messaging app
Security
Contus Fly offers a 3 layered security flow – end-to-end encryption, HMAC authenticated screening, and online/offline verification protocol; that ensures the data transmitted within the chat app is secure.
As and when a user triggers a message, the chat SDK sends a request to the Ejabbered server. In return the server checks for the availability of the recipient and if available, the delivery request is sent to the recipients SDK and then delivered. If the recipient is offline, the data is stored in the Ejabbered as message will be queued in the server.
CONTUS Fly Features
- Group Chat
- Offline Messages
- Push Notifications
- Presence
- Social Integrations
- Locations
- Sync and Store
- Voice & Video Calling
- Video Conferencing
- Multimedia Sharing
- Easy Screen Sharing
- Fully Searchable
- End to End Security
- Support
Uses Cases of CONTUS Fly
1. Build Your Own Chat App:
Contus Fly is a instant messaging solution that can be customised according to the needs of the user. The customizations are highly flexible and can be made both initially or even after the app is launched.
2. Chat API:
Chat API provides users the access to infrastructure of server. This enables any website or app to be integrated with a messaging solution that performs without any hassles and is highly scalable.
3. Messaging SDK:
SDK is an instant messaging framework that enables the app built with it to work on specific platforms. Contus Fly’s SDK has been built in an enterprise grade making it compatible on android, iOS and windows.
4. In-app Messaging:
A source to connect with your customers goes a long way. In-app messaging and push notifications initiates a direct conversation with app visitors and assists in providing accurate product explanation and suggestions.
If You Already Have An Idea About Build Chat App, Schedule A Free Demo And We’ll Get You On The Road To Chat App Success!
Whatsapp, what's inside? / Habr
In continuation of the publication of our company's research on the internal mechanisms of the world's largest instant messengers.
Today we will look at WhatsApp in its current state. In fact, the insides have not changed much over the past three years, the changes there are more cosmetic.
In this article, we will see in detail how you can study the protocol of the messenger, answer the question "can WhatsApp read our correspondence?" and I will attach all the necessary PHP code.
General information
WhatsApp uses a modified version of the XMPP protocol as a message format. All messages are compressed by replacing frequently used words with 1 or 2 byte tokens (for example, instead of “message”, we write byte 0x5f), thus getting what is called FunXMPP.
Some packages can be further compressed by zlib. The received packet is encrypted with AES GCM 256-bit and sent to the server.
The client performs a noise protocol handshake to obtain encryption keys. It's well described here. For some reason, all developers of open source implementations refused to implement it in code and hung up the “end of support” die, we will fix this.
The first time you connect, a full handshake is performed. After a successful connection to the server, each time a new key is issued for the next session, with the help of which a connection is subsequently made without exchanging keys.
WhatsApp supports end-to-end encryption using libaxolotl (Signal Protocol), two versions are implemented in the code - first they just did encryption, and then they added alignment and called it v2. There is only one problem here - because. Since this is a centralized system, then the keys are transferred through the WhatsApp server, so technically there are no obstacles for the developers of the messenger to transfer fake encryption keys and fully read the correspondence. But this does not have retroactive effect - you will not be able to read the messages retroactively.
By the way, when you receive a message from an unauthorized contact, the messenger displays a “report spam” button, by clicking on it we will not only block the contact, but also send the text of the message through a secure channel (already in clear form!).
Without studying the entire application code, there is no way to guarantee that this functionality is not used in any other cases.
To check the authenticity of the encryption keys in the WhatsApp application, you can go to the contact card, select the "Encryption" item, after which the application will prompt you to scan the QR code on the recipient's device. Thus, by the way, you can make a custom application based on the WhatsApp protocol, which will constantly monitor the status of encryption keys and issue beautiful “NSA is watching you” or “You are safe” badges: given the variety of instant messengers, replace one of them with this the application will be even useful.
The algorithm of work can be assumed as follows: the device that displays the QR code encodes its public key into it, the device that reads the QR code checks the key with the one in its database. This is a secure way to verify the key, but only if there are no bookmarks in the application.
When sending media, the files are uploaded to WhatsApp servers, we have not done further research to see if they are encrypted there.
Most likely they are not encrypted, because the application developer trusts himself, and the link to the file is transmitted over a channel protected by end-to-end encryption.
Account registration
Registration takes place in three https requests to the v.whatsapp.net domain (they can be peeped in any known way, for example, burp or mitmproxy, the application uses certificate pinning, which is bypassed using the ssl kill switch).
v.whatsapp.net/v2/exists?cc=country code&in=phone&id=device id&lg=en&lc=zz
does nothing useful, before, most likely, it served to check if this number was already registered (most likely until the moment when someone began to sort through their base)
v.whatsapp.net/v2/code?method=sms&cc=country_code&in=phone&token=token&sim_mcc=mcc&sim_mnc=mnc&id=device_id&lg=en&lc=zz&end-to-end_encryption_settings
It actually asks for an activation sms code. A similar request can also be used to receive a call.
End-to-end encryption settings are optional and can be configured upon further connection. The token is obtained like this:
md5("0a1mLfGUIBVrMKF1RdvLI5lkRBvof6vn0fD2QRSM" . md5("21752") . "phone") The first line is the encrypted string landscape, whatever that means. Any version of the application (21752) can be substituted (the most curious can try to register with a version that has not yet been released), the hash of the version is sewn up in the application code itself, but something similar to an md5 hash is selected quite quickly.
v.whatsapp.net/v2/register?cc=country_code&in=phone&code=code_from_sms&id=device_id&lg=en&lc=zz
This request, respectively, confirms the registration with the code received by SMS or call.
Requests use User-Agent: WhatsApp/2.17.52 iPhone_OS/7.1.2 Device/iPhone_4 . The correct agent is most likely required for the correct verification of the token.
MITM
All this has been known for more than a day - there are several implementations of the WA16 protocol (Chat-API, Yowsup), the difference from the current WA20 is, in fact, only in the Noise Protocol. With this information, we can develop a local MITM to view decrypted application traffic. Because Initially, the XMPP application protocol - then everything that happens there will be quite clear immediately from the decrypted traffic, so there is no particular need to dive into the wilds of the disassembler.
To start MITM, we will pretend to be a real WhatsApp server, perform a full handshake, after which our application will listen for traffic, redirecting it to the original whatsapp server and back. To do this, we need to change the original application:
All operations are carried out in the following configuration: iPhone 4, iOS 7.1.2, IDA 7, WhatsApp 2.17.52.
Patch application
1.
We will perform a full handshake on each connection, this will greatly simplify our lives. In method -[NoiseHandshakeManager initWithLoginPayload:clientStaticKeyPair:serverStaticPublicKey:] if serverStaticPublicKey is present, ResumeHandshake is executed, and if is not present, FullHandshake is performed.
The serverStaticPublicKey is stored in the R0 register and if it is absent, the transition to FullHandshake is performed. And we will make this transition unconditional. To do this, replace the two bytes
with
Result
In the decompiler, we see that one of the condition branches has become unattainable and is not displayed.
we don't have the private keys of the original server. Without this change, it will be impossible to sniff the traffic. To do this, we will make changes to the method (bool)- [NoiseHandshakeManager validateNoiseCertificate:serverHandshakeStaticPublicKey:] .
We want the function to always return one. Now the result of the certificate check from register R6 is put into R0.
Let's make R0 write one
As a result, we get
The application is assembled with all the debugging information, so additionally renaming, describing structures and generally performing a patch reversing process is actually not required during creation. The images are shown immediately after the decompiler was launched, without additional processing.
iOS 7.1.2 does not verify the authenticity of application binaries, so all changes can be made directly in the application file. In later versions of iOS, you can make these same changes to the running app's memory.
Writing code...
Next, with the help of IDA and long painstaking efforts, we prepare the code that successfully executes NoiseHandshake on the WhatsApp servers. Then we implement a fake server - we do all the same encryption operations, but in reverse order (sounds simple, but if you don’t do it every day, it’s still a headache).
The finished code is here.
Download the MITM application from the link above to your computer. Install PHP 5.6 (another version is also suitable, this version was used in my configuration). You will also need two more libraries:
- first
- second
We intercept the connection
It remains only to force the application to connect to our server, instead of the real one. The application connects to one of the e%d.whatsapp.net servers (where %d is a number from 1 to 16, for example e5.whatsapp.net), each of which resolves to several IP addresses, each time different, in total over 300 servers. The easiest way would be to change the server's DNS response and direct it to our computer with MITM.
To do this, we put the phone and the computer on the same network (literally any wifi router will do), on the phone we set DNS to our computer on which we install bind9 with the following host:
$TTL 86400 @ IN SOA ns.whatsapp.net. admin.whatsapp.net. ( 2017100500 28800 7200 1209600 86400) @ IN NS @ @ IN A YOUR IP v IN A 184.173.136.86 v IN A 174.37.243.85 * IN CNAME @
Watch traffic
Next, edit mitm.php - you need to substitute your phone number in the username field and the contents of the cck.dat file (located in the application directory) in the password field.
Run php mitm.php. We launch the WhatsApp application and see the following picture:
The screenshot shows two packets from the server - a message about successful authorization and some settings. This is how absolutely all application traffic looks - everything is readable and, in most cases, it is not required to further analyze the application.
Algorithm for turning FunXMPP into readable text is available in all WhatsApp libraries. Inside is the simplest state machine, I will not describe it further here.
Terminals
The application is made with high quality, uses modern encryption protocols, but deep inside lies the XMPP left over from the originally used ejabberd.
Using protobuf, judging by the current development vector of the application, would be more logical, but the historical legacy is too expensive.
The service suffered greatly from mass mailings for a long time - the code of open projects contributed widely to this. At the moment, no mailings have been received for a long time - the developers have introduced a limit on the number of messages sent to unauthorized contacts. It is this addition (technically implemented entirely on the server side), in my opinion, that decisively put an end to the confrontation between the fans of mailing lists and employees of the anti-mailing department (if they have one).
Purely technically, there is nothing complicated in such an algorithm, developers of other messengers (hello, Viber, I receive spam at least once a month) should take note of this technique.
Thanks for reading, I hope reading about this was as fun and interesting as doing the research.
How WhatsApp Web works, or How to use WhatsApp on a computer
Despite the popularity of WhatsApp, this is a very non-universal messenger.
Unlike Telegram, Whatsapp on multiple devices cannot work simultaneously. Or rather, maybe, but with a number of significant reservations. The reason for this, as it turned out, was a problem in the message synchronization mechanism. That is, WhatsApp is not able to track progress from one device to another if they are both offline at that time. In short, game. Nevertheless, the messenger has a web version, but it works far from being as obvious as it might seem.
WhatsApp Web can be run in a browser on any computer
WhatsApp told how to understand that you have been blocked
If you are interested in what is WhatsApp web , then know that this is a special version of the messenger that runs on browser power and is designed exclusively for desktop devices. In other words, for computers. Because running it on a smartphone in normal mode will not work. You can read more about this in this article.
How to transfer WhatsApp to a computer
Since WhatsApp is able to work on several devices at once, it is only rather conditional that in order to connect to WhatsApp Web , you will need a smartphone.
Even though the developers claim that they have canceled the binding of the web version to the mobile one, technically it is still there. True, now the device is needed not to maintain the messenger on the computer, but for authorization. But what does it change?
- Go to web.whatsapp.com from your computer;
You can only connect to WhatsApp Web using your smartphone
- Open WhatsApp on your Android or iOS phone;
- Press "Menu" or "Settings" and open the QR code scanner;
You still won't be able to connect without a smartphone
- Point your phone at the screen and read the QR code;
- Confirm linking the device to your account and scan the QR code on the PC screen again if required.
You definitely believed in it! Collected 10 most popular myths about WhatsApp
If it used to be necessary for the smartphone to remain in line of sight from the computer running WhatsApp Web at all times, now this is in the past.
WhatsApp from the phone is no longer relayed to the computer, but is needed simply for pairing. It became more convenient. But the authorization procedure will have to be performed every time after exiting WhatsApp Web .
Since all messages in WhatsApp Web no longer pass through your smartphone, no traffic will be consumed, regardless of the amount of data transmitted or received through the desktop version of the messenger. So there's no difference like connect to WhatsApp Web : via LTE or Wi-Fi. But keep in mind that when using cellular networks, the load will fall on the mobile Internet, which for most users is not unlimited.
How to disable WhatsApp Web
If you don't want to use WhatsApp in the browser, you can download the version of WhatsApp for computer from this link. It installs like a normal application. But fundamentally, the experience of use will not change this.
