---
name: monday-reverse-contact-integration
description: Connect monday CRM and Reverse Contact: what syncs, which editions carry it, the setup order, and the failures to expect. Covers contacts, companies, custom objects. Use when the user wants to set up, audit or troubleshoot monday and Reverse Contact together, or asks why data is not moving between them.
---

# monday CRM and Reverse Contact

> Generated from https://www.reversecontact.com/integrations-hub/reverse-contact-integrations/monday-reverse-contact-integration
> Every tier requirement, sync direction and limit below was read from the vendors' own documentation on 2026-10-11.
> Vendors change these without notice. Re-check anything load-bearing before you rely on it.

**What you have to buy first:** A Reverse Contact API key, a monday plan with automations, and a receiver for the webhook

**What moves:** contacts, companies, custom objects, one way, into monday.
**How it is built:** built on the api, zapier, make or n8n. **Effort:** hours.

## The short version

monday CRM is the least opinionated CRM in this directory and the most constrained to enrich, for one reason that has nothing to do with features: 1,000 API calls a day until you reach Pro. Everything else works. Webhooks are solid, the GraphQL API is pleasant, columns take whatever you write into them. But a read and a write per record against a four-figure daily ceiling means this is a trickle rather than a sweep until the plan changes, and the right build is one that enriches on creation and never backfills.

## What the daily call limit actually buys you

Rows: What you are trying to run. Columns: monday plan. monday meters the API by the day and the ceiling is low enough to be the design rather than a footnote: 1,000 calls on Free, Basic and Standard, 10,000 on Pro and 25,000 on Enterprise, resetting at midnight UTC. The grid assumes two calls per record, one to read it and one to write every enriched column back in a single mutation, which is the cheapest this build can honestly be.

| What you are trying to run | Free, Basic or Standard | Pro | Enterprise |
|---|---|---|---|
| Enrich 100 new items a day | Comfortable | Comfortable | Comfortable |
| Enrich 500 a day | At the limit | Comfortable | Comfortable |
| Enrich 2,000 a day | Over the daily budget | Comfortable | Comfortable |
| Backfill 20,000 items in one pass | Over the daily budget | Over the daily budget | At the limit |
| Run it beside another integration | Over the daily budget | At the limit | Comfortable |

- **Comfortable.** Inside the daily allowance with room for something else to be using the account too. Pro at 10,000 calls a day is where this pair stops needing to be thought about, and it is also where the minute limit rises to 2,500 and concurrency to 100.
- **At the limit.** Technically inside the budget and with nothing spare. Five hundred records at two calls each is the entire Standard allowance, and a 20,000-record backfill is 40,000 calls against an Enterprise ceiling of 25,000, so it is two nights or a requested increase through the API analytics dashboard.
- **Over the daily budget.** Over the limit, and the limit returns DAILY_LIMIT_EXCEEDED rather than queueing. The allowance is shared with every personal token, private app and public app on the account, excluding marketplace apps and monday's own, so in practice there is less of it than the number suggests.

Counted off that grid, of fifteen pairings: eight give you comfortable, three give you at the limit, four give you over the daily budget.

The second row is the one worth sitting with: five hundred records a day is the whole Standard budget, and it is shared. That makes monday the one CRM in this set where the honest recommendation is to enrich on creation and never backfill, unless the plan changes. Pipedrive gates the capability and monday gates the volume, and the volume gate is the easier one to miss, because nothing fails until the day somebody imports a list.

## What actually syncs

Direction is written from monday's point of view: out means out of monday, in means into it.

| What | Direction | What that means in practice |
|---|---|---|
| Trigger | One way, out | A webhook on create_item or a column change, verified with monday's challenge handshake. |
| The enrichment | One way, out | Your receiver, a Zap or a Make scenario calls /v2/enrich/persons with the email from the item. 2 credits. |
| Write-back | One way, in | A GraphQL change_multiple_column_values mutation sets the columns. One call against the daily count. |
| Anything back to Reverse Contact | One way, out | Nothing. This is a read layer, and the receiver decides which columns may be written. |

## Which field lands where

The enrichment never happens inside monday, because there is no HTTP step in its automations. What the board contributes is a trigger and a set of columns, and everything interesting about the mapping is that columns are identified by id rather than by name.

