# Argentina COMPR.AR Contract Awards - Per Award (`nexgensignal/ar-comprar-award-records`) Actor

Argentina COMPR.AR federal contract awards (all years) as clean per-record data - procedure, executing unit, award date, supplier organisation, amount. Natural-person (CUIT 20/23/24/27) suppliers dropped. CC BY 4.0. $0.05 per record.

- **URL**: https://apify.com/nexgensignal/ar-comprar-award-records.md
- **Developed by:** [NexGen Signal](https://apify.com/nexgensignal) (community)
- **Categories:** Business, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $33.50 / 1,000 award records

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Argentina COMPR.AR Contract Awards - Per Award

Who won Argentine federal contracts - the **COMPR.AR** award records (adjudicaciones) across all published years
as clean, per-award records. Procedure, executing unit, award date, supplier organisation, contract document and
amount. **Natural-person suppliers are dropped; only organisation suppliers are delivered.**

### What one record represents

The source is **COMPR.AR** (Sistema de Contrataciones Electronicas), Argentina's federal e-procurement system,
published as yearly CSV extracts on `infra.datos.gob.ar`. Each record is **one award document**: the procedure
number, executing unit and organisational codes, the procedure type and modality, the award date, the supplier
(CUIT and organisation name), the contract document, the amount and currency, and the operation type.

### Coverage and volume, and the person guard

This is the defining property of the cell. In Argentina, a CUIT beginning **20, 23, 24 or 27 identifies a
natural person**; 30/33/34 and other prefixes identify organisations. Award rows whose supplier CUIT is a
natural-person prefix are **structurally dropped at ingest** - a row-level guard removes them before delivery,
verified with a planted-person-CUIT test - so only **organisation suppliers** are delivered, with their
organisation name.

The live all-years award total is about **92,898 rows**; after the natural-person rows are removed, the delivered
count is the organisation-supplier subset (roughly two thirds).

**Sol's Wave-4 index put this door at 205,299 awards; measured live at build time the published all-years
extracts total about 92,898 award rows before the person-CUIT drop - the live figure is what this listing
quotes, and the delivered set is the organisation-supplier subset.**

### Licence and attribution

The data is published under **CC BY 4.0**. The full notice travels on every record:

> Argentina open data (datos.gob.ar), CC BY 4.0. Reproduced unchanged with attribution to the source. Supplier rows whose CUIT is a natural-person prefix (20/23/24/27) are dropped; only organisation suppliers are delivered.

### Person-data policy

Beyond the CUIT person-prefix drop, the delivered fields are all procurement and organisation attributes - the
supplier is an organisation name, and the executing unit is a government body. A per-record row guard removes
person-CUIT rows before any is delivered. No natural-person supplier is processed.

### Interpretation caveat

One record per Argentine federal contract award across all published years: procedure, executing unit, award date, supplier organisation (CUIT + name), contract document, amount and currency. Award rows whose supplier CUIT begins 20/23/24/27 (natural persons) are structurally dropped; only organisation suppliers are delivered.

Values are reproduced verbatim from the extracts; the Actor never rewrites a field. The amount is kept as the
source's own verbatim value; the CUIT is delivered only for organisation suppliers.

### Provenance and compliance

Every run reads the door host's `robots.txt` at runtime; the gate result (URL, status, byte length and, where a
policy is served, its SHA-256) is written to the run's `RUN_RECEIPT`. Where the host serves no applicable
robots rule, the gate records that (flagged) and proceeds on the licence, which grants re-use. The endpoint is
keyless. The Actor never bypasses a block or fetches through a mirror.

### Data quality and freshness

Boolean columns are delivered as real booleans and numeric columns as real numbers. Delivery is keyed on a
stable id, so the dataset is safe to diff, deduplicate or upsert. Every run re-reads the live door, so the data
is as fresh as the source publishes, and each record's `observed_at` stamp dates the snapshot. The run's
`RUN_RECEIPT` records the source URL and how many records were delivered and charged, and confirms
`charge_equals_delivered`.

### Billing, delivery and joins

