## Introduction

Guzzle is a popular PHP HTTP client that simplifies making HTTP requests. It has been around for over ten years and is utilized by the Laravel framework under the hood. Guzzle abstracts the complexities of creating HTTP requests and handling responses by wrapping them in intuitive PHP objects, which you can easily manipulate. It is super flexible and allows you to specify timeouts, auth and proxy details, SSL certificates, etc. Guzzle is used for various HTTP-related tasks, such as making API requests, scraping web pages, and interacting with web services.

## Features

Guzzle has all the features you'd expect from an HTTP client. Here are some of its key functionalities in detail:
HTTP Request Methods & Params
Guzzle supports all primary HTTP request methods, including GET, POST, PUT, DELETE, HEAD. You can easily specify the desired manner when creating requests.

*__Get query without parameters__*

        $client = new GuzzleHttp\Client();
        $request = $client->get('https://example.com');

*__Delete query__*

       $client = new GuzzleHttp\Client();
       $request = $client->delete('https://example.com');

Guzzle also makes it easy to add parameters to your requests. This is useful for passing data in the URL for GET requests or specifying the body for the JSON API you interact with.

__Get query with parameters__

     $client = new GuzzleHttp\Client();
     $response = $client->request('GET', 'https://example.com', [
       'query' => [
         'param1' => 'value1',
         'param2' => 'value2',
        ],
    ]);  

 __Post query with parameter__

     $client = new GuzzleHttp\Client();
     // Define the parameters as an associative array 
       $parameters = [
         'param1' => 'value1',
         'param2' => 'value2'
      ];
      // Convert the parameters to a JSON string if there are two or more parameters, 
      and skip this step if you pass only one parameter
     $json_ parameters = json_encode($parameters); 
     // Send the POST request
     $response = $client->request (POST, 'https://example.com', [
        'body' => $json_ parameters,
        'headers' => [
    'Content-Type' => 'application/json',
        ],
     ]); 
     // *__Get the response body if needed
     echo__* $response->getBody()->getContents();

### Custom Request Headers

You can set custom HTTP headers for your requests, essential for authentication, user agent identification, and specifying content types.

__Guzzle HTTP Client Authentication Example__

You can use Guzzle to send authenticated requests using various authentication methods such as Basic Authentication, Bearer Token, or other custom authentication mechanisms. Here's an example of basic authentication:

        $client = new GuzzleHttp\Client();
        $response = $client->request('GET', 'https://example.com', [
           'auth' => [
             'your_username',
             'Your_password'
             ],
           ]); 

__Guzzle HTTP Client Specifying Content Types Example__

You can specify the Content-Type and Accept headers to indicate the content type of the request and the expected response content type:

        $client = new GuzzleHttp\Client();
        $response = $client->request('POST', 'https://example.com', [
           'headers' => [
              'Content-Type' => 'application/json',
              'Accept' => 'application/json',
            ],
            'json' => [
               'key1' => 'value1',
               'key2' => 'value2',
              ],
            ]);

__Guzzle HTTP Client User Agent Identification Example__

You can set a custom User-Agent header to identify your client to the server:

      $client = new GuzzleHttp\Client();
      $response = $client->request('GET', 'https://example.com', [
         'headers' => [
            'User-Agent' => MyCustomUserAgent/1.0,
          ],
        ]);

__Request Options__

Guzzle allows you to configure various request options, such as timeouts, SSL verification settings, and more.

      // Timeout if a server does not respond in 5 seconds
      $client->request('GET', 'https://example.com', ['timeout' => 5]);

     // Automatically retry the request if a client or server error occurs - 
      it is possible by installing an additional Guzzle Retry
      Middleware package via 'composer require caseyamcl/guzzle_retry_middleware'. 
      Then, add an option in the request
        $response = $client->get('https://example.com', [
           'max_retry_attempts' => 5, // maximum number of retries. It is ten by default.
          ]);

    // *If you're using Laravel, 
    you can set retries with this code where 3 is the number of request attempts, 
    and 50 is the number of milliseconds Laravel should wait between shots
    Use Illuminate\Support\Facades\Http;
    $response = Http::retry(3, 50)->post('https://example.com'); 

    // Use a custom SSL certificate on disk
    $client->request('GET', '/', ['verify' => '/path/to/directory/certificate.pem']);

