Development of a Tampermonkey script for automating responses in the internal CRM via the OpenAI API.

Budget: 12000 UAH Deadline: 5 days

I can create a Tampermonkey script for your CRM with prompt settings for 5-10 IDs, tracking new messages, querying the OpenAI API, and inserting the response into the chat field. For a budget of 6000 UAH, I can make a basic version, but for a proper settings window, checks, logs, and testing, I would estimate from 12000 UAH and 5 working days.

I have experience with OpenAI, browser automation, and internal working systems. Close examples:
> https://business.ingello.com/vorfahr - AI automation of workflow
> https://business.ingello.com/fractal - agent logic and automation scripts
> https://systems-fl.ingello.com/ua - our profile in system development

For implementation, I see it this way - first, we establish stable reading of the active ID and new text, then map the ID to system instructions in a convenient settings window, followed by integration with gpt-4o-mini, drafting the response in the input field, and sending it with a delay of 20-45 seconds. I would also add stop filters, a log of recent actions, and a testing mode without sending - practice shows that rushing can make people laugh =)

From your side, access to a test CRM account or an HTML example of the page is needed, as well as a way to store the OpenAI API key - either in the script settings or through your intermediary server.

I would like to clarify two points:
> Does the CRM update the chat via WebSocket, periodic requests, or simply by changing the DOM on the page?
> Should the response be sent fully automatically, or is it better to first insert it as a draft for the operator to check?

I will test the script on a real page or on your test example before handing it over, to avoid a situation with code that looks good but doesn't work. Here, it seems the main risk is not the OpenAI API, but the stable detection of a new message and the correct active dialogue. Expand

Budget: 6000 UAH Deadline: 2 days

Hello.

I am a NodeJS developer. I have experience with the OpenAI API. I can write a JS script for you.

Budget: 6000 UAH Deadline: 4 days

Good day! This is exactly my profile: I write browser automation scripts and do integrations with the OpenAI API. The task is clear and will be done carefully.

Here’s how I see the implementation. A separate settings window right in the script: a table "Dialogue ID — your System Prompt," so you can add and edit prompts yourself without me, plus a field for the OpenAI key and model selection, gpt-4o-mini as you requested. The key is stored locally in the Tampermonkey storage and is not hardcoded in the code. I catch new messages through MutationObserver on the chat container, without reloads and without polling the page every second. I insert the response into the input field and send it with a random pause of 20–45 seconds, as described.

I will add two small features that usually help in such scripts: a switch right in the panel so the operator can intercept the dialogue manually at any moment, and protection against replying to the same message multiple times.

A question regarding the essence: does that unique dialogue ID lie in the page markup or in the address bar, and does the dialogue switch without reloading? This determines what exactly to attach the observer to. If you send a screenshot of a piece of the markup, I can tell you exactly without guessing.

The price is 6000 UAH within your budget, and the timeframe is 4 working days. I am ready to show live examples of my scripts in the chat so you can see the level before the solution.

Petro Pankov, BotCraft Group Expand

Budget: 6000 UAH Deadline: 3 days

The main thing here is not OpenAI, but detecting a new message in the CRM chat: using MutationObserver on the dialog container instead of polling, otherwise the script consumes CPU and duplicates responses with fast messages. I have been writing browser automations since 2013 and have worked with the OpenAI API multiple times. I will save the ID-prompt map using GM_setValue so that the settings persist through page reloads - if you plan otherwise, let me know. Shall we discuss the details in correspondence?

Budget: 6000 UAH Deadline: 7 days

Hello, I worked on Auto-CRM Assistant — a script on Tampermonkey that processed over 3000 messages a day through the OpenAI API with a delay of 15–40 seconds to simulate a live operator. Very similar to your project!

Please tell me, is the unique dialogue ID always located in the same element on the page, or can its location change depending on the type of chat? This is important for stable reading.

I suggest we get in touch; I will provide you with free technical consultation and we can create a development plan + I will tell you about my team! ✨

Budget: 6000 UAH Deadline: 5 days

I have experience with the OpenAI API and browser automation, including working with Tampermonkey scripts. Your task is entirely within my profile: reading the dialogue ID, storing prompts in settings, integrating with gpt-4o-mini, and inserting responses with simulated delays. My portfolio includes ShopAgent AI with Claude API, demonstrating experience with LLM integrations. I will implement the script in 5 days, with tested logic for reading CRM elements, secure key storage, and a user-friendly settings window. The rate of 6000 UAH corresponds to the complexity of the task and the volume of work. I am ready to start immediately after approval.

Budget: 6000 UAH Deadline: 3 days

Hello, Maxim!

This is our profile — we integrate AI agents into CRM, tampermonkey + OpenAI for specific layouts regularly (tyaplyapai.com).

The key here is not OpenAI itself, but a reliable detection of new messages (MutationObserver + deduplication, without double responses), correct insertion into the React/Vue field, and verification before sending, so as not to respond in a switched dialog with a delay of 20–45 seconds.

