Automation of processes through API and Python

Budget: 200 EUR Deadline: 1 day

Hello!

We can automate this process between services for you.

1. Can we discuss the content of the attachment right here?
2. Which stages need to be automated first?

—
About us

We are dZENcode – a full-cycle IT development company: from design and programming to integrations and post-release support of digital solutions. We create projects from scratch, as well as connect to existing solutions that need refinement, development, or technical support.

You can find detailed information about our services and rates on our official website: Freelancehunt

Take a look – after that we can discuss the details and agree on the next step.

⚠️ After clarifying all the details, we will determine the scope of work, the suitable format of cooperation: task-based, outsourcing, or outstaffing – and the final cost.

With us, projects are guaranteed to reach release:
• 10+ years providing IT services;
• 90+ in-house specialists;
• 250+ public reviews since 2015;
• We support products under SLA after launch;
• We work under NDA and contract with the company! Expand

Budget: 777 EUR Deadline: 1 day

Hello. I am ready to implement automation through n8n. Feel free to contact me.

Budget: 550 EUR Deadline: 7 days

Hello!

My name is Evgeny, and I have been professionally developing mobile applications, websites, web services, and web applications for 7 years.

*The cost mentioned is for 1 hour of work. To provide a more detailed price, I would like to connect/call and discuss the details.

- You can review my portfolio, feedback, and awards in my profile.

Why should you choose me?
- I have taken 1st and 2nd places in international championships and competitions in the IT field.
- I have verified video testimonials and letters of appreciation.
- I am always available, honest, and reasonable.
- I work under a contract.
- I lead my own development team.

I would be happy to talk to you in more detail about the project. Expand

Budget: 400 EUR Deadline: 1 day

Hello!
The task is clear — to eliminate all manual data transfer between Perplexity, Dropcontact, and Loxo CRM, leaving you only with launching the first prompt and the final check.
Here’s how I will implement it:
I will build automation through n8n (self-hosted or cloud) — this will give full control over each step without limitations on credits or API calls.
Flow:
You manually launch Prompt 1
↓
n8n receives the result from Perplexity
↓
Automatically sends data to Dropcontact
↓
Waits for a response with email addresses
↓
Automatically launches Prompt 2 in Perplexity
(correction of emails + formatting)
↓
Mapping fields to Loxo final format
↓
Creating a list and uploading leads to Loxo CRM
↓
You receive a notification — the list is ready
What I need from you to start:
— Examples of real process files that you attached — please send them
— Access to the Dropcontact and Loxo CRM API
— An example of the final file "Loxo final" with fields
— Examples of 2-3 prompts that you use (with different criteria)
Cost:
Turnkey setup — $400–600
Support for the first month is included, then $60–80/month if needed.
I am ready for a call for details. Send the files — I will take a look and give a more accurate estimate.
Best regards,
Bogdan Expand

Budget: 1300 EUR Deadline: 13 days

Robilem https://poseidon.codezerogroup.com — a platform with data pipelines between multiple external services, automatic processing, and API integration. Your case Perplexity -> Dropcontact -> Loxo is exactly the same type of work: API orchestration + data transformation + CRM.

I have reviewed the attached files — I understand the current manual process and the points where automation will bring the greatest time savings.

What I will do:
- Perplexity API integration — automatic triggering of the first and second prompt, handling credit limits
- Dropcontact API integration — email searching, data transfer between services
- Loxo CRM API integration — creating lists, loading leads
- Orchestration of the entire pipeline: Perplexity -> Dropcontact -> Perplexity -> Loxo, error handling and retry
- Python script with configuration via .env file, logging, ability to run on VPS 24/7

--- OPTIONS ---

- Option A (Core Automation): 1,300 EUR (13 days) — full automation of the Perplexity-Dropcontact-Loxo pipeline, Python script, configuration, testing on your data.
- Option B (Extended with monitoring): 2,080 EUR (21 days) — everything from A + status dashboard in Streamlit, Telegram notifications about errors, retry queue, handling variable prompt criteria per project. — best scope/price ratio
- Option C (UVWeb Premium): 2,710 EUR (27 days) — everything from B + deployment on VPS, CI/CD GitHub Actions, documentation, 30 days of post-implementation support.

Execution time: 13-27 days. I need API keys (Perplexity, Dropcontact, Loxo) and sample test data.

Portfolio:

