Categorization of income/expenses from bank statement (LLM model)

Budget: 25000 UAH Deadline: 10 days

Experience in developing modules for integrating external models and APIs, including setting up local ML/LLM solutions, allows for effectively building your categorization system. Considering the requirements for speed (up to 2 seconds for 100 transactions) and strictness of responses — I recommend implementing a caching layer and processing requests in batches.

I can help organize the processing of incoming JSON and generate output with categories based on a given list. For local LLM, lightweight models can be used optimized for your task, or external services can be connected with clear cost control.

Given that the project is in Python, I can provide an API (for example, REST) with PHP or Laravel for receiving and sending data, if needed for further integration. My experience includes working with REST APIs, Docker for environment isolation, Git, MySQL/PostgreSQL, which will assist in scaling and maintaining the project.

I can also help with setting up rapid recognition and adaptation for new banks by building a rule template system and parsing that will complement the categorization.

I am ready to start a technical discussion of the details to accurately implement the requirements for speed, accuracy, and scalability.

Budget: 2000 UAH Deadline: 14 days

I made such a solution for myself - analysis of financial data by month. I can implement it for you according to your request and requirements.

Budget: 7497 UAH Deadline: 7 days

Вітаю! Подивився output.json — важливі моменти:
Блок heuristic зі status: ok, changes_count: 0 — у вас вже є робочий rule-based layer, який сходиться з category. Задача не будувати класифікатор з нуля, а додати LLM-fallback для ambiguous cases.

У description_raw вбудовані MCC-коди (5411, 5814, 5541, 5912) — 70-80% транзакцій класифікуються через ISO 18245 без LLM. Але MCC = сигнал, не істина: ABTS BARTOLILLOS має MCC 5422 (meat/butcher), а у вас Entertainment — потрібна перевірка по merchant name.

Реальний список — 16+ категорій, не 12. Restaurants ≠ Food, P2P self, Subscriptions, Cash withdrawal.
Архітектура: MCC → heuristic → LLM тільки для low-confidence → cache. $0.001/100tx при 85% coverage без LLM.Я новий на Freelancehunt, щоденно пишу з LLM у проді (StratBase.ai).

Budget: 3000 UAH Deadline: 4 days

Hello, I am looking forward to the opportunity to implement a project for categorizing income and expenses from bank statements using a large language model (LLM). I am confident in my ability to complete this task, as I have experience with similar projects and know how to create an effective categorization system. To implement this project, I will use natural language processing tools, such as TensorFlow or PyTorch libraries, to develop and train the LLM on existing data, ensuring a high level of categorization accuracy. Additionally, I will pay special attention to the data preprocessing stages, such as normalizing text data, to improve the quality of the resulting model.

Budget: 11000 UAH Deadline: 7 days

Good day.
I am ready to take your project to work.
I can develop such automation for you for categorizing statements using n8n.
Write to me privately, we will discuss all the nuances and can start the implementation.

Budget: 1000 UAH Deadline: 1 day

Hello! We are the NovaCore Solutions team. We have significant experience in developing fintech solutions and banking transaction processing systems. We specialize in creating high-performance modules for structuring financial data and categorizing it using LLM. For your request, we can offer an optimized solution based on local models (for example, Llama architecture or BERT-like models fine-tuned for classification), which will ensure the necessary speed (up to 2 seconds for 100 transactions), strict validation of responses, and minimal cost. Since we have already implemented large-scale CRM systems with financial modules, we understand the specifics of working with various banking formats and can build a universal parser for quickly adding new banks. We are ready to discuss the technical details and architecture of the module.

Budget: 15000 UAH Deadline: 8 days

Kostyantyn looked at example.json — 232 transactions from Banamex, Spanish merchant lines (OXXO, DIDI, FARMACIA SIMI), RFC codes in description_raw, the category field is already filled ("Medical" in the first entry). The task is not just a call to LLM — a stable module under 4 constraints: valid output structure, 50 tx/sec, $0.005/100 tx, 30+ banks.

