Skip to content
Back to guides
Guide

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.

Thomas Ferreira 13 min read

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):

IntegrationWhat Vanta says it syncsPhishing simulation results
KnowBe4”completed training from selected training campaigns”, via the KnowBe4 Reporting API “with read-only permissions”; users matched by emailNot mentioned
WizerTraining enrollment and completion, “Completion data updates every hour""No, Not currently synced”
MimecastTraining 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 BusinessTraining 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

RouteVanta APIWhat the auditor sees in VantaEffort
1. Training statusPUT /v1/resources/user_security_training_statusPer-person training records (assigned, due, completed), checked by Vanta’s training testsLow
2. Phishing resultsPUT /v1/resources/custom_resource plus a Custom TestPer-person outcome for each campaign, with a pass or fail from your testMedium
3. Report as evidencePOST /v1/documents then POST /v1/documents/{documentId}/uploadsThe PDF report of each campaign or quarter, attached as a documentLowest

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:

  1. A Vanta Admin opens Settings › Developer Console, clicks Create, picks Build Integrations and the Private distribution. The OAuth client_id is generated; click Generate client secret.
  2. In the app’s Resources tab, click + Create Resource twice:
    • one resource on the UserSecurityTrainingStatus base type, for training;
    • one on the CustomResource base type, for phishing results, with custom properties written in JSON Type Definition. Vanta supports boolean, int32, string and timestamp (resources).
  3. 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.

EndpointReturns
GET /meThe key’s org_id and scopes
GET /orgs/{org_id}/campaigns?status=completedCampaigns: id, name, status, started_at, completed_at (paginated, limit up to 200)
GET /orgs/{org_id}/campaigns/{campaign_id}/recipientsOne row per recipient (paginated, limit up to 500, filter outcome)
GET /orgs/{org_id}/campaigns/{campaign_id}/resultsTotals and rates: delivered, opened, clicked, submitted, reported, click_rate, report_rate, per-department summary
GET /orgs/{org_id}/course-assignmentsTraining 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 fieldnophi.sh field
uniqueIdid (assignment)
displayNameuser_email and course_title
externalUrlthe console address, https://app.nophi.sh/org/{org_id}
trainingId / trainingNamecourse_id / course_title
traineeEmail, traineeAccountNameuser_email
traineeFullNameuser_first_name and user_last_name
statusCOMPLETE when status is completed, else INCOMPLETE
trainingCreatedTimestampassigned_at
trainingDueTimestampdeadline_at
trainingCompletedTimestampcompleted_at
frameworksFulfilledfor example ["ISO27001", "SOC2"]

Phishing results (route 2), from recipients to your custom resource:

Vanta fieldnophi.sh field
uniqueIdevent_id (one per person and campaign)
displayNameemail and the campaign name
externalUrlhttps://app.nophi.sh/org/{org_id}/campaigns/{campaign_id}
customProperties.email, departmentemail, department
customProperties.campaign, sentAtcampaign name, email_sent_at
customProperties.outcomeoutcome
customProperties.clicked, submittedCredentials, reportedclicked, submitted, reported
customProperties.trainingCompletedtraining.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:

RouteDrata APINotes
Training evidence per personGET /personnel?expand[]=complianceChecks, then POST /users/{userId}/documents with type = SEC_TRAINING, a file and completionDateDrata’s recipe; needs the “Create User Document” permission
Your own recordsPOST /custom-connections/{connectionId}/resources/{resourceId}/recordsRequires 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 TrainingRecord and the API reference calls it UserSecurityTrainingStatus. 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.