- https://poseidon.codezerogroup.com — enterprise platform, Python/React, API integrations, data pipelines
- https://nyxvx.com — Epic Games, custom CMS, high-load infrastructure
- https://ou-uv.com — Flask/Python CMS, API integration, Docker

8 years in backend and automation — from simple scripts to enterprise platforms with multiple APIs and data pipelines.

Available immediately, I can start upon receiving the API keys. Expand

Budget: 100 EUR Deadline: 3 days

Hello, I have experience in automation using Python and I am ready to deliver quality work in the shortest time possible.

Budget: 200 EUR Deadline: 7 days

Hello.

I can assemble the first working MVP for automation between Perplexity, Dropcontact, and Loxo: lead processing, re-AI-normalization, data structure verification, and preparation/uploading of the list for Loxo final.

The key part here is a stable pipeline: a clear field schema, duplicate checking, handling empty or questionable emails, logging each run, and the ability to repeat a specific stage without manually restarting the entire process.

Technically, I propose a Python API bridge:
- Perplexity API for prompt logic and structured output
- Dropcontact batch API with result waiting
- mapping for Loxo final
- uploading to Loxo via Open API or fallback CSV
- retry, logs, dedupe, basic run report

Before starting work, I need to clarify:
- whether there is a Perplexity API key
- whether there is a Dropcontact API/credits
- whether Loxo Open API is available in your plan
- an example of the input file and final Loxo final
- which fields are mandatory for a lead

After a test run, we can accurately finalize full automation and support.
We can discuss the details in a language convenient for you (Ukrainian, Russian, English). Expand

Budget: 18000 EUR Deadline: 7 days

Hello. Here, it's not just about setting up the CRM, but about a managed funnel and integrations that work seamlessly in real operations.

What I understood about the task: After that, the data is processed again through Perplexity: - manually correcting inaccuracies in emails; formatting the data to the required view; preparing the final file for upload to Loxo CRM. / I would like to automate it. The main task is to automate the entire process between: Perplexity Dropcontact Loxo CRM Ideally, I would like to automate: Data transfer: Perplexity → Dropcontact Dropcontact → Perplexity Perplexity Loxo Automatic launch of the second prompt.

How I would approach it:
1. First, I will describe the lead/client journey and statuses so that the CRM reflects the real process, not just a set of fields.
2. I will gather integrations through webhooks/API with logs, retries, and duplicate protection.
3. In the end, I will leave a clear map: what happens automatically, what the manager does, where to look for failures and metrics.

Relevant experience: I have done end-to-end API/integration pipelines: data collection, filtering, enrichment, CRM connections, logs, and duplicate protection.
Regarding timelines: the target is 7 days. Regarding budget: 18,000 — after a brief clarification of the technical specifications, I will be able to confirm more precisely.

If relevant — in the first message, I will provide a short implementation plan and a list of clarifications to immediately fix the MVP without unnecessary development. Expand

Budget: 650 EUR Deadline: 9 days

Hello.

I am ready to take on the automation of this process. I carefully reviewed the description: the task is clear — we need to eliminate manual transfers between Perplexity, Dropcontact, and Loxo CRM and create a stable workflow where, after launching the first prompt, the process automatically goes through all stages to a ready list of leads in Loxo.

I have practical experience in building AI/workflow automations through Make, AI tools, APIs, spreadsheets, Notion/CRM logic, data processing, statuses, field mapping, and error control. In my projects, I have already built chains where data passes through several services, is processed by AI, formatted as needed, and then transferred to the publishing/CRM system.

For your case, I see the following workflow logic:

1. Analyze the current files and the final format "Loxo final".
2. Describe the exact field scheme: what data comes from Perplexity, what is needed by Dropcontact, what is returned back, what should go into Loxo.
3. Assemble the first workflow:
— launch after Prompt 1;
— transfer data to Dropcontact;
— receive email;
— reprocess/clean through Perplexity;
— prepare the final file;
— upload/create the list in Loxo CRM.
4. Add checks: empty emails, duplicates, format errors, limits, invalid strings.
5. Test on a small volume of leads, then scale up to your 300 leads per day.

I would suggest starting with the first stage within your budget of 500 euros:
— analyze the actual process files;
— design the automation scheme;
— assemble the first working MVP on a test volume;
— check data transfer and mapping for Loxo final;
— after testing, accurately assess full automation and support.

Important: I will not promise "everything in one day" because we need to check the availability of APIs/integrations for Perplexity, Dropcontact, and Loxo, as well as the format of your files. But the task itself is realistic, and it can be properly assembled step by step.