| In monday | In Reverse Contact | What to know about the match |
|---|---|---|
| A board event | Nothing yet | Created through the create_webhook mutation with a board, a url, an event and a config, so an event can be scoped to one column and one value. Custom automations are metered separately from API calls, starting at 250 a month on Standard and rising to 25,000 on Pro. |
| The webhook payload | Your receiver, over POST | Carries a JWT in the Authorization header when the webhook was created with an integration app token, verifiable against the app Signing Secret. Requests retry once a minute for thirty minutes, so a receiver that is briefly down loses nothing. |
| Your worker, holding an email | POST /v2/enrich/persons, 2 credits | Identity, the current role, history, education, skills and location on one schema. Costs nothing on a miss, because every 4xx and 5xx is free, and nothing from monday's budget either because it is not a monday call. |
| Your worker, holding a domain | POST /v2/enrich/companies, 2 credits | Firmographics from a domain or a company name. Worth running once per account board item rather than once per person linked to it, which also halves the monday calls. |
| A live refresh, if you want one | POST /v2/fetch/persons/live, 2 credits | Genuinely available on this route, unlike most of the CRM pages here, because the worker is outside monday and can poll. Polling is free and off the rate-limit clock. |
| change_multiple_column_values | Every enriched column, in one call | The mutation that matters for the budget. One call carrying six values costs one of your daily allowance; six calls cost six, and on 1,000 a day that decides your throughput. |
| A column id | Not a column name | Mutations address columns by id. Renaming a column in the interface is harmless and duplicating a board mints new ids, so a write can land nowhere without anything reporting a failure. |
| Anything outbound to Reverse Contact | Only what your worker sends | This is a read layer. Nothing travels back, and there is nothing in the product to write to. |

### Four separate budgets, and only one of them is the one people watch

monday meters four different things at once and each has its own error. The daily call limit is the one that decides whether this pair is viable, and it is also the only one of the four that a small integration will ever reach.

| The budget | What it is and what happens at the end of it |
|---|---|
| Daily call limit | 1,000 on Free, Basic and Standard, 10,000 on Pro, 25,000 on Enterprise, resetting at midnight UTC. Returns DAILY_LIMIT_EXCEEDED |
| Minute limit | 1,000 queries a minute on other tiers, 2,500 on Pro, 5,000 on Enterprise. Returns a minute limit error with a Retry-After header |
| Concurrency limit | 40 simultaneous requests on other tiers, 100 on Pro, 250 on Enterprise. Returns a concurrency error |
| Complexity limit | 5,000,000 points for a single query, and a per-minute budget on a sliding window: 5,000,000 each for reads and writes on an app token, 10,000,000 combined on a personal token, 1,000,000 on trial, NGO and free accounts. Returns ComplexityException |
| A request that hit any rate limit | Counts 0.1 of a call against the daily limit rather than a full one, and returns retry_in_seconds |
| A request that simply failed | Counts in full. monday states that all requests count toward the limits, even those that fail or return an error |

**What does not cross:**

- An HTTP step inside a monday automation. There is none, which is why this build always has a receiver in it and why the enrichment is never a monday feature.
- A contact object with agreed fields. A board is columns somebody named, addressed by id, so there is no schema for a mapping to be wrong about and no schema to protect you either.
- A business email or a direct phone number. Both are separate Reverse Contact endpoints at 3 and 20 credits, charged only when one is found.
- A backfill on anything below Pro. One thousand calls a day shared across every integration on the account is a few hundred records, and the limit resets at midnight UTC rather than at yours.

## Connect it, in this order

**Who has to do it:** Somebody who can create a monday app and an OAuth token, plus whoever hosts the webhook receiver and whoever can create a Reverse Contact API key.
**How long:** A day. The challenge handshake is twenty minutes and the volume arithmetic in step one is what decides whether the rest is worth doing.

### 1. Do the volume arithmetic before anything else, because it may end the project

*Where:* A calculator, not monday

The daily API call limit is 1,000 on Free, Basic and Standard, 10,000 on Pro and 25,000 on Enterprise, resetting at midnight UTC and shared with every other integration on the account. An enrichment round trip is at least one read and one write, so anything below Pro is a few hundred records a day and never a backfill.