__Middleware__

Middleware is a powerful feature that enables you to modify requests and responses flexibly and reusable. You can attach middleware to the Guzzle client to perform tasks like logging, authentication, or response processing.

      // An example of how to log Guzzle HTTP requests and responses
      for debugging purposes using the Monolog package, which sends logs to a file,
      and the MessageFormatter instance that controls what gets logged
      $logger = new Logger('guzzle');
      $logger->pushHandler(new StreamHandler('guzzle.log'));
      $stack = \GuzzleHttp\HandlerStack::create();
      $stack->push( \GuzzleHttp\Middleware::log(
           $logger,
           new MessageFormatter('{method} {uri} - {code} - {res_body}')
         )
        );
        $client = new GuzzleHttp\Client(['handler' => $stack]);
        $response = $client->request('GET', 'https://example.com');

__Cookies__

Guzzle includes a CookieJar for managing cookies in your HTTP requests. This allows your application to handle session and authentication cookies seamlessly.

       // An example of managing cookies 
       across multiple requests using CookieJar
       $cookieJar = new CookieJar();
       $client = new GuzzleHttp\Client(['cookies' => $cookieJar]);
       $response = $client->request('GET', 'https://example.com');
       $cookies = $cookieJar->toArray(); // Access cookies from the response
       print_r($cookies);

__Async Requests__

Guzzle supports asynchronous requests, which means you can send multiple requests in parallel and process their responses as they become available. This can significantly improve the performance of your applications when dealing with numerous remote resources.

      // An example of how to send asynchronous requests for improved performance
      $client = new GuzzleHttp\Client(); 
      $api_urls = [
        'https://api.example.com/resource1',
        'https://api.example.com/resource2',
        'https://api.example.com/resource3',
    ];
    $promises = []; 
    foreach ($api_urls as $url) {
        $promises[$url] = $client->getAsync($url);
    }
    $responses = Promise\settle($promises)->wait(); // 
    A settled Promise represents the outcome of 
    an asynchronous operation which can be 
    successfully (fulfilled) or with an error (rejected)
    foreach ($responses as $url => $response) {
    if ($response['state'] === 'fulfilled') {
        $response_data = $response['value']->getBody()->getContents();
        echo "Response from $url: $response_data \n";
      } else {
         echo "Request to $url failed.\n";
       }
     }

__Streaming Responses__

Guzzle can stream large response bodies, which helps download large files or process streaming data without loading it all into memory.

    // You can stream large responses to save memory
    $client = new GuzzleHttp\Client(); 
    $api_url = 'https://api.example.com/large-resource';
    $response = $client->request('GET', $api_url, ['stream' => true]); 
    // Stream the response
    $stream = $response->getBody();
    while (!$stream->eof()) {
        echo $stream->read(1024); // Process data in chunks
    }

__Proxy support__

Proxy support in Guzzle allows you to route your HTTP request through an intermediary server (a proxy server) before reaching the target server. This can be useful when accessing resources behind a firewall or for privacy reasons. Guzzle makes configuring and using a proxy server for your requests is straightforward.

    // An example of how to set proxy servers. Define the proxy server details
	    $proxy_servers = [
        first_server => 'https://first-proxy-server:port',
        second_server => 'https://second-proxy-server:port',
    ];
    // Create a Guzzle HTTP Client with proxy configuration
    $client = new GuzzleHttp\Client([
        RequestOptions::PROXY => $proxy_servers,
    ]);
    // Sent a GET request through the proxy
    $response = $client->get('https://example.com');
    // Handle the response
   echo $response->getBody()->getContents();