I suggest starting with a prototype on one dialog to match the layout.

We are just entering Freelancehunt and are currently consciously building a client base and reviews — so we will do it cheaper than others: 4500 UAH instead of 6000, timeframe 3 days. This does not affect the quality; we just prioritize the first projects and your feedback.

Two questions: screenshot/HTML of the dialog window of your CRM? Expand

Budget: 6000 UAH Deadline: 3 days

I am a NodeJS developer. I am ready to take on this task. Write to me, and we will discuss.

Budget: 6000 UAH Deadline: 2 days

Hello. The task is completely clear. I have extensive experience in developing automation scripts for Tampermonkey (Greasemonkey) and integrating with the OpenAI API. I am ready to implement this tool quickly and efficiently.
How the script will be implemented:
Reading messages and IDs: I will use MutationObserver to track the appearance of new messages in the chat in real-time without burdening the browser. The script will automatically parse the unique ID of the active dialogue from the DOM structure of the page.
Settings window (UI): I will integrate a neat and user-friendly floating panel (Settings Modal) into the CRM interface. In it, you will be able to specify your OpenAI API key and fill in the parameter map: enter dialogue IDs and their corresponding custom System Prompts. All settings will be securely stored in the local memory of the extension via GM_setValue.
Working with OpenAI: Requests will be sent asynchronously to the gpt-4o-mini model (it works instantly and is the most budget-friendly in terms of tokens).
Human imitation: After receiving a response from the AI, the script will initiate a random delay of 20–45 seconds. After that, it will insert the text into the input field, programmatically generate input, change, and keydown events (this is necessary for modern frameworks like React/Vue in the CRM to correctly recognize text input) and initiate the click of the send button.
Cost and deadlines:
Final cost: 6,000 UAH.
Completion time: 2 days (including testing and adjustments to your CRM selectors).
To start working, I will need a screenshot of the chat page code (DOM tree) so that I can clearly see the classes/IDs of the input field, send button, and the element where the dialogue ID is displayed. I guarantee clean, commented code and complete confidentiality of your CRM system. I look forward to hearing from you in private messages.

Budget: 6000 UAH Deadline: 5 days

Hello! I am ready to discuss and complete your order.

https://smate1.github.io/ink.design/
https://smate1.github.io/PanterEx/
https://smate1.github.io/stay_safe/
https://smate1.github.io/avg/

Budget: 6000 UAH Deadline: 5 days

Hello! I am ready to create a Tampermonkey script with GPT-4o-mini. I have experience working with the OpenAI API and JS injections. For security, we will store the keys in the local/sync storage of the extension.

How is the message sending initiated in the CRM — by clicking or through DispatchEvent?

I suggest we discuss the details.

Budget: 6000 UAH Deadline: 4 days

I have almost ready a similar solution for automating responses via OpenAI, which can be quickly adapted to your CRM and put into operation.
I am available to discuss the details within the marketplace.

Commercially, I can work within your budget - 6000 UAH.
The timeframe is estimated at 3-4 days after access to the test page or recording the HTML structure of the chat.

I see the implementation as follows:
> Tampermonkey script reads the active dialogue ID
> for each ID, it pulls its instruction from a convenient settings window
> tracks new messages through changes on the page
> sends text to OpenAI API on gpt-4o-mini
> inserts the response into the input field and triggers sending with a random delay of 20-45 seconds
> we add protection against reprocessing the same message and an error log

!!security nuance!! - the OpenAI key in the browser script may be visible to the operator, so I would suggest either a limited key or a small intermediate server if this is an internal production CRM.
It can be kept simple in the first version, but it's better to consider this.

I would like to clarify 2 points:
> is there test access or at least an example page with HTML chat?
> should the response only be inserted into the field or is it actually necessary to press the send button automatically?

Similar logic cases:
> https://business.ingello.com/vorfahr - automation with AI and business logic
> https://business.ingello.com/fractal - agent scenarios and working with instructions

Main page for Ingello systems for FLH:
> https://systems-fl.ingello.com/ua Expand

Budget: 6000 UAH Deadline: 2 days

Good day!

The task is clear. I am writing integrations for the OpenAI API with userscripts and plugins.

The logic is straightforward. Two technical points that I will consider right away:
— Reading the ID and new message — through MutationObserver, not polling. The selectors are tied to the CRM layout — I keep them easily updatable in case of CRM updates.
— A queue of requests, so that when there is a batch of messages, parallel requests do not occur and responses do not overlap.

The rest is straightforward work: a settings window with a map of ID→prompt, calling gpt-4o-mini, inserting the response + sending with a delay of 20–45 seconds. The key is in GM-storage, not in the code.

To provide a firm deadline — I need access or screenshots of the CRM DOM (where the ID, message, input field are). In terms of volume — a day to a day and a half, I can stay within budget. Expand

Budget: 6000 UAH Deadline: 3 days