Pricing is per record: you are billed only for records the Actor actually delivers, with the charge raised after
each record is pushed (push-then-charge), so a failed or empty run costs nothing. The **Maximum records** cap
bounds every run, so you control spend precisely - sample cheaply, then raise it. Every record is a flat, typed
object keyed on a stable id, so the data loads without a cleaning pass, diffs cleanly between runs, and upserts
into a table you maintain over time; re-running keeps that table current without re-paying for rows you already
hold, and each receipt reconciles delivered against charged. Because the source's own identifiers are preserved
verbatim, the dataset joins cleanly onto other sources keyed on the same identifier.

### Scaling and scheduling

Set **Maximum records** low to sample the shape of the data cheaply, then raise it once the cell fits your use.
The Actor delivers incrementally and streams its source, so memory stays flat regardless of how many records you
request, and you are billed only for what is delivered. Because the source republishes on its own cadence, a
scheduled run keeps a downstream table current: new and changed records upsert over the old ones on the stable
key, and the `observed_at` stamp on every record tells you when each was last seen live. There is no
subscription and no minimum - the per-record price and the record cap together mean the spend on any run is
known in advance and matched exactly to the data you receive.

### Inputs

- **Maximum records** (`maxRecords`) - hard cap on award records delivered and billed.

### Output

Records land in the Actor's default dataset and export as JSON, CSV, Excel or via the Apify API. A tabular
overview surfaces procedure, award date, supplier organisation, CUIT, amount and executing unit.

### Fields in detail

The record leads with `procedure_number`, the SAF/UOC codes and `executing_unit`, `procedure_type`, `modality`,
`fiscal_year`, `award_date`, `categories`, `supplier_cuit`, `supplier_name`, `contract_document`,
`document_type`, `amount`, `currency`, `operation_type` and `perfection_date`. The provenance block closes every
record.

### Typical uses

Analysts use this cell to see who won Argentine federal contracts - supplier organisations, amounts and dates,
by executing unit and procedure - as a clean, person-free award table. Because the supplier and executing unit
are first-class fields, a group-by gives the top suppliers or the busiest buyers without cleaning. Join
`procedure_number` to the calls-for-tender cell to trace an award back to its process.

### Reading the CUIT guard

The CUIT is Argentina's tax identifier, and its first two digits encode the entity type: 20, 23, 24 and 27 are
natural persons; 30, 33 and 34 (and a few others) are organisations. Because a public award dataset that names
natural-person suppliers is personal data, this cell drops the person-CUIT rows at ingest and keeps only the
organisation suppliers - so the delivered table is a clean, person-free record of which organisations won which
contracts. The guard runs before any row is delivered or billed, and the run receipt reports how many rows it
removed. If you need the full unfiltered count for reconciliation, the live all-years total is stated above; the
delivered set is the organisation subset of it.

### Reconciling with the index

The live all-years extract totals differ from the figure the research index cited, which is expected: the
published CSVs are re-issued over time and the yearly files shift as records are corrected or consolidated, so
the live count is the honest measure and is what this listing quotes. What matters for a buyer is that the cell
delivers the complete published set at the award grain, minus the natural-person suppliers, keyed on the
procedure and contract document so it upserts cleanly and joins to the tender side. A scheduled run picks up new
award documents as the extracts are refreshed.

### Sibling Actors

It sits beside the Argentina calls-for-tender cell (same door, process grain - join on the procedure number) and the fleet's Brazil PNCP awarded-contracts cell. It shares its multi-CSV engineering with the fleet's other records Actors.

# Actor input Schema

## `maxRecords` (type: `integer`):

Maximum records delivered and billed. You are billed only for records actually delivered. Raise it to pull the full set.

## Actor input object example

```json
{
  "maxRecords": 500
}
```

# Actor output Schema

## `results` (type: `string`):

The delivered Argentina COMPR.AR contract award record.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "maxRecords": 500
};

// Run the Actor and wait for it to finish
const run = await client.actor("nexgensignal/ar-comprar-award-records").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "maxRecords": 500 }

# Run the Actor and wait for it to finish
run = client.actor("nexgensignal/ar-comprar-award-records").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "maxRecords": 500
}' |
apify call nexgensignal/ar-comprar-award-records --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nexgensignal/ar-comprar-award-records"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/gHpB8HDXIBbaV4hU0/builds/mrySxHs5yfIx4BDBe/openapi.json