### 2. Decide which columns the enrichment owns, and write down their ids

*Where:* monday: the board

A board is columns somebody named rather than a contact object with agreed semantics. Mutations address columns by id, so renaming one in the interface breaks nothing and duplicating a board for another team produces new ids that break everything silently. Write the ids down somewhere outside monday.

### 3. Build the receiver and answer the challenge first

*Where:* Your own host, or n8n

monday posts a randomly generated token in a challenge field to prove you control the URL, and expects the identical value returned in a challenge field of your JSON response. A receiver that does not implement that cannot be registered at all, so this is step one of the build rather than a detail. The URL is also capped at 255 characters.

### 4. Create the webhook with an integration app token, not a personal one

*Where:* monday: a monday app with an integration feature

Two things follow from doing it this way. Requests then carry a JWT in the Authorization header that you can verify against the app Signing Secret, and end users cannot disable the webhook, which monday documents as deliberate so a curious user cannot toggle an integration off.

### 5. Subscribe to the narrowest event you can

*Where:* monday: the create_webhook mutation

The mutation takes a board, a url, an event and a config, so a status-column event can be scoped to one column and one value. Every event that fires is a round trip against a four-figure daily budget, so the filter is the budget.

### 6. Enrich in the receiver, not in monday

*Where:* Your worker, or an n8n workflow

monday has no HTTP step in its automations, so the call to Reverse Contact always happens outside. That also means the live endpoints are available here in a way they are not on most of these pages, because a worker can poll and a CRM automation cannot.

### 7. Write back with change_multiple_column_values rather than one call per field

*Where:* Your worker, against the monday API

One mutation carrying every enriched column is one call against the daily limit; six mutations are six. On a 1,000-call budget that distinction is the difference between 400 records a day and 70.

### 8. Read the RateLimit headers and throttle before you are throttled

*Where:* Your worker, on every response

monday returns RateLimit-Policy and RateLimit headers in the IETF format, reporting minuteRate, concurrency and complexityMinute with a remaining value and a reset. Every rate-limit error also carries retry_in_seconds. Honouring those is cheaper than retrying, because all requests count toward the limits even when they fail.

Step one is unusual in this set because it can honestly end the project: on Standard there is no volume at which this pair is a sweep rather than a trickle. That is a different kind of constraint from [the one Pipedrive has](pair:pipedrive+reverse-contact), where every plan can be made to work and the automation simply cannot read a response.

## How to check it worked

- Register the webhook and confirm it was accepted. monday will not create one against a URL that fails the challenge, so a successful registration is itself the proof that half the build works.
- Trigger the event once and verify the JWT in the Authorization header against the app Signing Secret. Doing it on the first event rather than later is what stops the receiver quietly accepting anything that finds the URL.
- Run twenty records through and read the RateLimit header on the last response. The remaining value against your tier is what turns the volume arithmetic in step one from an estimate into a measurement.
- Write to a column id you have deliberately mistyped. The mutation does not error in a way that looks like a mistake, which is exactly why the column ids belong written down.

## When it goes wrong

Each row is a symptom somebody reports, the documented reason, and the fix. Work down it before escalating to either vendor, because most of these are configuration.