Hello, message me privately to discuss, I have experience with the OpenAI API.))

Budget: 6000 UAH Deadline: 3 days

I understood the task: a content script for Tampermonkey that reads the ID of the active dialogue in the CRM, pulls the corresponding system prompt from a map, sends a message via the OpenAI API (gpt-4o-mini), inserts the response into the input field, and initiates sending with a random delay of 20-45 seconds.

I have stable experience with OpenAI and Anthropic APIs, prompt engineering, building LLM pipelines, and I have experience in browser automation using Playwright and Selenium. I haven't previously created a Tampermonkey script, but this is a standard JS content script with MutationObserver and fetch to the API, technically not difficult, I will do it without a backend, purely a client-side script.

I will display the prompt map by ID in a separate settings window of the script using GM_setValue, so that parameters can be edited without interfering with the code. I am ready to discuss timelines and implementation details.

Budget: 6000 UAH Deadline: 3 days

Good day. I have reviewed your task and believe that I can turn your aspirations into a working structure. I suggest we discuss the details of the work and get started 😊

Budget: 5700 UAH Deadline: 3 days

Hello!

The task is clear and fully aligns with my profile — I am a frontend developer (React/TS), and I often work with integrating LLM-APIs (OpenAI, Anthropic) into web services and streaming interfaces, so there will be no issues with the tampermonkey script and working with the DOM.

Here’s how I envision the implementation:
— I read the ID of the active dialogue from the DOM and pull the necessary System Prompt from the settings;
— I catch new messages via MutationObserver;
— I send the text + prompt to gpt-4o-mini and insert the response into the input field with a random delay.

I will immediately account for solutions to non-obvious areas where such scripts usually break:
1. Deduplication — MutationObserver often triggers multiple times for a single message, so I maintain a list of already processed messages to avoid duplicate responses.
2. Pre-send check — while the delay is ongoing, the interlocutor may add more text or the operator may switch the dialogue; before sending, the script checks that the dialogue is the same and no new messages have appeared.
3. Input field — if the CRM is on React/Vue, a simple value assignment will not work; a correct event dispatch is needed, otherwise the framework will not "see" the text.
4. CORS — call to OpenAI via GM_xmlhttpRequest.
5. API key — in the userscript, it is essentially open; I can store it in GM storage, but it’s safer to make the call through a small proxy. This depends on your security requirements.

What I suggest starting with: first, create a minimal prototype on one dialogue (reading → sending to API → inserting response) to quickly verify against the actual layout of your CRM, and then scale it to 5–10 dialogues and prompt settings. This saves time, as everything hinges on the specific layout of the CRM.

To accurately assess the timeline and amount, a few clarifications:
1. Who are the end recipients of these responses, and are they aware that they are communicating with an automated system? This affects both the logic and whether I will take on the project.
2. What CRM is this — can you provide a screenshot or HTML fragment of the dialogue window? The layout affects almost everything.
3. Is the CRM built on a framework (React/Vue) or standard HTML?
4. Is the OpenAI key yours and needs to be in the script, or is it okay to make the call through a proxy?
5. Is the delay of 20–45 seconds a fixed range or adjustable?

I am ready to discuss the details. Thank you! Expand

Budget: 6000 UAH Deadline: 4 days

I understood the logic: The Tampermonkey script should track the active dialogue by its ID, select the appropriate System Prompt, generate a response using gpt-4o-mini, and insert it into the input field with a random delay for naturalness.

How I will do it:
1. I will define the CRM selectors to read the dialogue ID and detect new messages (using MutationObserver).
2. I will create a separate settings window (GM_config or a custom panel) with a map of ID → prompt and a field for the API key.
3. I will connect the OpenAI call, insert the response into the input field, and add a delay of 20–45 seconds before sending.

I need a few screenshots of the CRM or access to clarify the selectors. The deadline is 3–4 days, and I am ready to start immediately.

Budget: 6000 UAH Deadline: 2 days

Hello!
I have experience in developing JavaScript scripts for browser automation, as well as integration with the OpenAI API. I have already worked with similar logic, where it is necessary to track changes on the page, process messages, and automatically perform subsequent actions.
I can implement: Determining the active dialogue ID; A separate convenient settings window for binding the ID to the System Prompt; Sending messages through the OpenAI API; Automatically filling in the response field and sending with a random delay of 20-45 seconds; Neat and stable operation of the Tampermonkey script.
I initially estimate the execution to take 2 days; I can provide a more accurate timeline after reviewing the CRM. If there is an opportunity to show the interface or provide a short video of the system in action, I will immediately suggest the optimal solution.
I would be happy to discuss the details and start working as soon as possible.

Budget: 6000 UAH Deadline: 6 days