I am ready to start with an analysis of your files and a short call/chat to clarify:
— where the result of Prompt 1 is currently stored;
— in what format Dropcontact accepts the file;
— how exactly Loxo accepts imports;
— whether Make/n8n or another integration is needed;
— which fields are mandatory for the final list.

After that, I will be able to propose a precise assembly plan and the first MVP. Expand

Budget: 500 EUR Deadline: 5 days

Hello!

I can help turn this into a single automated process, so you only need to run the first prompt, and everything else will be done automatically, including creating the final list directly in Loxo. I have already implemented many similar automations that transfer data between services, clean it, and maintain a consistent format, so you won’t have to manually fix columns every day.

I suggest adding a simple quality check step between Dropcontact and the final upload, which will automatically flag suspicious email addresses and duplicates, and then resend only those rows for a second processing stage through Perplexity. This will help reduce credit consumption and improve email deliverability while keeping a clean file fully ready for upload to Loxo.

I can set up the process as follows: the result of the first prompt is automatically saved and structured, then sent to Dropcontact for data enrichment, after which the processed file triggers the second prompt for cleaning and formatting. Finally, the system creates a new list in Loxo with correct field mapping according to your final format. Additionally, a project execution log will be maintained so you can always track what happened during each run and quickly repeat the process if any service encounters a request limit.

https://oscarstories.com
https://live.chatbullet.com

Thank you! Expand

Budget: 80 EUR Deadline: 2 days

I reviewed the process and files. The main technical point to agree on before starting is that the result of the prompt cannot be automatically retrieved from the Perplexity web interface — to eliminate manual steps, the first prompt must also go through the API. For you, this will look just as simple: an input field for criteria, a start button, and then the chain itself: Perplexity → Dropcontact (they have asynchronous batches — the script waits and retrieves the result itself) → second prompt for cleaning → mapping for Loxo final → creating a list in Loxo.

I will do it in pure Python without n8n and paid subscription intermediaries: one script with config, logs, and retries for failed steps. It can handle 300 leads a day easily and requires no maintenance.

Two questions: do you have a Perplexity API key or just a web subscription? And is Open API included in your Loxo plan — it is not available in all plans, which affects the upload method.

The price includes a day of testing on your real projects and instructions for launching.

Budget: 300 EUR Deadline: 5 days

Hello!

Great description of the process. I looked at the attached logic and understand your pain: manually transferring files between three services for 300 leads a day wastes a lot of time, and the mapping of columns (when emails or names misalign) adds stress before uploading to Loxo CRM.

I am a Python developer specializing in creating API orchestrators and automating work with LLM.

Some suggest emulating clicks in the browser (Playwright) — this is a bad idea; the system will break at the first design update of Dropcontact. I propose to build a reliable monolithic API bridge.

How it will work under the hood (Ideal scenario):

Single launch window: I will create a micro web form (or a simple Telegram bot) for you. You input your criteria for Prompt 1. At this point, your manual work ends.

Perplexity API: The server receives the criteria and collects the initial pool of companies through the API (models sonar-pro or sonar-reasoning).

Enrichment (Dropcontact): Data goes directly via API (bypassing the CSV download stage) to Dropcontact. They have an asynchronous API (batch processing) — my script will wait for the result and retrieve the completed batch of emails.

Cleaning (Perplexity Prompt 2): Dirty data returns to Perplexity. Here I will apply Structured Outputs (a strict JSON schema). The AI will guarantee to return data in a format where the First Name column is always a name, not a title. Mapping will never misalign again.

Final export to Loxo CRM: The clean JSON array is automatically uploaded to Loxo via their Open API, creating a ready list.

Two important questions for accurate assessment:

Do you have access to the paid Perplexity API (it is billed separately from their Pro subscription), and is the Open API available in your Loxo CRM plan?

Is there a strict time limit for the entire cycle from submission to entry into the CRM?

Timeline and budget:
Developing such an API bridge, considering all error logs and testing, will take 5-7 days.
Budget: 250 - 300 EUR.

Let's communicate, I'll look at your files, and we can start right away! Expand

Budget: 150 EUR Deadline: 2 days

Hello, how are you doing today?

I am very interested in your post.

I have extensive experience in this field, so I can confidently provide you with an answer.

I believe we can create excellent and wonderful projects together in the future.

I look forward to your reply.

Thank you. Expand

Budget: 450 EUR Deadline: 6 days

