Json Question posted in
Our archive of expertly curated questions and answers provides insights and solutions to common problems related to this popular data interchange format. From parsing and manipulating JSON data to integrating it with various programming languages and web services, our archive has got you covered. Start exploring today and take your JSON skills to the next level

Json – How to validate company registration data using an API in Python?

I’m developing an application that needs to validate company registration data against a centralized database. I want to use Python to send the registration details to an API and retrieve validation results.

I’ve come across an API provided by Law Council Group that offers endpoints for company registration validation within the Astana International Financial Centre (AIFC). However, I’m unsure about the best way to integrate this API into my Python application for efficient validation.

Could someone provide an example of how to send a POST request with JSON data to this API using requests or any other suitable Python library? Also, any tips on handling responses and errors would be appreciated.

Here’s a basic idea of what I’m trying to do:

import requests

api_url = "https://lcg.kz/api/validate"
company_data = {
   "name": "Example Company",
   "registration_number": "123456789",
   "country": "Kazakhstan"
}
 
response = requests.post(api_url, json=company_data)
if response.status_code == 200:
   validation_result = response.json()
   print(validation_result)
else:
   print(f"Error: {response.status_code}")

I’m particularly interested in:

How to handle different types of responses (success, validation errors, etc.)
Best practices for sending and receiving JSON data in this context
Thank you in advance!

Tags:

2

Answers


  1. 0

    A typical pattern could look like this:

    import requests
from requests.exceptions import HTTPError

company_data = {
    "name": "Example Company",
    "registration_number": "123456789",
    "country": "Kazakhstan",
}

url = "https://lcg.kz/api/validate" 

with requests.post(url, json=company_data) as response:
    try:
        response.raise_for_status()
    except HTTPError as e:
        print(e, response.text)

    raise_for_status is documented here

    If the HTTP status indicates some kind of error then the exception will tell you what happened. There may be further information in response.text that qualifies the issue.

    In this particular example, the HTTP status code is 447 (non-standard) and there’s no other information that explains why that’s been returned. It may simply be because the reference data (json) is garbage

    Login or Signup to reply.
  2. 0

    A good practice would be to implement something like the following client:

    from contextlib import asynccontextmanager
from typing import AsyncIterator

from aiohttp import ClientResponseError, ClientSession, ClientResponse
from pydantic import BaseModel


class CustomClientError(Exception):
    """Base error for all Client related errors."""


class ValidateCompanyResponse(BaseModel):
    ...


class Client:
    def __init__(self, base_url: str) -> None:
        """."""

        self._session = ClientSession(...)
        self._base_url = base_url


    @asynccontextmanager
    async def handle_client_error(self, response: ClientResponse) -> AsyncIterator[None]:
        """Handle HTTP errors from your Client."""

        try:
            response.raise_for_status()
            yield
        except ClientResponseError as exc:
            logger.error(f"Client error occurred: {exc.message}")
            raise CustomClientError(exc.message)


    async def validate_company(self, data: dict) -> ValidateCompanyResponse:
        """Validate company."""

        async with self._session.post(
            f"{self._base_url}/api/validate",
            json=data,
            headers={"Content-Type": "application/json"},
        ) as response:
            async with self.handle_client_error(response=response):
                company = await response.json()

            return ValidateCompanyResponse.model_validate(company)

    With this setup you can catch CustomClientError at all levels above which is a pretty convenient and scalable way to handle errors.

    Successful response body can be validated using corresponding pydantic model. You can actually even catch pydantic.ValidationError and convert it to CustomClientError if you need it.

    Login or Signup to reply.
Please signup or login to give your own answer.

Back To Top
Search