Ready to develop a reliable Tampermonkey script that fully complies with the described logic and works without interfering with the existing CRM. I will implement clean and understandable code with the possibility of further expanding functionality, so that in the future it will be easy to add new IDs, change prompts, or connect other OpenAI models without rewriting the entire system. Special attention will be paid to the stability of the operation with the page, correct identification of the active dialogue, processing of new messages, and protection against duplicate requests. All settings will be moved to a separate convenient Tampermonkey interface, where the correspondence between IDs and System Prompts can be edited without changing the code. I will also implement secure integration with the OpenAI API, automatic request formation, response retrieval, its insertion into the input field, and sending with a random delay within a specified range for maximum natural operation. Before delivery, I will conduct complete testing of all scenarios, check the correctness of operation with different IDs, API error handling, repeated requests, and stability after page refresh. As a result, you will receive a ready tool that is easy to maintain, configure, and scale without the risk of disrupting the CRM operation.

Work plan:

Analysis of the CRM structure and the mechanism for obtaining the ID of the active dialogue.
Development of the Tampermonkey script.
Creation of a separate settings window for managing the correspondence between IDs and System Prompts.
Implementation of automatic tracking of new messages.
Integration with the OpenAI API via the gpt-4o-mini model.
Automatic insertion of the response into the input field.
Implementation of a random delay of 20-45 seconds before sending.
Protection against reprocessing messages and basic API error handling.
Comprehensive testing of all operational scenarios.
Delivery of the finished script and a brief setup instruction. Expand

Budget: 6000 UAH Deadline: 2 days

I wrote tampermonkey scripts for CRM, the logic here is clear. The key points I see are: stable reading of the active dialogue ID, a convenient settings window for the prompt map, and correct sending through the OpenAI API with a random delay of 20-45 seconds.

I have 3.5 years of commercial experience with TypeScript, I have a good understanding of browser APIs and working with external services via fetch/XHR. I will make the script cleanly: settings through GM_setValue/GM_getValue, a separate UI window for mapping IDs to prompts, error handling, and edge cases (for example, if the dialogue changes while we wait for a response).

The budget of 6000 UAH suits me. I am ready to start quickly, I just need access to the CRM page structure to understand the DOM.

Write to me, and we will agree on the details.

Budget: 5750 UAH Deadline: 4 days

Hello, Maksym.

The task is right in my profile: I have been working with browser automation, JavaScript, and OpenAI API for many years.

I will create a Tampermonkey script that identifies the ID of the active dialogue, selects a System Prompt for it, responds only to new messages, gets a response from gpt-4o-mini, and sends it with a delay of 20–45 seconds. I will move the ID → prompt map to a separate simple settings window. I will also add protection against duplicate responses and a clear error log.

To get started, I need test access to the CRM or an HTML fragment of the chat with examples of all IDs. After that, I will start immediately.

Budget: 6000 UAH Deadline: 3 days

Good day! We have experience in developing custom scripts for business process automation. We implement this through integration with the OpenAI API, ensuring correct reading of IDs and automatic insertion of responses into your CRM. We guarantee stable operation of the script and compliance with technical requirements.

Budget: 6000 UAH Deadline: 3 days

Ready to complete your job, all scripts will work, everything will really function.

Budget: 6000 UAH Deadline: 5 days

Maxime, the key here is to consistently capture the latest incoming message so that after the DOM update, the script does not create duplicate responses. I will create a userscript using MutationObserver: identifying the dialogue ID, selecting the system prompt, querying gpt-4o-mini, inserting the response, and sending it after a random delay of 20–45 seconds. In the separate settings, there will be a map of 5–10 IDs and prompts, an API key, script activation, and delay range; I will also add protection against duplicates and an error log. In my AI assistant for order processing, a similar logic is already implemented: receiving a message, generating a response according to instructions, and passing the result for further processing. The main risk is storing the OpenAI key directly in Tampermonkey, so it is safer to move the request to a small proxy. The cost is 6000 UAH, and the timeline is 5 days after receiving test access or HTML fragments of the required CRM elements. Is a small proxy acceptable for hiding the API key, or should the call go exclusively directly from Tampermonkey?

Budget: 6000 UAH Deadline: 3 days

Ready to take on the script. I see the essence: Tampermonkey, reading the dialogue ID, a map of prompts in the settings, calling gpt-4o-mini, and sending with a human delay.

The main nuance here is not the OpenAI API itself, but stable tracking of the DOM of your CRM.

I will do it through MutationObserver — without constant polling of the page, without unnecessary CPU load. I will add protection against duplication: the script remembers the hash of the processed message, so there will be only one response for each message.

⚙️ What is included in the work:
Reading the unique ID of the active dialogue from the page
A separate settings window with a map "ID → System Prompt" — you will be able to edit instructions for each of the 5–10 dialogues without my involvement
Saving the OpenAI key and settings locally via GM_setValue
Calling gpt-4o-mini with the message text and the associated prompt
Inserting the response into the input field and sending it with a random pause of 20–45 seconds

One point that can easily be missed: while the script waits its 20–45 seconds, the interlocutor may write something else. Therefore, before sending, I check if any new messages have appeared — and I either supplement the context or cancel the outdated queue. This saves from sending irrelevant responses.