__Sink__

Guzzle's "sink" feature allows you to efficiently download large files or responses directly to a file instead of loading the entire response into memory. This is particularly useful when dealing with large files, as it helps prevent memory exhaustion.

    // An example of downloading a file with the sink function
    $client = new GuzzleHttp\Client();
    // Define the file path where you want to save the downloaded file
    $file_path = 'path/to/directory/file.txt';
    // Send a GET request and save the response directly to the file
    $client->get('https://example.com/large-file.zip', [
        RequestOptions::SINK => $file_path,
    ]);

__Error Handling__

The library provides error-handling mechanisms and exceptions for various HTTP-related errors, making it easier to handle issues like connection failures, timeouts, and invalid responses gracefully.

    // Handle errors gracefully with Guzzle
    $client = new Client();
    $api_url = 'https://example.com/resource';
    try {
        $response = $client->request('GET', $api_url);
        // Handle the response here
    } catch (RequestException $e) {
        if ($e->hasResponse()) {
            // Handle HTTP errors
            $response = $e->getResponse();
            $status_code = $response->getStatusCode();
            echo "HTTP Error: $status_code \n";
        } else {
            // Handle other request errors
            echo 'Request Error: ' . $e->getMessage() . "\n";
        }
    }

__Request and Response Logging__

Guzzle supports request and response logging, which is valuable for debugging and monitoring the communication between your application and external services.

    // You can log both requests and responses for debugging. 
    Create a PSR-3 compatible logger (e.g., Monolog)
    $logger = new \Monolog\Logger('guzzle');
    $logger->pushHandler(new \Monolog\Handler\StreamHandler('guzzle.log'));
    $stack = HandlerStack::create();
    $stack->push(Middleware::log($logger, new MiddlewareFormatter()));
    $client = new GuzzleHttp\Client(['handler' => $stack]);
    $api_url = 'https://api.example.com/resource';
    try {
        $response = $client->request('GET', $api_url);
        // Handle the response here
    } catch (Exception $e) {
        echo 'Error: ' . $e->getMessage();
    }

__Note:__ In this example, you must implement a custom MiddlewareFormatter to format the log entries per your requirements.
Scenarios

Certainly, Guzzle HTTP Client is commonly used in various scenarios in PHP development. Let's dive into the most common use cases for Guzzle, along with detailed examples for each:

*__Web Scraping and Content Retrieval__*

Scraping web content or fetching HTML data from websites.

            $client = new GuzzleHttp\Client();
            $response = $client->get('https://example.com');
            $html_content = $response->getBody()->getContents()

*__Asynchronous Requests__*

Sending multiple HTTP requests in parallel for improved performance, e.g., concurrently fetching data from various APIs.

    $client = new GuzzleHttp\Client();
    $promises = [
        $client->getAsync('https://api.example.com/resource1'),
        $client->getAsync('https://api.example.com/resource2'), 
        // Add more async requests as needed
    ];
    // Wait for all promises to settle and get their results
    $responses = GuzzleHttp\Promise\unwrap($promises); 

*__Authentication and Token Retrieval__*

Authenticating with an OAuth 2.0 server to obtain an access token for API access.

    $client = new GuzzleHttp\Client();
    $response = $client->post('https://auth.example.com/token', [
        'form_params' => [
            'grant_type' => 'client_credentials',
            'client_id' => 'YOUR_CLIENT_ID',
            'client_secret' => 'YOUR_CLIENT_SECRET',
        ],
    ]);
    $token_data = json_decode($response->getBody()->getContents(), true);

Web Service Testing