I can fully automate this workflow using Python and APIs. The system will automatically transfer data between Perplexity, Dropcontact, and Loxo CRM, run the required prompts, format leads correctly, and create ready-to-use lists inside Loxo. Estimated delivery: 7-10 days.

Budget: 90 EUR Deadline: 1 day

Hello, I have experience in automating similar processes between API services (Perplexity, Dropcontact, CRM) using n8n/Make and can set up a complete pipeline so that after manually launching the first prompt, the rest runs automatically with the correct field mapping in Loxo CRM. The deadline is 3 days, and the cost is 4500 UAH. I look forward to collaborating!

Budget: 222 EUR Deadline: 2 days

Hello, I will do it. I have extensive experience in Python development. Please message me privately.

Budget: 150 EUR Deadline: 2 days

Hello!

Automating the workflow between services via API is our specialized area, and the task is clear. The goal is clear: you manually trigger Prompt 1, then the entire process runs automatically, and you end up with a ready list of leads in Loxo CRM — you just need to check and launch the mailing.

How we will gather:

- A unified pipeline that connects Perplexity → Dropcontact → Perplexity → Loxo CRM through their API, without manual file transfers between services;
- Automatic triggering of the second prompt and data transfer between steps;
- Field mapping strictly according to the "Loxo final" format;
- Automatic creation of the lead list in Loxo CRM.

The first prompt is up to you (the criteria change per project) — everything else happens automatically. This will eliminate manual work from your ~3 projects and 300 leads per day.

To assess accurately, please clarify:

- Is there API access to Perplexity, Dropcontact, and Loxo CRM (keys / rates)?
- Please send the attached files (example of the process and "Loxo final" format) — I will look at the structure for correct field mapping.

We will discuss project details and costs in private messages. Expand

Budget: 300 EUR Deadline: 4 days

Hello. I understand the process: right now everything is done manually between Perplexity, Dropcontact, and Loxo CRM, about 300 leads a day for three projects, and I would like you to launch only the first prompt, and then everything goes automatically to the ready list in Loxo, which remains to be checked and launched for mailing.

I would assemble this as a pipeline in Python through the APIs of the services: after the first prompt, the result goes to Dropcontact for email search, then the data returns for a second pass in Perplexity for correction and formatting, and finally, a list is created in Loxo CRM with the correct field mapping for your Loxo final format. I will add checks and logs between steps so that if one service fails, the process does not completely stop, and you can see which lead and why it halted.

The key part is the correct alignment of formats between services and field mapping for Loxo, because this is where time is currently lost on manual handling. The main criterion for the first prompt remains with you, and you can change it for the project; everything else from Dropcontact to list creation is automated.

I constantly automate processes between services through their APIs in Python. To assess accurately: is Open API enabled in your Loxo CRM plan, and do you use Perplexity through an API key or just a web subscription? The availability of the APIs of these services determines where automation is direct and where a workaround layer will be needed. I am ready to start with analyzing the file formats of the real process that you attached.

Budget: 500 EUR Deadline: 3 days

Good day. I am ready to complete this project and have extensive experience in developing various applications.

Budget: 200 EUR Deadline: 3 days

Hello! I have reviewed the project and am ready to start working. I am confident you will be satisfied with the result.

Budget: 500 EUR Deadline: 8 days

Hello.
I understand the task. It is important here not just to transfer the file between services, but to build a stable pipeline that can process about 300 leads daily without manual copying and without misaligned mapping.
I would do this as a Python/FastAPI orchestrator or n8n + Python for complex processing.
Logic:
you start the first prompt with project criteria;
the result is fetched into the system;
data goes to Dropcontact;
after enrichment, the second prompt is launched for cleaning, verification, and formatting;
after that, the data is mapped to Loxo final;
a list/import is created in Loxo CRM;
at the output, there is a processing log, errors, and a file/status for each project.
I would like to highlight two important points:
1. You need to check how exactly you are using Perplexity: via API or through the web interface. Using the API will be more reliable. Using the browser can also be discussed, but it is a less stable option.
2. You need to check if your Loxo plan includes access to the API. If there is no API, a version can be made by preparing a correct file for import.
I would start with a test run on one of your real processes and one Loxo final file to capture the data structure and mapping.
The main question: do you have access to Perplexity and Loxo via API, or is the entire process currently going only through the web interface and files? Expand

Budget: 180 EUR Deadline: 6 days

Hello! I have understood the process, the task is clear and fits well with my automation experience (n8n, Python, working with APIs).