After delivery, I won't disappear — I will stay in touch, helping with adjustments if the CRM updates the interface and the selectors change. I am currently completely free, starting today. Write to me — and I will outline the plan for the first stage. Expand

Budget: 5750 UAH Deadline: 4 days

Good day, Maksym.
I have reviewed the task. The main risk here is not the OpenAI API call itself, but the stable identification of a new message without repeated responses and checking that during the delay the operator has not switched to another dialogue.
I will implement a Tampermonkey script with the following logic:
— identification of the active dialogue ID from the DOM or URL;
— a separate settings panel for ID → System Prompt;
— the ability to edit prompts, model, and parameters independently without changes in the code;
— tracking new messages through MutationObserver, without constant polling;
— protection against double processing of a single message;
— a queue of requests to prevent multiple messages from triggering parallel responses;
— a re-check of the active dialogue and new messages before sending;
— a random delay of 20–45 seconds;
— a pause button and a preview mode for the response before automatic sending;
— handling timeouts, API errors, and the absence of the required prompt.
I will not hardcode the API key directly in the code. If necessary, I will create a small proxy so that the key is not accessible from the CRM page or the userscript source code.

Before starting, I need test access to the CRM or DOM snapshots of the active dialogue, new message, input field, and send button. It is also necessary to clarify whether the CRM switches dialogues without reloading the page. Expand

Budget: 6000 UAH Deadline: 3 days

Maxime, there is a moment in the timing of sending that is easy to miss. While the script waits for a random 20-45 seconds, the client may manage to write another message, and the script will send an outdated response. Therefore, before sending, I check for new incoming messages during the waiting time and either add them to the context or cancel the queue.

I read the dialogue ID through MutationObserver on the chat container. I move the map of IDs and System Prompt to a separate settings window with GM_setValue, the OpenAI key is also there without hardcoding. The skeleton of the script is ready to be shared privately before the start, so they can see the logic live. 6000 UAH, 3 days from the moment of access to the CRM. And also: while the response is being prepared, does the chat show the client the status of "operator typing," or is it just a simple field without indicators?

Budget: 6000 UAH Deadline: 2 days

Good day.
I have worked with the OpenAI API, using Playwright and Puppeteer for browser automation.
I would like to clarify where the prompts will be stored?
I would appreciate your cooperation.

Budget: 6000 UAH Deadline: 5 days

Hello! I have carefully studied your task regarding CRM automation. The project is completely clear to me, and the technology stack is familiar.

Here’s what you will receive as a result of our collaboration:

100% imitation of a real operator: The script will work as "human-like" as possible. In addition to random pauses of 20–45 seconds, the system will fully replicate human behavior — it will imitate real typing on the keyboard. For the CRM, it will appear as if the operator is typing the response manually.

Stability without page blocking: I will configure a bypass for the CRM's security system limitations. Requests to the artificial intelligence will go through a secure extension channel, so the system will not block operations or create failures.

Easy management without a programmer: You will receive a simple, neat settings window right in your browser. You will be able to replace the API key or edit instructions (prompts) for any of the 10 types of dialogues by yourself in just 1 minute.

Budget: 6000 UAH Deadline: 2 days

Hello! Maxim Shulha
The script will automatically insert the AI response into the input field and send it after a random delay of 20 to 45 seconds.
I will save the mapping of the identifier with the request on a separate settings panel of the script for easy editing without making changes to the code.
I have experience integrating the OpenAI API, observing the DOM for new messages, and simulating human behavior while typing and sending.
The solution will work exclusively with text, reliably handle multiple dialog windows, and include error handling in case of API failures.
I can provide a fully functional script within 2 days for your budget of 6000 hryvnias.
Let me know if you need any adjustments or if you have specific CRM selectors in mind.

Budget: 6000 UAH Deadline: 7 days

Good day!

I have experience in developing JavaScript scripts for Tampermonkey, browser automation, working with the OpenAI API, and integrating with internal CRM systems.

I can implement all the necessary functionality:

* automatic identification of the active dialogue ID;
* a separate convenient Tampermonkey settings menu for binding IDs to the corresponding System Prompts;
* tracking new messages in the chat via MutationObserver;
* integration with the OpenAI API (gpt-4o-mini);
* automatic filling of the response field;
* sending messages with a random delay of 20–45 seconds;
* handling API errors, retries, and logging for convenient diagnostics.

The code will be structured, well-commented, and easily extendable in case of new IDs or changes in CRM logic.

I am ready to start immediately after gaining access or receiving a sample CRM page. After familiarizing myself with the DOM structure, I will be able to quickly assess the timeline and implement the script in full. Expand

Budget: 6000 UAH Deadline: 4 days

Hello, Maksym. The main risk here is not the OpenAI API, but double responses due to DOM mutations and the leakage of the API key from the userscript. Therefore, I will create one MutationObserver with deduplication of message ID/hash, debounce, and a single-flight queue, and I will keep the key on a minimal backend/serverless proxy, not in the Tampermonkey code.