I have working code on Ollama with structured data extraction through JSON schema — the mechanics are close to your task.

Under your 7 points:

1. Input — your JSON without changes to the structure.
2. Module — categorize(transactions) -> list[dict] Python with type hints, integrates into the existing project without heavy dependencies.
3. LLM — hybrid: regex layer covers obvious markers (NOMINA → Salary, SPEI → P2P, OXXO → Food, etc.), LLM processes ambiguous cases. According to the public price on 17.04.2026: Gemini 2.5 Flash ~$0.002/100 tx, GPT-4o-mini ~$0.003/100 tx — both within your limit of $0.005. Batch API (50% discount) — if it can process in batches with a delay of up to 24 hours, otherwise sync rates are higher. Local Llama 3.1 8B via Ollama — an option, but on consumer Macs it realistically handles 1-3 tx/sec, not 50. So for pure local deploy with your speed, a GPU server with vLLM is needed, or regex covers 95%+ of traffic and LLM processes only 1-5 tx/100 — then locally it’s fine.
4. Output stability — JSON schema through Instructor or Outlines + temperature=0. This provides a valid format and very low variability. 100% determinism is impossible with any LLM provider (GPU reduction order, known Ollama issue #5321), so I will add an evaluation report on the stability of repeated runs on your data.
5. Speed 100 tx / 2 sec — achieved through 20-50 parallel async calls to Gemini Flash / GPT-4o-mini. Locally without GPU — through regex-first architecture.
6. Output — your JSON, the category field is overwritten with the value from the list + I add confidence per tx + evaluation report on the run across the entire file.
7. 30 banks — bank-agnostic prompt based on description_normalized + config merchant→category (YAML/JSON). Adding a new bank — lines in config, no code changes. Your JSON is already unified — no major rewrites are needed.

One clarification: do you want to improve the existing categorization (there is already "Medical" in the example) or redo it from scratch? This changes the priorities — when improving, it is necessary to compare with the baseline and not spoil the existing one. Expand

Budget: 12000 UAH Deadline: 5 days

Hello
Example of my AI interface implementation:
https://217-154-170-186.nip.io/
my technical solution for the project:
Local LLM (Speed & Privacy): To meet the timing of < 2 seconds, I suggest using the local model Phi-3-mini or Llama-3-8B, deployed via vLLM or Ollama. This will provide zero transaction cost and instant batch processing.

Strict format (JSON Guard): To prevent the model from "fantasizing," I use the Instructor or Outlines library. This ensures that the output will only be valid JSON and only categories from your list (Enum).

Cost optimization: If we choose an external API, then GPT-4o-mini will cost about $0.0007 for 100 transactions, which is 7 times cheaper than your limit ($0.005).

Versatility for 30+ banks: LLM works with the semantics of the text (description), so we do not need to write regular expressions for each bank. It is enough to provide a cleaned description field and MCC code.
GIT: https://github.com/onyx144 Expand

Budget: 10000 UAH Deadline: 1 day

✋ Hello! We are the IT company dZENcode.

We can develop a transaction categorization module for you for this task.

Do you have examples of transactions and the required categories for training?
Should we immediately include settings for new banks?

You can find detailed information about our services and rates on our website: Freelancehunt
Take a look – we will discuss the details of the work further, write when you are ready.

The final cost is determined only after clarifying the volume and requirements.

___________________
Best regards,
Manager dZENcode

Our strengths:
💎 10+ years providing IT services: Outsourcing, Outstaffing
🔥 90+ in-house specialists
🚀 Projects "from scratch" and for support
⚙️ SLA and post-production support
✅ Contract with the company, guaranteed results!
🔥 250+ public reviews since 2015. Expand

Budget: 8000 UAH Deadline: 7 days

Hello, I have worked with file parsers, and I already have a ready script. I suggest not doing everything through LLM, as it can hallucinate and provide false answers. Contact me personally, I will complete everything efficiently, quickly, and within your budget.

Budget: 11000 UAH Deadline: 6 days

Hello.

I reviewed your JSON and see that what is needed here is not just an LLM call, but a stable hybrid categorization module. There is a lot of noise in the data: 232 transactions, 217 unique raw descriptions, Spanish merchant strings, RFC, technical codes, various banks, and a strong skew in categories. Therefore, pure generation without an intermediate layer will be unstable.

For this case, I would gather the solution as follows:
- first, normalization of description_raw and bank-specific mapping fields
- next, a rule layer for obvious patterns and recurring merchants
- primary categorization through fastText as a deterministic fast classifier
- Qwen/Qwen2.5-3B-Instruct as a fallback for disputed or low-confidence transactions
- output only in strict JSON with a list of allowed categories

This approach provides the needed speed, as fastText works well on a regular CPU and is suitable for batch processing. For 100 transactions, up to 2 seconds is a more realistic path than doing everything through pure LLM. I would use Qwen2.5-3B-Instruct only where the rules and classifier do not provide a confident result, to maintain stability and control over categories.

Before starting work, I need to clarify:
- an example of the input JSON in full format
- the final list of categories
- whether there is a labeled set of transactions for quality checking
- which banks are critical for the first batch

I will personally answer all questions, and I can create a PoC on your JSON and show the accuracy, speed, and stability of the hybrid scheme before full implementation. Expand

Budget: 2000 UAH Deadline: 2 days

Good day, in general, this can be done without LLM, it is also possible to combine - code + LLM.

Budget: 10000 UAH Deadline: 1 day

Hello! I can implement it. Write to me privately to discuss all the details. I will be glad to cooperate!

Budget: 10000 UAH Deadline: 5 days

Good afternoon
Judging by the attached json, it will be necessary either to fine-tune the model or to train your own from scratch, since in many statements the purpose of the payment is unclear.
For classification, it is better in this case to choose not llm, but bert or embedding model.

Budget: 14000 UAH Deadline: 5 days

Hello, Konstantin! I am Nina, the manager of engineer Valentin.

We have thoroughly analyzed your example JSON with transactions from Banamex bank. We see the specifics of the data: Spanish descriptions of merchants (OXXO, DIDI, SIMI), the presence of tax identification numbers (RFC), and the need for mapping to your strict list of categories.

Our solution for your Python module:

Intelligent Pre-processing: Before sending to the LLM, the module will automatically clean the description_raw from technical codes and RFC. This is critical to stay within the budget of < $0.005, as it reduces the token volume by 3 times.

Semantic cache (L1/L2): We will implement a knowledge base for your transactions. If "DIDI FOOD" has already been encountered, the category will be assigned in 5 ms without calling AI. This guarantees a speed of 100 transactions / < 1 second.

Determinism through Pydantic: The model will operate in Structured Output mode. We will strictly limit it to your list (Salary, Telecom, Auto, etc.). There will be no options for "creativity" physically.

Batch API: For new transactions, we will use batch processing, which fits within the limit of $0.001 for 100 lines.

Deadline: 5–7 days.
Budget: 14,000 UAH.

Konstantin, we have already prepared a parser prototype for your format. We are ready to demonstrate accuracy on an extended dataset.

Best regards, Nina. Expand

Budget: 18000 UAH Deadline: 14 days

Hello! I have worked with similar tasks — in particular, I implemented a fraud transaction detection system, which is a significantly more complex task than categorization. Therefore, I immediately see several pitfalls here. LLM in production will not work stably within your requirements — latency is unpredictable, and costs are hard to control when scaling.

I would build it differently:

The foundation — a trained FastText classifier, not LLM:
- Inference ~0.1 sec for 100 transactions (20 times faster than your requirement)
- Cost after training: $0
Training data — we label 3–5k transactions through GPT-4o-mini Batch API (~$0.10 one-time), train the model, then it works autonomously.
LLM remains only as a fallback for low-confidence transactions — where the classifier is not confident.
Support for 30+ banks — through config files per bank for field mapping. A new bank can be connected without changing the logic of the classifier.
I suggest discussing the details of collaboration in private messages. Expand

Budget: 12000 UAH Deadline: 10 days

Hello! I propose to implement a classification module based on an ensemble of LightGBM, XGBoost, and CatBoost models. This solution is better suited for this task as it provides high processing speed even on a regular CPU and stable, predictable results.

I have 4 years of experience in Python development and creating data analysis systems, so I will be able to build a flexible architecture with the capability for rapid scaling and adding new banks. The module will operate completely locally and will strictly adhere to the specified categories and JSON format.

I suggest discussing the details of the technical assignment, and I will be happy to collaborate!

Budget: 18500 UAH Deadline: 9 days

Hello.

I have reviewed the example file. The task format is clear: it requires not just a call to an LLM, but a neat Python module that reliably accepts bank JSON, normalizes transactions, and returns strictly valid JSON with categorization within a specified list.

From the example, it is evident that it is important to maintain predictability of the result, a rigid response structure, high processing speed, and the ability to scale the solution for different banks without reworking the entire logic.

I would implement this as a reliable module with several levels of processing:
— receiving and validating the input JSON
— normalizing transaction descriptions
— categorizing into fixed categories
— strict JSON output
— logic that can be quickly adapted for new banks
— optimization for speed and cost of processing

In such tasks, I focus not on the "free response of the model," but on a controlled and practically applicable result that can be integrated into the product without surprises.

I am ready to review the final requirements for the input format and immediately propose an optimal implementation architecture. Expand

Budget: 15000 UAH Deadline: 7 days

Hello! I am the founder of the engineering agency Vaysed.
We build ecosystems where artificial intelligence operates under the strict control of deterministic algorithms. I have analyzed the provided file, which includes transactions from the Banamex bank, the field description_raw, and typical merchants like OXXO or DIDI FOOD. The task perfectly fits our profile.

Processing 100 transactions through LLM in 2 seconds "head-on" with a budget of < $0.005 is an engineering challenge that cannot be solved simply by writing a prompt. Here’s how we guarantee the claimed speed and strict output format:
Semantic cache instead of LLM: Most user transactions are regularly repeated. We implement an intermediate database layer (Redis + PostgreSQL). If the system already knows the merchant, the category is assigned instantly (within 5-10 milliseconds) without any call to the neural network. This reduces the processing cost of 80% of the array to zero.
Batching and deterministic parsing: For new transactions (e.g., unknown P2P transfers), our Python module will generate batch requests. To ensure absolute rigidity of responses (requirement #4), we will apply structural output libraries (Outlines or Instructor). The model at the token generation level will be limited to your list (Salary, Telecom, etc.) and physically will not be able to produce hallucinations or deviations from the format.
Universal adapter: The module will normalize the input array regardless of the bank's structure, pass the cleaned data to the categorization engine, and return the final JSON.

As for the model, we can deploy a local optimized version (based on vLLM for ultra-fast inference) or use gpt-4o-mini in batch mode, which comfortably fits within your financial limit.

We create reliable data architectures and enterprise-level microservices. You can evaluate our engineering approach and implemented cases in the portfolio: https://vaysed.me/

Write to me, and we will agree on the architecture of the module and the deployment timeline! Expand

Budget: 10000 UAH Deadline: 14 days

For this task, a small local model like Llama 3 or Mistral, run through vLLM or Ollama, is the best fit — this is the only way to stay within your budget limit and deliver results faster than 2 seconds. I will implement a module using Structured Output (through Instructor or Outlines) to ensure that the output is always valid JSON with strict categories without unnecessary "junk." I will base the architecture on abstract parsers: this will allow for quickly connecting new banks by simply describing the field mapping without rewriting the classifier logic. I will be available even after delivery if fine-tuning accuracy on specific transactions is needed.