The essence of the solution: the entire path will be one orchestrator scenario. You manually launch Prompt 1 (with criteria for a specific project), then everything goes automatically:
- Perplexity searches for companies and leads, the result goes to Dropcontact for email search
- enriched data returns to Perplexity for the second prompt (email cleaning, formatting), which is launched automatically
- final data is mapped to the "Loxo final" format and uploaded to Loxo CRM with the creation of a list.
In the end, you get a ready list in Loxo, check it, and launch the mailing.

I am focusing on n8n as the core (flexible, easy to maintain and change criteria for the project), with Python for any non-trivial processing logic. I will make the criteria for Prompt 1 editable (form or input field), so you can change them without modifying the code.

Budget: 200 EUR Deadline: 4 days

Hello! I have familiarized myself with your process, you described it very well, thank you!

I am ready to build a complete automation of this chain based on n8n (as the main orchestrator). This will give you:

- minimal manual actions (in fact — just launching Prompt 1)
- repeatable results (one format, one mapping, no "messed up" columns)
- the ability to easily scale the system for other processes in the future

Here’s how I see the "ideal scenario" for implementation:
1) You manually launch the prompt (or we can automate this too — depending on what is currently convenient/possible with Perplexity).

2) Then n8n automatically:
- retrieves the result from Perplexity
- sends companies/leads to Dropcontact for email search
- receives enriched data back
3) Launches "Prompt 2" (cleaning/validation/normalization + structuring)
forms the final file in the format for Loxo CRM with the correct field mapping
creates a list in Loxo CRM and uploads the ready leads there

At the output: a ready list of leads in Loxo, you just need to check and start the mailing.

Infrastructure:
I will set up all the infrastructure for this process to work and create several convenient ways to launch it, for example:

- Telegram bot / Viber
- email trigger
- simple form on the website
- Google Sheets (launch by button/row)

whichever is closer to your process. Expand

Budget: 100 EUR Deadline: 5 days

Good day. I specialize in Python, particularly in automation processes. I can quickly set up a pipeline according to the task.
Message me privately, and I will propose a detailed implementation plan, and we can discuss the terms.

Budget: 100 EUR Deadline: 1 day

Good day

I have extensive experience in developing automated workflows, integrations between SaaS services, CRM systems, and AI platforms. I have worked with automating processes for collecting, processing, and transferring leads, including integrations via API, webhooks, and orchestration middleware.

From your description, I see that the main issue lies not in finding leads themselves, but in the manual data transfers between Perplexity, Dropcontact, and Loxo CRM. This can be fully automated into a single pipeline.

I envision the implementation as follows:

• automatic retrieval of results after Prompt 1;
• transferring leads to Dropcontact for enriching contact data;
• monitoring the completion of processing and automatically retrieving results;
• launching the second prompt without manual intervention;
• automatic formatting and validation of data;
• creating lists in Loxo CRM;
• correct mapping of all fields to the final format;
• logging and error control at each stage.

As a result, after manually launching the first prompt, the entire subsequent process will operate automatically, and you will receive a ready list of leads in Loxo CRM.

I am ready to thoroughly review the provided files and suggest an optimal architecture for implementation. We can discuss the details in private messages. Expand

Budget: 300 EUR Deadline: 3 days

Hello! I will set up automation according to your requirements. Please message me to discuss all the details.

Budget: 777 EUR Deadline: 1 day

Good day.
Most likely, it will require just one API to bypass it; a hybrid solution will be needed.
I am engaged in automating similar processes.
Feel free to reach out.
The price is negotiable.

Budget: 280 EUR Deadline: 5 days

I work with Python and have experience in API integrations.

I see the implementation as follows: the script runs locally, sends a prompt to the Perplexity API, receives a list of companies with contacts, passes the data to Dropcontact for email search, formats the result, and creates leads in Loxo via the /people endpoint.

Clarification regarding Loxo: do you have an active subscription with Open API enabled? I know that this feature is not available in every plan, so it's better to check before starting work.

Deadline: 3-5 days. Cost: 280 EUR.

Budget: 350 EUR Deadline: 7 days

I have automated similar pipelines — I understand the task.

Essentially, I need an orchestrator that takes the result of the first prompt from Perplexity and then processes the data through the chain: Dropcontact for email enrichment, back to Perplexity for cleaning and formatting, and final export to Loxo CRM with the correct field mapping. The only manual step is launching the first prompt — everything else is automated.