For 5–10 IDs, I will create a separate settings panel ID → System Prompt with JSON import/export. When a new message arrives, the script finds the active ID, selects the prompt, gets the response, inserts it into the input, and waits for 20–45 seconds. Before sending, it rechecks that the dialogue has not changed. I will add pause, status, and review before send mode so that the automation can be safely checked before auto-sending.

Before starting, I need a test account/a copy of the CRM or DOM snapshots of the dialogue, a way to determine the ID, and selectors for the new message/input/send. Access and OpenAI key will be provided only after reserving the Safe; the key will be stored only in the proxy.

Estimate: 6000 UAH, 4 days. I will provide the userscript, proxy template, settings, README, smoke tests, and verification of the key scenario.

Budget: 6000 UAH Deadline: 3 days

Hello, Maxim!
I can help you with the project, I have experience and a portfolio.
I have had similar orders before, I made tampermonkey scripts for automating actions on cryptocurrency exchanges. I also have experience working with the OpenAI API.
I will complete this order with high quality.
Write to me, I will be happy to help!

Budget: 6000 UAH Deadline: 1 day

Hello! I will complete your task quickly and efficiently.

My recent works
https://indexfast.pro - fast website indexing
https://mono-bank.pp.ua - everything about Monobank
https://mamamia.pp.ua - online store
https://programist.pp.ua/ua/portfolio/ - portfolio of works
https://monitortest.pp.ua - monitor testing
https://keytest.pp.ua - keyboard testing
https://pctest.pp.ua - computer testing
https://devroman.dev/portfolio/ - portfolio
https://vseetut.matviy.pp.ua - layout
https://indexfast.pp.ua - fast website indexing

My portfolio: https://freelancehunt.com/ua/freelancer/romas6ka.html#portfolio
Write to me, I will start working today. I will be glad to collaborate with you! Expand

Budget: 6000 UAH Deadline: 1 day

Good day! I have relevant experience, so I am ready to complete the task you set with high quality!!! Feel free to contact me!!!

Budget: 6000 UAH Deadline: 1 day

Hello, Maksym! I am happy to develop a reliable, optimized, and user-friendly Tampermonkey script for automating responses in your CRM.

I have extensive experience with JavaScript/TypeScript, understand the architecture of the DOM tree, and the specifics of working with the OpenAI API.

I propose the following architectural and technical solution for your task:

1. Optimal message tracking (MutationObserver):
The script will not burden the processor with constant checks. I will set up a MutationObserver that will monitor the dialogue container and trigger instantly only when a new incoming message appears in the DOM tree.

2. Secure requests without CORS (GM_xmlhttpRequest):
To bypass the browser's security policy (CORS) for direct requests to OpenAI, I will use the built-in Tampermonkey function — GM_xmlhttpRequest. This ensures stable communication with the gpt-4o-mini model directly from your CRM.

3. Convenient settings interface (UI):
I will create a neat floating modal settings window right in your CRM interface. You will be able to conveniently enter your API key and configure the mapping: [Text ID of the dialogue] -> [Individual System Prompt].

4. Reliable data storage (GM_setValue / GM_getValue):
All your prompts and API key will be securely stored in the local memory of the extension. The settings will not be lost when the page is refreshed or the browser is restarted.

5. Human emulation (Event Dispatching):
To prevent the CRM's protection system from recognizing the autofill, the script will not just insert text but will programmatically generate artificial input events (InputEvent, ChangeEvent), after which it will execute the submission with a random delay in the range of 20-45 seconds.

Working conditions:
• Cost: 6000 UAH.
• Deadline: 3 days (including the testing phase and calibration of selectors for your CRM).

I am ready to start discussing the structure of your chat and the implementation of the script today. I look forward to collaborating! Expand

Budget: 6000 UAH Deadline: 2 days

Good day.
I am ready to create a Tampermonkey script for your internal CRM with a budget of 6000 UAH.
Portfolio: https://gooru-lab.github.io/portfolio/
Relevant experience: integrations with OpenAI API (including production bots with prompts/tools), browser automation, and working with DOM.
What I will do:
• read the ID of the active dialogue (5–10 options) from the CRM page;
• a separate convenient settings window: map ID → System Prompt (+ API key, model gpt-4o-mini);
• react to a new message in the chat → request to OpenAI (text + prompt);
• insert the response into the input field and send it with a random delay of 20–45 seconds;
• text only; basic error handling for API (log to console / notification, without crashing the page).
To start, I need: access/screenshots of the CRM (where the dialogue ID is, where the chat and input field are) or a test account. Deadline: 2–4 days after access to the markup. Expand

Budget: 6000 UAH Deadline: 3 days

Good day!