Writing automated tests to check the functionality of a web service's API endpoints. You can use PHPUnit, a popular testing framework for PHP, to create and run these tests.

    $client = new GuzzleHttp\Client();
    // Send a GET request to https://example.com/your-endpoint
    $response = $client->get('https://example.com/users/123'); 

  // Check if the response status code is 200, and then parse the JSON response content and make assertions about its structure and values

    $this->assertEquals(200, $response->getStatusCode());
    $data = json_decode($response->getBody(), true);
    $this->assertArrayHasKey('expected_key', $data);
    $this->assertEquals('expected_value', $data['expected_key']);

### Step-by-step with Guzzle HTTP Client

Picture yourself in the process of constructing a web application that needs to interact with various online services. Let's say you intend to retrieve video information from a video database and present it within your application. You will surely need an HTTP client, and Guzzle is the perfect choice. Let's start with authentication and then proceed with different download modes (synchronous and streaming). Follow these steps:

__1. Install Guzzle:__ If you haven't already, install Guzzle by running:

    composer require guzzlehttp/guzzle

__2. Create a PHP file:__ Start by creating a PHP file where you'll write the code for downloading the video.

__3. Import necessary classes:__ In your PHP file, you'll need to import the Guzzle classes you'll be using and include the “autoload” file in the script part of the code to load all the classes and methods.

    <?php
    require 'vendor/autoload.php';
    Use GuzzleHttp\Client;
    Use GuzzleHttp\RequestOptions;

__4. Specify the URL of the video and authentication credentials:__ Set the URL of the video and any authentication credentials if required:

      $username = 'your_username';
      $password = 'your_password';
      $video_url = 'https://example.com/path/to/video.mp4';
      $file_path = 'path/to/directory/video.mp4';

__5. Initialize Guzzle Client:__ Create an instance of the Guzzle Client. This client will handle the HTTP requests:

 	    $client = new GuzzleHttp\Client([
	        'auth' => [$username, $password]
    ]);

__6. Option 1:__ Synchronous Download: This method downloads the entire file simultaneously. Use this approach if you're working with reasonably sized files:
   
    try {
        $client->get($video_url, [
            RequestOptions::SINK => $file_path,
        ]);
        echo 'Video downloaded successfully!';
    } catch (GuzzleHttp\Exception\RequestException $e) {
        echo 'Error: ' . $e->getMessage();
    }


__7. Option 2:__ Streamed Download: This method downloads the file in chunks, which can be helpful for large files. It consumes less memory compared to synchronous downloads:

    try {
        $response = $client->request('GET', $video_url, [
            'auth' => [$username, $password], // Add authentication
            'stream' => true // Enable streaming
        ]); 
        if ($response->getStatusCode() === 200) {
            $stream = $response->getBody();
            $file_handle = fopen('video.mp4', 'w');
            while (!$stream->eof()) {
                fwrite($file_handle, $stream->read(1024));
            }
            fclose($file_handle);
            echo 'Video downloaded successfully!';
        } else {
            echo 'Error: Status code - ' . $response->getStatusCode();
        }
    } catch (Exception $e) {
        echo 'Error: ' . $e->getMessage();
    } 
Replace 'https://example.com/path/to/video.mp4', 'your_username', and 'your_password' with your actual URL and authentication credentials.

__Note:__ *Ensure you have the proper rights or permissions to download and use the video, considering any legal or copyright considerations.*

## Conclusion

Guzzle is an incredible HTTP Client for PHP because of its simplicity, flexibility, extensive feature set, security, and strong community support. Whether you're building web applications, APIs, or scripts that interact with remote services, Guzzle can streamline your HTTP-related tasks and enhance the overall quality of your projects.


Guzzle is an essential PHP HTTP client for API requests, web scraping, and streamlining requests with custom headers, timeouts, and methods.

guzzle

Guzzle's Hidden Gems: Beyond the Basics of HTTP Request Handling

In the digital age, where information is at our fingertips, the efficiency of retrieving data from the web has become paramount. To address the challenges posed by data retrieval, web scraping, and crawling have emerged as essential techniques. Let's delve into web scraping and crawling, exploring their benefits, intricacies, and potential pitfalls.