| Symptom | Why it happens | What to do |
|---|---|---|
| DAILY_LIMIT_EXCEEDED halfway through the afternoon | The daily call limit is 1,000 on Free, Basic and Standard, 10,000 on Pro and 25,000 on Enterprise, shared across every personal token, private app and public app on the account. | Collapse the write into one change_multiple_column_values call, narrow the webhook event, and find out what else on the account is spending the budget. An increase can be requested through the API analytics dashboard if the account consistently exceeds it. |
| The webhook will not register at all | monday posts a randomly generated token in a challenge field to verify you control the URL, and expects the identical value back in a challenge field of your JSON response body. The URL is also capped at 255 characters. | Implement the challenge before anything else. It is four lines in most frameworks, and no webhook exists until it passes. |
| An end user turned the integration off | A webhook created with a personal token can be toggled by end users. monday documents that webhooks created with an integration app token cannot, specifically so an app is not disrupted by a curious user. | Create a monday app with an integration feature, generate an OAuth token for it, and call create_webhook with that. The same change is what puts a verifiable JWT in the Authorization header. |
| The write reported success and the column is empty | Mutations address columns by id rather than by name, so a wrong id is a well-formed mutation against a column that is not the one you meant. | Keep the column ids written down outside monday, and re-check them after any board is duplicated. Duplicating a board for a new team mints new ids and breaks nothing visibly until the first write. |
| ComplexityException on a query that looks small | Complexity is a separate budget from the call count: 5,000,000 points for a single query, and a per-minute budget on a sliding window that is 1,000,000 on trial, NGO and free accounts. | Add the complexity field to the query to read the cost before and after, request only the fields you need, reduce nesting, and use the page and limit arguments. monday recommends exactly those three. |
| Retries made everything worse | All requests count toward the limits even when they fail, and every rate-limit error carries a retry_in_seconds field that a retry loop usually ignores. | Read the RateLimit header, which reports minuteRate, concurrency and complexityMinute with a remaining value and a reset in seconds, and throttle before the remaining value reaches zero. |
| The lookup came back empty and the column was blanked | Reverse Contact returns null rather than a best guess when it is not confident, and a worker that maps the response straight into a mutation writes the absence. | Branch in the worker on the field being present and omit it from the mutation otherwise. A column left alone costs nothing; a column overwritten with nothing costs a rep's trust in the board. |
| An endpoint that worked last week returns nothing | /v2/resolve was replaced by /v2/enrich and /v2/search/persons by /v2/search/people, with the old pair documented as live only until 13 October 2026. | Change both paths in the worker. This is the one route where that fix is in ordinary version-controlled code rather than inside a CRM automation nobody can diff. |

## What breaks, from the vendors' own docs

- **1,000 API calls a day on Basic and Standard.** The daily call limit resets at midnight UTC and is 1,000 on Free, Basic and Standard, 10,000 on Pro and 25,000 on Enterprise, and it is shared across every personal token, private app and public app on the account. Exceeding it returns DAILY_LIMIT_EXCEEDED. An enrich-and-write loop is at least one call per record, so plan the volume against the plan before anything else.
- **Complexity is a second, separate budget.** Reads and writes have a complexity budget of 5,000,000 points a minute each on an app token, 10,000,000 combined on a personal token, and 1,000,000 on trial, NGO and free accounts, on a sliding 60-second window. A single query may not exceed 5,000,000 points. Add a complexity field to a query to see the cost before you run it at scale.
- **Automations are metered too, and separately.** Custom automations start at Standard with 250 a month and rise to 25,000 on Pro. That is the budget the trigger comes out of, and it is independent of the daily API call count that the write-back spends.
- **The webhook endpoint must answer a challenge.** monday posts a randomly generated token in a challenge field when the webhook is created, and expects the identical value back in a challenge field of the response. A receiver that does not implement it cannot be registered. The URL is also capped at 255 characters.
- **A board is columns, not a schema.** There is no contact object with agreed semantics, only columns somebody named. That makes the write flexible and makes the mapping fragile: renaming a column in the interface does not break the mutation, which addresses columns by id, but duplicating a board for a new team produces new column ids and silently breaks nothing until the first write lands nowhere.

## The APIs, if you are building around it instead

### Reverse Contact

- **Base:** `https://api.reversecontact.com/v2`
- **Auth:** `Authorization: Bearer rc_your_api_key`. Keys are created in Workspace > API Keys.