The technical task is clear — a Tampermonkey script, reading the dialogue ID, a map of system prompts in the settings window, calling the OpenAI API (gpt-4o-mini), inserting the response into the input field. I have experience with similar integrations (several microservices with OpenAI/LLM API).

Before assessing, I would like to clarify one point regarding the logic: who are these responses intended for — is it internal communication with colleagues/leaders of the company, or dialogues with external clients/users of the platform? I ask because a delay of 20-45 seconds "to simulate the natural work of an operator" reads as an attempt to conceal automation from the interlocutor — if this is indeed the case, I would like to understand the context before starting the implementation.

If this is a transparent internal tool to speed up the work of operators (the company is aware, used legally) — I am ready to discuss the timeline and budget.

Budget: 6000 UAH Deadline: 6 days

Good day! I would create a special extension tailored specifically to your needs and for the CRM. Why modify someone else's code (to which you don't have full access) when it's simpler and more effective to create your own extension? You will have your own tool that won't depend on a third party. The budget will not change.

Budget: 6000 UAH Deadline: 3 days

Hello, have you already decided how the settings window for the ID map and instructions should look? I will agree on more precise terms and budget in personal correspondence.

1. I will implement reading the dialogue ID from the DOM of the page and storing the ID-instructions map in a separate Tampermonkey settings window.
2. I will set up tracking new messages through MutationObserver and sending the text with a prompt to the OpenAI API.
3. I will add a random delay of 20-45 seconds before inserting the response into the input field and automatically sending it.

Thank you for considering my proposal. I look forward to the opportunity to work with you!

Budget: 6000 UAH Deadline: 6 days

Good day, Maksym.

The key issue here is not calling the OpenAI API, but the stability of selectors in the internal CRM — any interface update will break the binding to the dialogue ID. Your script will receive resilient selectors with fallback logic, a settings window via GM_setValue for the prompt map by ID, and a jitter delay of 20–45 seconds instead of uniform random — anti-bot systems detect equal intervals instantly. Requests to gpt-4o-mini will go through your API key, stored in the Tampermonkey storage.

Options:

≈4 days: 3200–4000 UAH
Minimum functional script for automating responses.
- Automatic reading of messages and sending via OpenAI API
- Hardcoded prompts in the code (without a settings window)
- Basic simulation of sending delay
- Installation instructions and API key connection

or

≈7 days: 5500–8500 UAH
Full functionality with flexible prompt management and reliable operator simulation.
- Convenient settings window for managing the ID map and System Prompts
- Complete automation of the cycle: reading → generation → sending
- Randomized delays (20–45 sec) to minimize the risk of blocking
- Optimized work with CRM DOM elements for stability
- 2 weeks of free support in case of minor changes in the CRM interface

+additionally

≈3 days: 2500–4500 UAH
Advanced solution with enhanced detection protection and additional functionality.
- Advanced simulation system (simulating text input in the input field)
- Error and request logging in the console for quick diagnostics
- Support for multiple OpenAI models (ability to switch between gpt-4o and gpt-4o-mini)
- Extended support period and guarantee of adaptation to CRM updates within a month Expand

Budget: 6000 UAH Deadline: 2 days

Good day. I am engaged in automation. I am ready to implement this user script turnkey.

During development, I will focus on the stability of your system and security:

- Confidentiality: all settings, prompt mapping, and your OpenAI API key will be stored exclusively locally in your browser (GM_setValue). No third-party servers or risk of CRM data leakage.
- Asynchronicity: I will integrate with the API through background requests of the extension. The CRM system will not freeze while waiting for a response from OpenAI.
- Error Handling: if OpenAI temporarily does not respond or limits are exhausted, the script will not break the page but will gently highlight the input for the operator, signaling the need for manual entry.
- Convenient config interface: a settings window for mapping IDs and prompts.

I am ready to start today. Please let me know how you prefer to provide information about the page structure for setting up selectors: can you give test access to the CRM or send screenshots/HTML code? Write in private messages, and we will discuss the details.

Budget: 6500 UAH Deadline: 4 days

1) I will analyze the structure of the CRM and determine how to obtain the ID of the active dialogue and track the appearance of new messages.
2) I will implement a Tampermonkey script with a separate settings window where each ID can be linked to its own System Prompt without editing the code.
3) I will set up integration with the OpenAI API (gpt-4o-mini) so that each new message is automatically processed with the corresponding prompt.
4) I will implement automatic filling of the response field and sending a message with a random delay of 20–45 seconds.
5) I will add error handling, protection against reprocessing the same message, and test the script's operation in the CRM.

The most important aspect of such a project is to make the script resilient to DOM changes and ensure convenient prompt configuration without the need to modify the code. This will significantly simplify future maintenance.

I have experience with JavaScript, browser automation, and OpenAI API integration. I am ready to discuss the details of the CRM and propose an optimal implementation.

Budget: 6000 UAH Deadline: 3 days

I need a Tampermonkey script that automatically responds in the CRM chat using GPT-4o-mini, selecting the system prompt based on the dialogue ID.