## Navigating the Data Labyrinth

Web scraping involves extracting specific information from websites by parsing the HTML and other relevant data. It allows applications to access up-to-date information from the web without relying on manual input. 

### Benefits of Web Scraping

__Real-time Data__

Web scraping ensures that applications always have access to the latest data without the delay associated with manual updates.

__Automation__

By automating data collection, web scraping saves valuable time and resources that can be allocated to more critical tasks.

__Customization__

Scraping allows you to extract only the necessary data, eliminating the need to sift through irrelevant information.

__Competitive Insights__

Businesses can gain a competitive edge by monitoring competitors' websites for pricing, product details, and other market insights.

__Comprehensive Indexing__

Crawlers explore the entire web, indexing a wide range of content for users to search.

__Timely Updates__

Crawlers revisit websites periodically, ensuring the current indexed content.

__Structured Data__

Crawlers organize information in a structured manner, making it easier for search engines to retrieve relevant results.

### Challenges and Considerations

__Server Load and Rate Limiting__

Frequent crawling can strain website servers, potentially affecting their performance and leading to access restrictions. Websites protect themselves from being overwhelmed by requests by imposing rate limits or blocking IP addresses exhibiting suspicious behavior.

__Legal and Ethical Concerns__

Some websites prohibit scraping through their terms of use. It's crucial to respect the website's policies and not overload its servers with excessive requests.

__Duplicate Content__

Crawlers might inadvertently index the same content, leading to inaccurate search results.

__Data Integrity__

One challenge lies in ensuring the accuracy and integrity of the harvested data. Websites may update their structure or content, leading to data extraction errors. Additionally, ensuring that the scraped data is legally and ethically sourced is of utmost importance.

__Website Structure__

Websites often change their structure, which can break scraping scripts. Regular maintenance is necessary to adapt to such changes. Websites often use dynamic content-loading mechanisms like JavaScript, which can complicate the scraping process. Extracting data from such sources requires more advanced techniques to correctly interpret and capture the information.

### Conclusion

Scraping and crawling web pages are essential methods for optimizing web searches. They allow us to access up-to-date information from the Internet without manual input. However, it is crucial to be aware of the problems and considerations associated with these methods, such as website structure, legal and ethical issues, and data quality. By following best practices, web scraping and crawling can be used to efficiently and effectively extract data from the Internet.


Lexis Solutions explores the significance of web scraping and crawling in the digital age.

web scrapping-cover photo

Optimizing Web Data Retrieval: Web Scraping and Crawling

## The mountains were calling us

Lexis Solutions has just celebrated its sixth anniversary! We added one more year of hard work, constant laughter, and indulging in office-baked goods a bit more than we should've. So we treated ourselves to an unforgettable getaway in the city of Bansko, among Bulgaria's majestic mountains.