I will implement this through n8n or Make.com — a visual workflow that is easy to maintain and modify the logic without coding if necessary. If Loxo and Dropcontact have APIs — I will connect directly; if not — we will solve it through webhooks or file exchange.

Before giving an accurate estimate, please clarify a couple of points: do you use Perplexity through a web interface or do you have API access? And does Loxo have an API or only manual file import?

Budget: 25 EUR Deadline: 1 day

Hello
I am currently actively working on this topic.
Message me privately to discuss all the details.

Budget: 600 EUR Deadline: 6 days

I have familiarized myself with the process.

I envision the implementation through a separate backend service on FastAPI, which will act as an orchestrator between Perplexity, Dropcontact, and Loxo CRM.

Workflow scenario:

1. You manually trigger Prompt 1 in Perplexity.
2. The result is automatically sent to the system.
3. The backend formats and sends the data to Dropcontact for email search and validation.
4. After receiving the result, the second prompt in Perplexity is automatically triggered for cleansing, normalization, and formatting the data to the required structure.
5. The system automatically generates the final file according to the Loxo Final structure.
6. A list is created in Loxo CRM via API, and all leads are uploaded with the correct field mapping.
7. After the process is completed, you receive a ready list of leads in the CRM without additional manual actions.

Additional features can include:

- logging of all executions;
- error control at each stage;
- re-triggering of individual steps in case of failure;
- saving the history of processed projects.

For an accurate estimate, it is necessary to check the availability and capabilities of the APIs for Perplexity, Dropcontact, and Loxo CRM, as well as to see examples of input and final files.

I preliminarily estimate the implementation to take 20–40 hours of work depending on the capabilities of the APIs and additional requirements.

I look forward to your response. Expand

Budget: 248 EUR Deadline: 1 day

I carefully studied your workflow. The task is clear: we need to eliminate manual work and connect Perplexity, Dropcontact, and Loxo CRM into a single automated pipeline.

Here’s how I envision the implementation in Python:

The script intercepts the results of the first prompt from Perplexity.

It forms a correct JSON request and sends the data via API to Dropcontact for email enrichment.

It receives a response, runs it through the second prompt of Perplexity (for validation/cleaning).

It performs the correct field mapping and pushes the prepared list of leads to Loxo CRM via their API.

I have experience in backend development in Python and close work with third-party REST APIs. I will write clean code with error handling (for example, if Dropcontact does not find an email or the API times out — the script will not crash, but will log this).

I have a few questions before starting work:

Do you already have generated API keys for all three services (Perplexity, Dropcontact, Loxo)?

Where do you plan to run this script (locally on your computer if needed, or should it be a service deployed on a server/VPS)?

I work through Safe. I am ready to discuss the details and review examples of your files! Expand

Budget: 300 EUR Deadline: 5 days

Good day!

I am a Python developer with experience in automating business processes and integrating third-party services via API. I can implement a complete automation cycle between Perplexity, Dropcontact, and Loxo CRM: automatic data transfer, triggering the second prompt, processing results, creating lists in the CRM, and correctly mapping fields to the required format. I will also help optimize the process to minimize manual actions and ensure stable daily lead processing.

I am ready to discuss the details and propose the optimal solution.

Budget: 330 EUR Deadline: 12 days

Good afternoon. If all actions are done through the browser, then it can be automated using Python + Playwright. Can you record a video of the complete algorithm to understand the scope of work?

Budget: 550 EUR Deadline: 7 days

I will create it as a program, requests will be sent through the APIs of the specified services.
It is necessary to connect 3 services.
After the project is completed, I will remain in touch.
Write to me, and we will discuss in more detail; if there are any clarifying questions and if live examples are needed.

Budget: 730 EUR Deadline: 7 days

Good afternoon
I will write a script for automation in PHP
Cost 730EUR, deadline one week
I have extensive experience in automation, CRM API, AI

Budget: 300 EUR Deadline: 2 days

Greetings! The task is clear, this is a classic case of lead generation automation, which I regularly implement in Python.

I propose to build a reliable asynchronous script (API bridge) with logic for re-checks and watchdogs that will connect Perplexity, Dropcontact, and Loxo CRM.

For flexibility, we will move the initial prompt and mapping settings to a convenient configuration file (or we can manage it through a Telegram bot, so you can start the process directly from your smartphone).

It will take about 2 days for development and 1 day for testing. Let's discuss the details regarding the Perplexity API and the import format for Loxo!