Here's how I'll do it: A MutationObserver on the chat DOM detects a new incoming message, reads the active dialogue ID, and retrieves the corresponding system prompt from GM_getValue. The request to the OpenAI API is made via GM_xmlhttpRequest (bypassing CORS without a server-side component). The response is inserted into the input field via an input event (so the CRM "sees" the change), and submission is initiated with a random delay of 20-45 seconds using setTimeout. The ID -> prompt map is edited in a convenient modal settings window with a Save button.

Key risk: if the CRM uses React/Vue, direct assignment of value will not work; we need to use nativeInputValueSetter through Object.getOwnPropertyDescriptor, keeping this in mind from the start.

What framework is the CRM built on, and is there a way to briefly show the structure of the input field's DOM?

Budget: 6000 UAH Deadline: 2 days

Hello. The described logic of mapping the dialogue ID to the system prompt is something I have already implemented in similar scenarios. Question: how exactly do you track the appearance of a new message in the chat - through MutationObserver, polling, or an event? This affects the architecture of the script. After the release, I will remain available for support with minor adjustments.

Budget: 6000 UAH Deadline: 4 days

Good day. I will develop a Tampermonkey script for automating responses in the internal CRM via the OpenAI API.

The script will identify the active dialogue, retrieve the appropriate prompt from the settings, and respond only to new incoming messages. I will add protection against reprocessing, parallel requests, and accidental duplication of responses, as well as timeouts, an error log, and a customizable delay before sending.

The API key and the mapping of dialogue IDs to prompts will be placed in separate settings without hardcoding in the code. I will provide the finished script and a brief instruction.

The cost is 6,000 UAH. The deadline is up to 4 calendar days. To get started, I need test access to the CRM or examples of the HTML structure of the page.

Budget: 6000 UAH Deadline: 5 days

Good day!

I am a full-stack developer. Stack: Next.js, TypeScript, React, Node.js, Python, PostgreSQL/Prisma.

What I can do for you:
— websites and landing pages turnkey from Figma designs, responsive and SEO;
— online stores with integrations: CRM, Nova Poshta, online payments, product feeds;
— Telegram bots and Mini Apps (grammY, aiogram);
— AI integrations: chatbots, RAG agents based on your materials, Claude/OpenAI API;
— automation and parsing in Python (Playwright), working with APIs;
— WebGL / Three.js — interactive 3D scenes and shader animation;
— deployment and server setup: Docker, Nginx, SSL, backups, monitoring.

The code and access will be completely yours after completion. I work through Safe, in phases with clear deadlines and transparent communication. Languages: Ukrainian, Russian, English.

Please write the details of the task — I will provide an estimate and timeline and send examples of my work. Expand

Budget: 5800 UAH Deadline: 6 days

Hello.

I will handle the development of a Tampermonkey script for your CRM system and the integration with the OpenAI API. Write to me, we will discuss the details and I will start immediately.

Budget: 6000 UAH Deadline: 5 days

Hello, Maxim.
I have done similar projects — I know the nuances and will do exactly what is described. There are a few clarifications before starting.
The final price/timeframe after all clarifications.

Profile: Freelancehunt
Reviews: Freelancehunt

Budget: 10000 UAH Deadline: 5 days

Good day. I have created a similar extension for OnlyFans. I can implement it without any problems in a few days. I will need access to the dashboard and text accounts.

Budget: 5999 UAH Deadline: 1 day

Good day! I have experience in developing JavaScript solutions, browser automation, and working with the OpenAI API. I am ready to quickly and efficiently complete the task, taking into account all requests and creating a convenient solution for future use. I can start today, feel free to message me privately.

Budget: 6000 UAH Deadline: 4 days

I will create a Tampermonkey script: MutationObserver monitors new messages in the chat, reads the dialogue ID, pulls the System Prompt from the map in a separate settings window, sends a request to gpt-4o-mini, inserts the response into the input field, and sends it with a random delay of 20–45 seconds. Ready in 4 days.

Budget: 6000 UAH Deadline: 3 days

Can I get access to the CRM test account to view the chat DOM and input fields in order to correctly read the dialogue ID and catch new messages via MutationObserver? I understand the logic: the System Prompt is taken from the map by ID, the text goes to OpenAI gpt-4o-mini, the response is inserted into the input field, and sent with a random delay of 20–45 seconds. I will move the ID→prompt map to a separate settings window (GM_setValue). I am ready to deliver in 3 days.

Budget: 6000 UAH Deadline: 4 days

Maxim, to automate responses in the CRM, it is necessary to correctly intercept the DOM update event in the chat and set up the proper context transmission through the OpenAI API, while maintaining the specified delay to simulate a human. I will implement a separate settings interface for mapping dialog IDs with prompts and configure a mechanism for processing incoming messages with a random sending delay. Please let me know if your CRM has any specific protective mechanisms or anti-fraud systems that might block the automatic insertion of text into the input field?