![lexis team 1](//images.ctfassets.net/5gydaotbo8jm/20Chpf9lKapSlEe177ZYHI/008090b42a1363505694c1e72693a472/368345149_685406642969575_5658398649408658154_n.jpeg)

## Journeying through nature's beauty

The breathtaking landscapes of the Bulgarian mountains set the stage for an unforgettable experience. We started our hike from Vihren Chalet and visited the magnificent lakes around. 

![planina](//images.ctfassets.net/5gydaotbo8jm/15i8mVhdkGwZBZlafFydKn/b7d0889add2f15689e6f21ecf4c57125/IMG_2202.jpg)

![pirin](//images.ctfassets.net/5gydaotbo8jm/13a4Tv4TjZ2Spg1te2t6Ag/a2c85e017c51e4af58d8fa444fc57dcb/IMG_2210.jpg)

## The spirit of sportsmanship

Sport has always been a crucial part of Lexis Solutions, so a friendly football match brought out the team's competitive spirit as we kicked up the dust and scored goals.

![football](//images.ctfassets.net/5gydaotbo8jm/7tdCSN5TdKjbhBi2qs4XII/9756b7d4080fc745cc12befe97fee984/IMG_20230819_100945__1_.jpg)

## The Airsoft challenge

An unexpected highlight was the airsoft battles, where another friendly competition took on a new dimension.

![air force](//images.ctfassets.net/5gydaotbo8jm/5Rj3dBvEqlFbtZLf6dKFZp/e6c06c804168046d127baacdf8e93c30/IMG_1983.jpg)

![air force 2](//images.ctfassets.net/5gydaotbo8jm/5vjXsktQpwTLAiw20OU72e/deb9b959b2e4a380596a8fbd780b6112/IMG_1981.jpg)

Between the planned activities, we had fun with various games and enjoyed the spa at the hotel where we were staying. And, of course, the Lexis team did not miss the opportunity to delight in the flavors of our typical cuisine. 

![lexis team 2](//images.ctfassets.net/5gydaotbo8jm/1OMtzXXB9RNH1V8vdTJlgs/6e8856832011b5b0c7874ec14a2d4706/IMG_2213.jpg)

In the heart of the Bulgarian mountains, Lexis Solutions found more than just an escape; we found a journey of growth, unity, and unforgettable moments. This getaway showcased that a team that plays together grows and succeeds together.


Celebrating 6 incredible years at Lexis Solutions with a mountain retreat in Bulgaria's breathtaking Bansko! 

Bansko 2023

In the heart of the mountains: A Lexis Solutions getaway

OnnoPlus-logo

Services

Onno Plus needed to scale its operations which meant wide-scale adoption of new systems and apps to support, extend, and automate their processes. Their existing order management system was inefficient and limited in functionality.

The support and sales teams worked in two completely separate systems. This made it hard to track, measure, and compare the impact the teams were having. The challenge was to unify all teams and processes under an extendible, fast, and scalable central app.

Challenge

In the following month, we introduced the sales module to the CRM. This allowed the sales team to easily share and access customer information and sales data, leading to better collaboration and coordination.

solution-onno

Solution

After all, teams were onboarded to the new CRM; we continued to tailor and perfect the workflows by adding integrations (AIrcall, Gmail, Maps), automations (e.g., auto-scanning for negative reviews), and new apps to improve their customers’ buying experience.

integration-onno

Custom integrations & automation

better-onno

A better way of working

Onno Plus, a Berlin-based marketing company, provides 8000+ German businesses with the tools to perfect their online presence. Their core product is assistance with removing fake and harmful reviews on leading platforms such as Google Maps, Trustpilot, Kununu, etc. 

onno-full-cover

OnnoPlus Admin Screenshot

preview-cover-onnoplus

210%

99.8%

216%

OnnoPlus tripled sales using Lexis Solutions. Assisting 8000+ businesses against harmful reviews on key platforms.

Onno Plus: CRM & E-commerce Boost with Lexis Solutions

Walter

Onno Plus achieves 3X sales by tailor-made CRM and e-commerce checkout

As the war in Ukraine raged in early 2022, and the core technical team was located there, FranceVerif's investors sought to diversify risk and guarantee reaching set milestones. They needed a reliable, devoted and well-grounded tech company to supplement their existing team and supervise their mobile application.


Their key decision factors were the price-to-quality ratio and the ability to form a strong team quickly.

As the client already had an ongoing mobile app, the team had to adapt to the existing codebase quickly and do a complete overhaul of the project.

Lexis Solutions led the mobile project while communicating tightly with their existing dev partners.

solution-france

Detecting the perfect copies of reputable websites may become a daunting task, so FranceVerif's Sure-T AI-based tool helps predict scams and protect customers. It allows shoppers to check the reliability of a site, avoid scams, and buy serenely on the web.

sure-t

Sure-T

Optimus Price is the automatic price comparison tool that browses different offers for a specific item on the web and discovers the best one. It's available through the mobile application or the browser extension.

optimus-price

Optimus Price

Robocash is FranceVerif's discount deal tool crawling the web to discover available vouchers for specific websites. It allows you to take advantage of your discount immediately.

robocash

Robocash

FranceVerif is working on a purchase assistant tool that allows checking the reliability of e-commerce sites, getting the best price for a given item, and automatically benefiting from available discounts.

franceverifi-full-cover

franceverif-preview

627K

75K+

With Lexis, FranceVerif’s AI tool verifies e-commerce reliability, ensuring optimal deals and auto-discounts.

FranceVerif: AI Detects 75K+ Fraudulent E-stores

avatar-mehdi-bellatig

FranceVerif identifies 75K+ fraudulent e-commerce stores by AI-based app

balans.bg logo

2019 was the year Kreston BulMar - the most prominent Bulgarian accounting and consulting agency in the last 25+ years, went to create a unique platform for further sharing its vast knowledge. The critical part was managing the thousands of documents accumulated over the last three decades. Lexis Solutions rose to the challenge. An abundant administration with sophisticated document parsing algorithms and a responsive, SEO-optimized client application was created, offered, and successfully implemented.

Balans.bg has nearly 4 000 unique resources separated into 13 categories - calculators, articles, legal acts, videos, news, textbooks, etc. With such a rich database, the platform offers its users a solution for every business case.

solution-balance

Each resource has connections to other resources, and their sum accounts for well over 10 000 links. By visualizing and organizing linked resources, users can seamlessly acquire a complete understanding of the issue and hand and solve their professional case.

interconnected

Resources are interconnected

Balans.bg detects whenever law articles are updated and notifies admins of potentially outdated resources. The process has been guaranteed by the links between resources and legal acts and guarantees.

updates

Constant updates

Because of the fantastic architecture, feature planning, and caching for quick access, each user can find their needed solutions as fast as the speed of light.

speed

Performance as fast as the speed of light

Kreston BulMar is the most prominent Bulgarian accounting and consulting agency, which, over the last 25+ years, has authored thousands of articles, analyses, commentaries, videos, handbooks, and a dozen textbooks. By 2019 they came to the idea of establishing a long-term partnership with an IT company to help them create a custom knowledge management platform to organize and monetize their professional expertise.

balans-full-cover

balans.bg zdds

preview-cover-balans

15K+

24K+

120%

Kreston BulMar teamed with Lexis for a custom platform, making 25 years of expertise accessible. Now reaching over 15K users.

Balans.bg: 25+ Years Expertise Harnessed with Lexis

Emil-Popov

Balans.bg surpasses 15K users on legal-tech platform with a knowledge base spanning 25 years

Our web development services make use of React, Next.js, Gatsby, Vue, Angular for the front-end, and Node.js, .NET, PHP, and AWS services for the back-end.

web-final-x1

Custom web solutions

For the best mobile experience, we use React Native, which allows us to craft beautiful applications for both iOS and Android, managing one codebase.

mobile-final-x1

Mobile development

We develop custom data solutions using databases, APIs, and web scraping tools to deliver clean and structured data. Whether you need to integrate data from multiple sources, turn complex data into actionable insights, or automate data workflows, we can help.

Build your digital solutions with expert help

We provide full-cycle software development

Custom web solutions

Mobile development

Custom data solutions

Success stories

Onno Plus achieves 3X sales by tailor-made CRM and e-commerce checkout

FranceVerif identifies 75K+ fraudulent e-commerce stores by AI-based app

Balans.bg surpasses 15K users on legal-tech platform with a knowledge base spanning 25 years

A partner that will make your idea better

Communication is key

No middlemen

Executives you can trust

Don't take our word for it

Latest articles

Guzzle's Hidden Gems: Beyond the Basics of HTTP Request Handling

Optimizing Web Data Retrieval: Web Scraping and Crawling

In the heart of the mountains: A Lexis Solutions getaway

Partner with a bolder software agency