Send phishing simulation results to Vanta (and Drata) in 2026
Vanta's security awareness integrations sync training completion, not phishing results. How to push per-person phishing outcomes with a private integration, with field mapping and a script.
Updated 18 November 2026. Every Vanta and Drata statement below was checked on their own documentation on that date, with links.
Short answer: Vanta’s security awareness integrations sync training completion, not phishing simulation results. The KnowBe4 integration “syncs completed training from selected training campaigns”, and Vanta’s capability tables for Wizer and Mimecast mark phishing simulation results as “Not currently synced”. To get per-person phishing outcomes into Vanta, build a private integration: training status goes to the built-in UserSecurityTrainingStatus resource, phishing results go to a custom resource evaluated by a Custom Test. Drata accepts the same data as per-person training documents or Custom Connection records.
This guide explains what Vanta and Drata sync natively, then gives a working recipe with the nophi.sh REST API as the source: endpoints, field mapping and a sync script. The Vanta side applies to any phishing tool that exposes per-recipient results.
Does Vanta sync phishing simulation results in 2026?
From the integration articles in Vanta’s help center (checked 18 November 2026):
| Integration | What Vanta says it syncs | Phishing simulation results |
|---|---|---|
| KnowBe4 | ”completed training from selected training campaigns”, via the KnowBe4 Reporting API “with read-only permissions”; users matched by email | Not mentioned |
| Wizer | Training enrollment and completion, “Completion data updates every hour" | "No, Not currently synced” |
| Mimecast | Training enrollment and completion | ”No, Not currently synced” |
| Docebo (an LMS) | Training enrollment and completion | ”Yes, Powers SAT compliance tests and evidence collection” (no further detail) |
| Absorb LMS, Udemy Business | Training completion | ”No, Not supported by this integration” |
Synced trainings become personnel tasks. Vanta’s personnel tasks article says: “For every training assigned to personnel, there will be a test, “[Training name] training records tracked"". So an auditor reading Vanta sees who completed which course, and nothing about who clicked a simulated phishing email unless you send it.
Vanta’s integration directory also has pages for Hoxhunt and Huntress (Curricula), but on 18 November 2026 their body text gave no detail we could verify.
Three ways to get phishing results into Vanta
| Route | Vanta API | What the auditor sees in Vanta | Effort |
|---|---|---|---|
| 1. Training status | PUT /v1/resources/user_security_training_status | Per-person training records (assigned, due, completed), checked by Vanta’s training tests | Low |
| 2. Phishing results | PUT /v1/resources/custom_resource plus a Custom Test | Per-person outcome for each campaign, with a pass or fail from your test | Medium |
| 3. Report as evidence | POST /v1/documents then POST /v1/documents/{documentId}/uploads | The PDF report of each campaign or quarter, attached as a document | Lowest |
Most teams combine route 1 (training after a mistake counts as training) with route 3 (the report auditors already know), and add route 2 when they want click and report outcomes tested per person. The rest of this guide builds routes 1 and 2.
Step 1: create a private integration in Vanta
From Vanta’s private integration quickstart:
- A Vanta Admin opens Settings › Developer Console, clicks Create, picks Build Integrations and the Private distribution. The OAuth
client_idis generated; click Generate client secret. - In the app’s Resources tab, click + Create Resource twice:
- one resource on the
UserSecurityTrainingStatusbase type, for training; - one on the
CustomResourcebase type, for phishing results, with custom properties written in JSON Type Definition. Vanta supportsboolean,int32,stringandtimestamp(resources).
- one resource on the
- Copy each Resource ID: every sync call names it.
The custom properties for phishing results can be:
{
"properties": {
"email": { "type": "string" },
"department": { "type": "string" },
"campaign": { "type": "string" },
"sentAt": { "type": "timestamp" },
"outcome": { "type": "string" },
"clicked": { "type": "boolean" },
"submittedCredentials": { "type": "boolean" },
"reported": { "type": "boolean" },
"trainingCompleted": { "type": "boolean" }
}
}
Authentication is the OAuth client credentials grant: POST https://api.vanta.com/oauth/token with a JSON body (client_id, client_secret, scope, "grant_type": "client_credentials"). Vanta rejects form-encoded bodies. The scopes are connectors.self:write-resource and connectors.self:read-resource. Tokens last 3,600 seconds, and requesting a new token revokes the previous one (authentication).
Custom resources and Custom Tests are a private-integration feature. Vanta’s docs are explicit about the test: “Without a custom test, a custom resource is just a passive data record”, so create a Custom Test in the Vanta app once the first records are in.
Step 2: read per-person results from the phishing platform
With nophi.sh, an admin creates an organisation API key in Settings › API access with the read scope only: the sync never needs to write. Calls go to https://app.nophi.sh/api/v1 with Authorization: Bearer nph_live_…, documented in the OpenAPI file.
| Endpoint | Returns |
|---|---|
GET /me | The key’s org_id and scopes |
GET /orgs/{org_id}/campaigns?status=completed | Campaigns: id, name, status, started_at, completed_at (paginated, limit up to 200) |
GET /orgs/{org_id}/campaigns/{campaign_id}/recipients | One row per recipient (paginated, limit up to 500, filter outcome) |
GET /orgs/{org_id}/campaigns/{campaign_id}/results | Totals and rates: delivered, opened, clicked, submitted, reported, click_rate, report_rate, per-department summary |
GET /orgs/{org_id}/course-assignments | Training per person: course_id, course_title, status, assigned_at, deadline_at, completed_at, quiz_score, user_email, names |
Each recipient row carries event_id, user_id, name, email, department, status (delivery), email_sent_at, outcome (credentials, clicked, reported, opened or none for a delivered email), the booleans opened, clicked, submitted and reported, first_click_at, first_click_delay_seconds, and training (status, progress, quiz score, course title, deadline, overdue flag, practice exercise result). Results count human interactions only: clicks from email security scanners are set aside.
Step 3: map the fields
Training (route 1), from course-assignments to UserSecurityTrainingStatus (schema):
| Vanta field | nophi.sh field |
|---|---|
uniqueId | id (assignment) |
displayName | user_email and course_title |
externalUrl | the console address, https://app.nophi.sh/org/{org_id} |
trainingId / trainingName | course_id / course_title |
traineeEmail, traineeAccountName | user_email |
traineeFullName | user_first_name and user_last_name |
status | COMPLETE when status is completed, else INCOMPLETE |
trainingCreatedTimestamp | assigned_at |
trainingDueTimestamp | deadline_at |
trainingCompletedTimestamp | completed_at |
frameworksFulfilled | for example ["ISO27001", "SOC2"] |
Phishing results (route 2), from recipients to your custom resource:
| Vanta field | nophi.sh field |
|---|---|
uniqueId | event_id (one per person and campaign) |
displayName | email and the campaign name |
externalUrl | https://app.nophi.sh/org/{org_id}/campaigns/{campaign_id} |
customProperties.email, department | email, department |
customProperties.campaign, sentAt | campaign name, email_sent_at |
customProperties.outcome | outcome |
customProperties.clicked, submittedCredentials, reported | clicked, submitted, reported |
customProperties.trainingCompleted | training.status is completed |
Step 4: the sync script
Both Vanta endpoints are “state of the world” syncs: each call replaces everything the app sent before, and records left out are deleted in Vanta. Send the full set every run. Vanta suggests pushing on a recurring schedule, “typically hourly”; a nightly run is enough for audit evidence.
import os
import requests
NPH = "https://app.nophi.sh/api/v1"
NPH_AUTH = {"Authorization": f"Bearer {os.environ['NOPHISH_API_KEY']}"} # read scope
VANTA = "https://api.vanta.com"
def nph(path, **params):
r = requests.get(NPH + path, headers=NPH_AUTH, params=params, timeout=30)
r.raise_for_status()
return r.json()
def items(path, limit, **params):
offset = 0
while True:
page = nph(path, limit=limit, offset=offset, **params)
yield from page["items"]
offset += len(page["items"])
if not page["items"] or offset >= page["total"]:
return
def vanta_token():
r = requests.post(VANTA + "/oauth/token", timeout=30, json={
"client_id": os.environ["VANTA_CLIENT_ID"],
"client_secret": os.environ["VANTA_CLIENT_SECRET"],
"scope": "connectors.self:write-resource connectors.self:read-resource",
"grant_type": "client_credentials",
})
r.raise_for_status()
return r.json()["access_token"]
org = nph("/me")["org_id"]
console = f"https://app.nophi.sh/org/{org}"
phishing = []
for c in items(f"/orgs/{org}/campaigns", 200, status="completed"):
for p in items(f"/orgs/{org}/campaigns/{c['id']}/recipients", 500):
if p["status"] != "delivered":
continue
phishing.append({
"displayName": f"{p['email']} / {c['name']}",
"uniqueId": p["event_id"],
"externalUrl": f"{console}/campaigns/{c['id']}",
"customProperties": {
"email": p["email"],
"department": p["department"] or "",
"campaign": c["name"],
"sentAt": p["email_sent_at"],
"outcome": p["outcome"],
"clicked": p["clicked"],
"submittedCredentials": p["submitted"],
"reported": p["reported"],
"trainingCompleted": bool(p["training"]) and p["training"]["status"] == "completed",
},
})
training = [{
"displayName": f"{a['user_email']} / {a['course_title']}",
"uniqueId": a["id"],
"externalUrl": console,
"trainingId": a["course_id"],
"trainingName": a["course_title"],
"frameworksFulfilled": ["ISO27001", "SOC2"],
"traineeFullName": f"{a['user_first_name'] or ''} {a['user_last_name'] or ''}".strip(),
"traineeAccountName": a["user_email"],
"traineeEmail": a["user_email"],
"status": "COMPLETE" if a["status"] == "completed" else "INCOMPLETE",
"trainingCreatedTimestamp": a["assigned_at"],
"trainingDueTimestamp": a["deadline_at"] or a["assigned_at"],
"trainingCompletedTimestamp": a["completed_at"],
} for a in items(f"/orgs/{org}/course-assignments", 500)]
token = vanta_token()
for resource, resource_id, records in [
("custom_resource", os.environ["VANTA_PHISHING_RESOURCE_ID"], phishing),
("user_security_training_status", os.environ["VANTA_TRAINING_RESOURCE_ID"], training),
]:
r = requests.put(f"{VANTA}/v1/resources/{resource}", timeout=60,
headers={"Authorization": f"Bearer {token}"},
json={"resourceId": resource_id, "resources": records})
r.raise_for_status()
print(resource, len(records), "records sent")
Keep the four secrets (NOPHISH_API_KEY, VANTA_CLIENT_ID, VANTA_CLIENT_SECRET and the two Resource IDs) in your scheduler’s secret store. To check the result, GET /v1/resources/custom_resource?resourceId=… with the read scope lists what Vanta holds.
For route 3, the Manage Vanta API creates a document (POST /v1/documents), uploads a file to it (POST /v1/documents/{documentId}/uploads, multipart, with an optional effectiveAtDate) and submits it (POST /v1/documents/{documentId}/submit), with the vanta-api.documents:upload scope (upload a document). The nophi.sh PDF audit report is the natural file to attach.
Drata: the same results through the public API
Drata’s native KnowBe4 connection retrieves “completion data for assigned campaigns”, and “We will update the personnel’s activity nightly”. Like Vanta, it carries training completion. Drata’s check is Test 43, Security Awareness Training Completed, which “inspects your company security awareness training certificates”.
For another tool, the Drata public API (https://public-api.drata.com/public/v2, with EU and APAC hosts) offers two routes:
| Route | Drata API | Notes |
|---|---|---|
| Training evidence per person | GET /personnel?expand[]=complianceChecks, then POST /users/{userId}/documents with type = SEC_TRAINING, a file and completionDate | Drata’s recipe; needs the “Create User Document” permission |
| Your own records | POST /custom-connections/{connectionId}/resources/{resourceId}/records | Requires the “Custom Connections and Tests” feature on your account |
Authentication is a bearer API key created in Drata under Settings › API Keys, or OAuth client credentials (Drata API keys). For nophi.sh, the per-person training evidence can come from course-assignments (status completed, completed_at) and the file from the campaign’s PDF report.
What we could not verify
- Vanta’s concept pages call the training type
TrainingRecordand the API reference calls itUserSecurityTrainingStatus. The docs do not say whether records from a private app create the “[Training name] training records tracked” test or how they join Vanta’s training categories. Check in your tenant after the first sync. - The Developer Console needs a Vanta login, so we could not see which base types its Resources tab offers. The resource types above come from Vanta’s API reference.
- Vanta’s integration pages for Hoxhunt and Huntress had placeholder text on 18 November 2026, and we found no Vanta pages for Adaptive Security or Phished. Ask those vendors what their Vanta connection sends.
- Drata’s recipe mentions a “personnel ID” in step 1 while the endpoint path takes
{userId}. Check which identifier your tenant expects with one test upload. - Drata’s public integration directory blocked automated reading, so the list of Drata training connections above is limited to the help center articles we could open.
For the audit side of the same evidence (clause 7.2, control A.6.3, what to export), see ISO 27001 A.6.3: phishing test and training evidence. To let an AI assistant run the campaigns that feed this sync, see phishing simulation MCP servers and APIs compared. nophi.sh costs 1 euro excl. VAT per person per month with the API included (pricing).
Sources (checked on 18 November 2026): Vanta help center: KnowBe4, Wizer, Mimecast, Docebo, Absorb LMS, Udemy Business, personnel tasks. Vanta developer docs: private integration quickstart, authentication, resources, user security training statuses, upload a document. Drata: KnowBe4 guide, Test 43, training evidence recipe, API keys. nophi.sh: OpenAPI.