| Call | Request | What it does |
|---|---|---|
| `POST /v2/enrich/persons` | `{ "email": "j.okafor@northwind.io" }` | Resolve a person from an email, a name plus company, or a profile URL. Cached resolution, returns in the response. |
| `POST /v2/enrich/companies` | `{ "domain": "northwind.io" }` | Resolve a company from a domain or a name. |
| `POST /v2/fetch/persons` | `{ "linkedInUrl": "..." }` | Standard profile lookup from the database. |
| `POST /v2/fetch/persons/live` | `{ "linkedInUrl": "..." }` | Live on-demand resolution. ASYNCHRONOUS: returns a webhookId to poll, not a record. |
| `POST /v2/search/people` | `{ "filters": { "currentCompanyDomain": "northwind.io" } }` | Filtered people search. 1 credit a profile delivered, and /v2/search/people/count is free. It replaced /v2/search/persons, which returns 410 Gone since 13 October 2026. |
| `POST /v2/search/organizations` | `{ "filters": { "companyDomain": "northwind.io" } }` | Filtered company search. A domain can also go straight to a company through POST /v2/enrich/companies, or through the enrich_company MCP tool since November 2026. |
| `POST /v2/contact/email` | `{ "linkedInUrl": "..." }` | Find an email. ASYNCHRONOUS: returns a taskId to poll. 3 credits for a professional address, 5 for a personal one, 8 for both, refunded when neither is found. |
| `GET /v2/webhooks/:webhookId` | - | Poll an async job until status is "succeeded". Polling is free and does not count against the rate limit. |

Response shape:

```json
{
  "success": true,
  "data": {
    "person": {
      "fullName": "Jane Okafor",
      "headline": "VP Sales at Northwind",
      "location": "London, United Kingdom",
      "linkedInUrl": "https://linkedin.com/in/...",
      "currentPosition": { "title": "VP Sales", "companyName": "Northwind", "startDate": "2023-04" },
      "emails": [], "experience": [], "education": [], "skills": []
    },
    "company": { "name": "Northwind", "domain": "northwind.io",
                 "industry": "Software Development", "employeeCount": 220 }
  },
  "error": null,
  "metadata": { "requestId": "req_...", "executionTimeMs": 480, "updatedAt": "2026-09-01T..." },
  "quotas": { "creditsConsumed": 1, "workspace": { "credits": { "total": 10000, "used": 4521, "left": 5479 } } }
}
```

**Rules that will cost you time if you skip them:**

- A miss returns **null**, not a best guess. Every response carries a confidence score, and you can raise the precision threshold on the request. Branch on it: do not treat a low-confidence answer as a match.
- Use the cached endpoints anywhere that must answer inside one HTTP request. The `/live` endpoints return a task and need polling.
- `quotas.workspace.credits.left` is on every response. Log it, or you will find out about the balance from a 402.
- Credit costs per call are published and a dollar rate per lookup is not: 2 credits for a reverse lookup from an email, 1 for a cached profile lookup, 2 for a live refresh, 3 for a business email and 20 for a direct phone number, with the last two charged only when one is found. Checks and the search count endpoint are free. Credit packs expire after 3 months. Do not hard-code a dollar cost assumption.

**MCP server:** `https://api.reversecontact.com/mcp`

- Auth: OAuth 2.1 where the client supports it, otherwise `Authorization: Bearer rc_your_api_key`.
- Tools: `enrich_person`, `enrich_person_live`, `enrich_company`, `enrich_company_live`, `search_persons`, `search_companies`, `check_usage`, `check_task`
- Streamable HTTP, JSON-RPC 2.0. The `_live` tools return a task id that `check_task` polls.

Docs: https://docs.reversecontact.com/getting-started

## Sources

- monday.com API: rate limits: https://developer.monday.com/api-reference/docs/rate-limits
- monday.com API: webhooks: https://developer.monday.com/api-reference/reference/webhooks
- monday CRM pricing: https://monday.com/crm/pricing
- Reverse Contact API documentation: https://docs.reversecontact.com/getting-started
- Reverse Contact: credits: https://docs.reversecontact.com/guides/credits
- Reverse Contact: rate limits: https://docs.reversecontact.com/guides/rate-limits
- Reverse Contact pricing: https://www.reversecontact.com/pricing
- 14 practitioner threads read on 2026-10-11, summarised on the page: https://www.reversecontact.com/integrations-hub/reverse-contact-integrations/monday-reverse-contact-integration#reddit
- This pair, with the reasoning behind each step: https://www.reversecontact.com/integrations-hub/reverse-contact-integrations/monday-reverse-contact-integration

---

*Published by Reverse Contact, which appears in this directory as a data provider.
No other vendor pays for placement. Where a vendor publishes no public figure, this file says so
rather than estimating. Reverse Contact costs are stated in credits, which it publishes; no dollar
rate per lookup appears here, because none is published and dividing a pack price is not their number.*
