Mutations

Mutations allow for modifying data within the Worksome API.

acceptBid

Type: Hire!

Hire a worker for a job by accepting their bid.

Only companies can make hires. The worker must have submitted a bid on the job before this mutation can be used.

Once a hire is created, a draft contract is automatically generated (Hire.latestContract) and is pending acceptance from the other party (usually the worker).

Arguments
inputAcceptBidInput!
The input required for hiring a worker by accepting their bid.

Example

mutation AcceptBid {
  acceptBid(input: {
    # AcceptBidInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

actionApprovalApprovable

Type: ApprovalApprovable

Take action on a pending approval request — approve, reject, or request changes.

The authenticated user must be a member of the approver’s user group and the approval request must be awaiting their action (viewerCanAction must be true).

Arguments
inputActionApprovalApprovableInput!
The action to take on the approval request.

Example

mutation ActionApprovalApprovable {
  actionApprovalApprovable(input: {
    # ActionApprovalApprovableInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

approveEmploymentChanges

Type: Employment!

Mark an employment as updated.

Arguments
inputApproveEmploymentChangesInput!
The input for approving employment changes.

Example

mutation ApproveEmploymentChanges {
  approveEmploymentChanges(input: {
    # ApproveEmploymentChangesInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

approveTrustedContact

Type: TrustedContact!

Approve a trusted contact.

Only companies can approve trusted contacts.

Arguments
inputApproveTrustedContactInput!
The details of the trusted contact to be approved.

Example

mutation ApproveTrustedContact {
  approveTrustedContact(input: {
    # ApproveTrustedContactInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

attachJobsToProject

Type: Project!

Attach one or more jobs to a project.

Only companies can attach jobs to projects.

Arguments
inputAttachJobsToProjectInput!
The details for attaching a job to a project.

Example

mutation AttachJobsToProject {
  attachJobsToProject(input: {
    # AttachJobsToProjectInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

attachUsersToUserGroup

Type: UserGroup!

Attach one or more users to a group.

Only companies can attach users to groups.

Arguments
inputAttachUsersToUserGroupInput!
The details for attaching users to a group.

Example

mutation AttachUsersToUserGroup {
  attachUsersToUserGroup(input: {
    # AttachUsersToUserGroupInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

attributeRecruiterToHire

Type: Hire!

Attribute a recruiter to a hire.

Only companies can attribute recruiters to their hires.

Arguments
inputAttributeRecruiterToHireInput!
The input required for attributing a recruiter to a hire.

Example

mutation AttributeRecruiterToHire {
  attributeRecruiterToHire(input: {
    # AttributeRecruiterToHireInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

attributeSupplierToHire

Type: Hire!

Attribute a supplier (Company or Recruiter) to a hire.

Only companies can attribute suppliers to their hires.

Arguments
inputAttributeSupplierToHireInput!
The input required for attributing a supplier to a hire.

Example

mutation AttributeSupplierToHire {
  attributeSupplierToHire(input: {
    # AttributeSupplierToHireInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

blockTrustedContact

Type: TrustedContact!

Block an applied trusted contact.

Only companies can block trusted contacts.

Arguments
inputBlockTrustedContactInput!
The details of the trusted contact to be blocked.

Example

mutation BlockTrustedContact {
  blockTrustedContact(input: {
    # BlockTrustedContactInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

cancelHire

Type: Hire!

Cancel a hire.

Only companies can cancel their hires.

Arguments
inputCancelHireInput!
The input required for canceling a hire.

Example

mutation CancelHire {
  cancelHire(input: {
    # CancelHireInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

changeEmail

Type: User!

Change the email of the currently authenticated user.

Arguments
inputChangeEmailInput!
The input for changing the email.

Example

mutation ChangeEmail {
  changeEmail(input: {
    # ChangeEmailInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

createApproval

Type: Approval!

Create an approval flow.

Only companies can create approvals. An approval defines a review process that is automatically triggered when certain events occur (e.g. a hire is created or a contract changes). Once created, add approval rules to define the conditions and approvers for the flow.

Arguments
inputCreateApprovalInput!
The details for the new approval flow.

Example

mutation CreateApproval {
  createApproval(input: {
    # CreateApprovalInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

createApprovalRule

Type: ApprovalRule!

Add a rule to an approval flow.

A rule defines the conditions under which an approval is required. Each rule contains one or more variable conditions (e.g. “hourly rate > 100”) that are evaluated when the trigger event fires. After creating the rule, use createApprover to assign user groups who will review matching items.

Arguments
inputCreateApprovalRuleInput!
The details for the new approval rule.

Example

mutation CreateApprovalRule {
  createApprovalRule(input: {
    # CreateApprovalRuleInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

createApprover

Type: Approver!

Assign a user group as an approver on an approval rule.

Approvers are processed in position order — position 1 is asked to approve first, then position 2, and so on. Each approver is a user group whose members can act on the approval request.

Arguments
inputCreateApproverInput!
The details for the new approver assignment.

Example

mutation CreateApprover {
  createApprover(input: {
    # CreateApproverInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

createBatch

Type: Batch

Create a new batch of items for processing.

Arguments
inputCreateBatchInput!
The details for the new batch.

Example

mutation CreateBatch {
  createBatch(input: {
    # CreateBatchInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

createCompanyRecruiter

Type: CompanyRecruiter

Add and invite a new recruiter.

Only companies can add and invite recruiters.

Arguments
inputCreateCompanyRecruiterInput!
The details for adding & inviting the recruiter.

Example

mutation CreateCompanyRecruiter {
  createCompanyRecruiter(input: {
    # CreateCompanyRecruiterInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

createCustomField

Type: CustomField!

Create a custom field.

Arguments
inputCreateCustomFieldInput!
The input for creating a custom field.

Example

mutation CreateCustomField {
  createCustomField(input: {
    # CreateCustomFieldInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

createCustomTimesheet

Type: CreateCustomTimeSheetResponse!

Create a custom timesheet.

Use this endpoint to create timesheets in Worksome from a custom data format. The endpoint requires data in a custom format, as defined by the input schema.

Arguments
inputCreateCustomTimesheetInput!
The details for creating a custom timesheet.

Example

mutation CreateCustomTimesheet {
  createCustomTimesheet(input: {
    # CreateCustomTimesheetInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

createDraftHire

Type: Hire!

Create a draft hire for a trusted contact.

Only companies can make hires. The worker must already be a trusted contact of the hiring company. A job is optional — if omitted, one will be created automatically from the provided details.

Draft hires must be completed in the Worksome UI before they become active, such as applicable compliance checks. The hire will start in DRAFT status and progress through the lifecycle once all required steps are finished.

Arguments
inputHireInput!
The input required for creating a draft hire.

Example

mutation CreateDraftHire {
  createDraftHire(input: {
    # HireInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

createExport

Type: CreateExportResponse

Create an export.

The export URL and the number of rows will be returned (excluding headings).

Arguments
inputCreateExportInput!
The input for creating an export.

Example

mutation CreateExport {
  createExport(input: {
    # CreateExportInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

createJob

Type: Job!

Create a job with minimal required fields.

Only companies can create jobs. The job is created in DRAFT status with just a title, skills, and owner. Use updateJob to set the full details (description, rates, dates, location, etc.) and to publish the job.

Arguments
inputCreateJobInput!
The minimal details for the new job.

Example

mutation CreateJob {
  createJob(input: {
    # CreateJobInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

createJobCandidate

Type: [JobCandidate!]!

Create a job candidate.

This will make the workers eligible and proposed for a job.

Arguments
inputCreateJobCandidateInput!
Input data to create the job candidate.

Example

mutation CreateJobCandidate {
  createJobCandidate(input: {
    # CreateJobCandidateInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

createJobShare

Type: [JobShare!]!

Create a job share.

Arguments
inputCreateJobShareInput!
The details for the job share.

Example

mutation CreateJobShare {
  createJobShare(input: {
    # CreateJobShareInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

createMilestones

Type: [Milestone!]!

Create one or more milestones.

Arguments
inputCreateMilestonesInput!
The details for the new milestones.

Example

mutation CreateMilestones {
  createMilestones(input: {
    # CreateMilestonesInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

createNote

Type: Note!

Create a note.

Arguments
inputCreateNoteInput!
The details for creating a note.

Example

mutation CreateNote {
  createNote(input: {
    # CreateNoteInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

createPassword

Type: User!

Create a password for the authenticated user.

This operation is only allowed if the user currently does not have a password for changing the password see updatePassword operation instead.

Arguments
inputCreatePasswordInput!
The input for creating a password.

Example

mutation CreatePassword {
  createPassword(input: {
    # CreatePasswordInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

createPaymentRequest

Type: PaymentRequest!

Create a payment request.

Arguments
inputCreatePaymentRequestInput!
The details for creating a payment request.

Example

mutation CreatePaymentRequest {
  createPaymentRequest(input: {
    # CreatePaymentRequestInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

createProject

Type: Project!

Create a project.

Only companies can create projects.

Arguments
inputCreateProjectInput!
The details for creating a project.

Example

mutation CreateProject {
  createProject(input: {
    # CreateProjectInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

createRecruiterCandidate

Type: RecruiterCandidate

Add and invite a new candidate.

Only recruiters can add and invite candidates.

Arguments
inputCreateRecruiterCandidateInput!
The details for adding & inviting the candidate.

Example

mutation CreateRecruiterCandidate {
  createRecruiterCandidate(input: {
    # CreateRecruiterCandidateInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

createSmsMultiFactor

Type: SmsCreateMultiFactorPayload!

Create a new multi-factor authentication implementation.

Arguments
inputCreateSmsMultiFactorInput!
The details for the new SMS multi-factor authentication implementation.

Example

mutation CreateSmsMultiFactor {
  createSmsMultiFactor(input: {
    # CreateSmsMultiFactorInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

createSupplierCandidate

Type: SupplierCandidate

Add and invite a new supplier candidate.

Only accounts that act as suppliers can add candidates.

Arguments
inputCreateSupplierCandidateInput!
The details for adding & inviting the candidate.

Example

mutation CreateSupplierCandidate {
  createSupplierCandidate(input: {
    # CreateSupplierCandidateInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

createTimesheet

Type: Timesheet

Create a timesheet.

Only workers can create timesheets.

Arguments
inputCreateTimesheetInput!
The details for the new timesheet.

Example

mutation CreateTimesheet {
  createTimesheet(input: {
    # CreateTimesheetInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

createTotpMultiFactor

Type: TotpCreateMultiFactorPayload!

Create a new multi-factor authentication implementation.

Arguments
inputCreateTotpMultiFactorInput!
The details for the new TOTP multi-factor authentication implementation.

Example

mutation CreateTotpMultiFactor {
  createTotpMultiFactor(input: {
    # CreateTotpMultiFactorInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

createTrustedContact

Type: TrustedContact!

Add and invite a new trusted contact.

Only companies can add & invite trusted contacts.

Arguments
inputCreateTrustedContactInput!
The details for adding & inviting the trusted contact.

Example

mutation CreateTrustedContact {
  createTrustedContact(input: {
    # CreateTrustedContactInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

createUserGroup

Type: UserGroup!

Create a user group.

Only companies can create user groups.

Arguments
inputCreateUserGroupInput!
The details for creating a group.

Example

mutation CreateUserGroup {
  createUserGroup(input: {
    # CreateUserGroupInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

createWebhook

Type: Webhook!

Create a webhook.

Only companies can create webhooks.

Arguments
inputCreateWebhookInput!
The input required for creating a webhook.

Example

mutation CreateWebhook {
  createWebhook(input: {
    # CreateWebhookInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

createWorkflow

Type: Workflow!

Create an approval workflow as a complete tree in a single operation.

Only companies can create workflows. This is the recommended way to set up an approval flow — it creates the approval (root), its rules (conditions), and approvers (user groups) all at once, rather than calling createApproval, createApprovalRule, and createApprover separately.

The input is structured as a tree: a root node (the approval definition), rule nodes (conditions), and approver nodes (user groups). Nodes reference each other via temporary id and parent/children fields.

Arguments
inputCreateWorkflowInput!
The complete workflow tree: root approval, rules, and approvers.

Example

mutation CreateWorkflow {
  createWorkflow(input: {
    # CreateWorkflowInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

deleteCompanyRecruiter

Type: CompanyRecruiter

Delete a recruiter relationship.

Both the company and the recruiter can delete the relationship.

Arguments
inputDeleteCompanyRecruiterInput!
The details of the recruiter relationship to be deleted.

Example

mutation DeleteCompanyRecruiter {
  deleteCompanyRecruiter(input: {
    # DeleteCompanyRecruiterInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

deleteCustomField

Type: CustomField!

Delete a custom field.

All fields details must be provided.

Arguments
inputDeleteCustomFieldInput!
“ The input for deleting a custom field.

Example

mutation DeleteCustomField {
  deleteCustomField(input: {
    # DeleteCustomFieldInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

deleteMilestones

Type: [Milestone!]!

Delete one or more milestones.

Arguments
inputDeleteMilestonesInput!
The details for the milestone to delete.

Example

mutation DeleteMilestones {
  deleteMilestones(input: {
    # DeleteMilestonesInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

deleteNote

Type: Note!

Delete a note.

Arguments
inputDeleteNoteInput!
The details for deleting a note.

Example

mutation DeleteNote {
  deleteNote(input: {
    # DeleteNoteInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

deletePaymentRequest

Type: PaymentRequest!

Delete a payment request.

Arguments
inputDeletePaymentRequestInput!
The details for deleting a payment request.

Example

mutation DeletePaymentRequest {
  deletePaymentRequest(input: {
    # DeletePaymentRequestInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

deleteProject

Type: Project!

Soft delete a project.

Only companies can delete projects.

Arguments
inputDeleteProjectInput!
The details for deleting a project.

Example

mutation DeleteProject {
  deleteProject(input: {
    # DeleteProjectInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

deleteRecruiterCandidate

Type: RecruiterCandidate

Delete a recruiter candidate relationship.

Both the recruiter and the candidate can delete the relationship.

Arguments
inputDeleteRecruiterCandidateInput!
The details of the recruiter candidate relationship to be deleted.

Example

mutation DeleteRecruiterCandidate {
  deleteRecruiterCandidate(input: {
    # DeleteRecruiterCandidateInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

deleteSupplierCandidate

Type: SupplierCandidate

Delete a supplier candidate.

Only the owning supplier can delete a candidate.

Arguments
inputDeleteSupplierCandidateInput!
The details of the supplier candidate to delete.

Example

mutation DeleteSupplierCandidate {
  deleteSupplierCandidate(input: {
    # DeleteSupplierCandidateInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

deleteTimesheet

Type: Timesheet!

Delete a timesheet.

Only workers can delete timesheets.

Arguments
inputDeleteTimesheetInput!
The details for the timesheet.

Example

mutation DeleteTimesheet {
  deleteTimesheet(input: {
    # DeleteTimesheetInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

deleteTimesheetRegistration

Type: TimesheetRegistration!

Delete a timesheet registration.

Only workers can delete timesheet registrations.

Arguments
inputDeleteTimesheetRegistrationInput!
The details for the timesheet registration.

Example

mutation DeleteTimesheetRegistration {
  deleteTimesheetRegistration(input: {
    # DeleteTimesheetRegistrationInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

deleteTrustedContact

Type: TrustedContact

Delete a trusted contact.

Only companies can delete trusted contacts.

Arguments
inputDeleteTrustedContactInput!
The details of the trusted contact to be soft deleted.

Example

mutation DeleteTrustedContact {
  deleteTrustedContact(input: {
    # DeleteTrustedContactInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

deleteUserGroup

Type: UserGroup!

Soft delete a user group.

Only companies can delete user groups.

Arguments
inputDeleteUserGroupInput!
The details for deleting a user group.

Example

mutation DeleteUserGroup {
  deleteUserGroup(input: {
    # DeleteUserGroupInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

deleteWebhook

Type: Webhook!

Delete a webhook.

Arguments
inputDeleteWebhookInput!
The input required for deleting a webhook.

Example

mutation DeleteWebhook {
  deleteWebhook(input: {
    # DeleteWebhookInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

deleteWorkflow

Type: Workflow!

Delete an approval workflow.

Only companies can delete workflows. If the workflow has no existing approval requests, it is permanently removed along with its rules and approvers. If it has existing approval requests, the workflow is archived instead — its rules and approvers are preserved, but it will no longer evaluate new events.

Arguments
inputDeleteWorkflowInput!
The ID of the workflow to delete.

Example

mutation DeleteWorkflow {
  deleteWorkflow(input: {
    # DeleteWorkflowInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

detachJobFromProject

Type: Project!

Detach a job from a project

Only companies can detach a job from a project.

Arguments
inputDetachJobFromProjectInput!
The details for attaching a job to a project.

Example

mutation DetachJobFromProject {
  detachJobFromProject(input: {
    # DetachJobFromProjectInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

detachUsersFromUserGroup

Type: UserGroup!

Detach one or more user from a group.

Only companies can detach users from a group.

Arguments
inputDetachUsersFromUserGroupInput!
The details for detaching users from a group.

Example

mutation DetachUsersFromUserGroup {
  detachUsersFromUserGroup(input: {
    # DetachUsersFromUserGroupInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

duplicateJob

Type: Job!

Duplicate a job.

Creates a copy of the job with all its details (description, skills, location, budget, etc.) Only companies can duplicate jobs.

Arguments
inputDuplicateJobInput!
The details for duplicating the job.

Example

mutation DuplicateJob {
  duplicateJob(input: {
    # DuplicateJobInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

endJob

Type: Job!

End a job.

Only companies can end jobs.

Arguments
inputEndJobInput!
The details to end the job.

Example

mutation EndJob {
  endJob(input: {
    # EndJobInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

endProject

Type: Project!

End a project.

This is used to set an end date on the project to consider it no longer active.

Arguments
inputEndProjectInput!
The details for ending a project.

Example

mutation EndProject {
  endProject(input: {
    # EndProjectInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

forwardCandidate

Type: JobCandidate!

Present a candidate to a linked job with a specified rate.

Arguments
inputForwardCandidateInput!
Input data to forward a candidate.

Example

mutation ForwardCandidate {
  forwardCandidate(input: {
    # ForwardCandidateInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

generateInviteLink

Type: Company!

Generate the company invite link token.

Arguments
inputGenerateInviteLinkInput!
The input required to generate the company invite link token.

Example

mutation GenerateInviteLink {
  generateInviteLink(input: {
    # GenerateInviteLinkInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

generatePersonalInviteLink

Type: String!

Generate or regenerate a personal invite link for the authenticated user.

This URL allows workers to join as trusted contacts with auto-approval. Only company members can generate personal invite links.

Arguments
inputGeneratePersonalInviteLinkInput!
The company for which to generate the personal invite link.

Example

mutation GeneratePersonalInviteLink {
  generatePersonalInviteLink(input: {
    # GeneratePersonalInviteLinkInput fields
  })
}

hire

Type: Hire!

Deprecated

Directly hire a trusted contact without requiring a bid.

Deprecated: use createDraftHire to create draft hires via the public API.

Only companies can make hires. The worker must already be a trusted contact of the hiring company. A job is optional — if omitted, one will be created automatically from the provided details.

Arguments
inputHireInput!
The input required for directly hiring a trusted contact.

Example

mutation Hire {
  hire(input: {
    # HireInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

inviteCandidateToOnboard

Type: JobCandidate!

Use this endpoint to invite a candidate to complete the required Worksome onboarding and compliance information before a hire offer is shared.

Calling this endpoint will: - add the worker to the company’s talent pool if needed - include the worker in the company’s compliance tracker - notify the supplier for supplier-managed workers, so they can complete the required onboarding and compliance steps

Arguments
inputInviteCandidateToOnboardInput!
Input data to invite a candidate to onboard.

Example

mutation InviteCandidateToOnboard {
  inviteCandidateToOnboard(input: {
    # InviteCandidateToOnboardInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

inviteCompanyRecruiter

Type: CompanyRecruiter!

Invite an existing recruiter.

Only companies can invite the recruiter.

Arguments
inputInviteCompanyRecruiterInput!
The details of the recruiter to be invited.

Example

mutation InviteCompanyRecruiter {
  inviteCompanyRecruiter(input: {
    # InviteCompanyRecruiterInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

manageOnboardingDocuments

Type: Company

Manage Onboarding documents.

Arguments
inputManageOnboardingDocumentsInput!
The input required to manage onboarding documents.

Example

mutation ManageOnboardingDocuments {
  manageOnboardingDocuments(input: {
    # ManageOnboardingDocumentsInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

manageRecruiterOnboardingDocuments

Type: Company

Manage staffing agency onboarding documents.

Arguments
inputManageRecruiterOnboardingDocumentsInput!
The input required to manage staffing agency onboarding documents.

Example

mutation ManageRecruiterOnboardingDocuments {
  manageRecruiterOnboardingDocuments(input: {
    # ManageRecruiterOnboardingDocumentsInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

markFilesAsUploaded

Type: [File!]!

Mark one or more files as uploaded to the temporary URL.

Arguments
inputMarkFilesAsUploadedInput!
The input required for marking files as uploaded.

Example

mutation MarkFilesAsUploaded {
  markFilesAsUploaded(input: {
    # MarkFilesAsUploadedInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

onboardEmployment

Type: Employment!

Onboard an employment with optional employment costs.

Arguments
inputOnboardEmploymentInput!
The input for onboarding an employment.

Example

mutation OnboardEmployment {
  onboardEmployment(input: {
    # OnboardEmploymentInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

openProject

Type: Project!

Open a project.

This is used to set the end date on the project to null to make it open again.

Arguments
inputOpenProjectInput!
The details for opening a project.

Example

mutation OpenProject {
  openProject(input: {
    # OpenProjectInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

reinviteTrustedContact

Type: TrustedContact!

Resend an invitation to a Trusted Contact that already exists in the Talent Pool.

This can be used for workers that has not responded to the initial invitation or for workers that was previously managed by a Staffing Agency.

Arguments
inputReinviteTrustedContactInput!
The input for resending an invitation to a Trusted Contact.

Example

mutation ReinviteTrustedContact {
  reinviteTrustedContact(input: {
    # ReinviteTrustedContactInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

rejectHire

Type: Hire!

Reject a hire.

Arguments
inputRejectHireInput!
The input required to reject a hire.

Example

mutation RejectHire {
  rejectHire(input: {
    # RejectHireInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

removeJobShare

Type: [JobShare!]!

Remove a job share.

Arguments
inputRemoveJobShareInput!
The details for removing the job share.

Example

mutation RemoveJobShare {
  removeJobShare(input: {
    # RemoveJobShareInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

removeMultiFactor

Type: MultiFactor

Remove a multi-factor authentication implementation.

Arguments
inputRemoveMultiFactorInput!
The details for removing the multi-factor authentication implementation instance.

Example

mutation RemoveMultiFactor {
  removeMultiFactor(input: {
    # RemoveMultiFactorInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

removeOnboardingDocuments

Type: Company

Remove Onboarding documents.

Arguments
inputRemoveOnboardingDocumentsInput!
The input required to remove onboarding documents.

Example

mutation RemoveOnboardingDocuments {
  removeOnboardingDocuments(input: {
    # RemoveOnboardingDocumentsInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

removeRecruiterFromHire

Type: Hire!

Remove a recruiter from a hire.

Only companies can remove recruiters from their hires.

Arguments
inputRemoveRecruiterFromHireInput!
The input required for removing a recruiter from a hire.

Example

mutation RemoveRecruiterFromHire {
  removeRecruiterFromHire(input: {
    # RemoveRecruiterFromHireInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

removeRecruiterOnboardingDocuments

Type: Company

Remove staffing agency onboarding documents.

Arguments
inputRemoveRecruiterOnboardingDocumentsInput!
The input required to remove staffing agency onboarding documents.

Example

mutation RemoveRecruiterOnboardingDocuments {
  removeRecruiterOnboardingDocuments(input: {
    # RemoveRecruiterOnboardingDocumentsInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

retryWebhookEvent

Type: WebhookEvent!

Retry a webhook event.

Only companies can retry webhook events.

Arguments
inputRetryWebhookEventInput!
The input required for retrying a webhook event.

Example

mutation RetryWebhookEvent {
  retryWebhookEvent(input: {
    # RetryWebhookEventInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

runBatchAction

Type: RunBatchActionResponse!

Run an action on a batch.

Arguments
inputRunBatchActionInput!
The details for the batch action.

Example

mutation RunBatchAction {
  runBatchAction(input: {
    # RunBatchActionInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

sendVerificationEmail

Type: User!

Sends a new verification email.

This operation is only allowed if the user has not verified their email.

Example

mutation SendVerificationEmail {
  sendVerificationEmail {
    __typename
    # ...plus the fields you need
  }
}

setInternalBudgetOnJob

Type: Job!

Set the internal budget of a job.

Only companies can set the internal budget on the job.

Arguments
inputSetInternalBudgetOnJobInput!
The details of internal budget for the job.

Example

mutation SetInternalBudgetOnJob {
  setInternalBudgetOnJob(input: {
    # SetInternalBudgetOnJobInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

shareCandidatesWithPartner

Type: [JobCandidate!]!

[Experimental] Share candidates with the linked partner account.

Arguments
inputShareCandidatesWithPartnerInput!
Input data to share candidates.

Example

mutation ShareCandidatesWithPartner {
  shareCandidatesWithPartner(input: {
    # ShareCandidatesWithPartnerInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

shareHire

Type: Hire!

Share a hire offer with a worker.

Only companies can share hires with workers.

Arguments
inputShareHireInput!
The input required for sharing a hire.

Example

mutation ShareHire {
  shareHire(input: {
    # ShareHireInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

storeBankDetails

Type: BankDetail!

Update the bank account details.

Arguments
inputStoreBankDetailsInput!
The details for updating the bank account record.

Example

mutation StoreBankDetails {
  storeBankDetails(input: {
    # StoreBankDetailsInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

submitCompliance

Type: Compliance!

Submit information for a compliance — e.g. a company reviewing a worker, or a worker filling in form data. Set exactly one field on the input to choose the action; the acting company/user comes from your authenticated session. Returns the updated Compliance.

Arguments
inputSubmitComplianceInput!
The action to perform. Set exactly one field.

Example

mutation SubmitCompliance {
  submitCompliance(input: {
    # SubmitComplianceInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

terminateHire

Type: Hire!

Terminate a hire.

Arguments
inputTerminateHireInput!
The input required for terminating a hire.

Example

mutation TerminateHire {
  terminateHire(input: {
    # TerminateHireInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

updateApproval

Type: Approval!

Update an approval flow.

Updating an approval creates a new version. Only companies that own the approval can update it.

Arguments
inputUpdateApprovalInput!
The fields to update on the approval.

Example

mutation UpdateApproval {
  updateApproval(input: {
    # UpdateApprovalInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

updateApprover

Type: Approver!

Update an approver’s user group or position in the approval sequence.

Arguments
inputUpdateApproverInput!
The fields to update on the approver.

Example

mutation UpdateApprover {
  updateApprover(input: {
    # UpdateApproverInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

updateCompanyRecruiter

Type: CompanyRecruiter

Update a recruiter relationship.

Only companies can edit recruiter relationships.

Arguments
inputUpdateCompanyRecruiterInput!
The details of the recruiter relationship to be updated.

Example

mutation UpdateCompanyRecruiter {
  updateCompanyRecruiter(input: {
    # UpdateCompanyRecruiterInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

updateCustomField

Type: CustomField!

Update a custom field.

All fields must be provided.

Arguments
inputUpdateCustomFieldInput!
The input for updating a custom field.

Example

mutation UpdateCustomField {
  updateCustomField(input: {
    # UpdateCustomFieldInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

updateJob

Type: Job!

Update a job’s details.

Only companies can update jobs. This is the follow-up to createJob — use it to set the full role details (description, rates, dates, location, visibility) and to publish the job when ready.

All fields are optional; only the fields you provide will be updated.

Arguments
inputUpdateJobInput!
The fields to update on the job.

Example

mutation UpdateJob {
  updateJob(input: {
    # UpdateJobInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

updateJobCandidatePreferred

Type: JobCandidate!

Update job candidates “preferred” status.

Arguments
inputUpdateJobCandidatePreferredInput!
Input data to update a job candidate preferred status.

Example

mutation UpdateJobCandidatePreferred {
  updateJobCandidatePreferred(input: {
    # UpdateJobCandidatePreferredInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

updateJobCandidateStatus

Type: JobCandidate!

Update a job candidate status.

A reason and comment can be provided.

Arguments
inputUpdateJobCandidateStatusInput!
Input data to update a job candidates status.

Example

mutation UpdateJobCandidateStatus {
  updateJobCandidateStatus(input: {
    # UpdateJobCandidateStatusInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

updateJobCandidateStep

Type: JobCandidate!

Manually update the hiring step of a job candidate.

Only manual (non-system) steps can be set through this mutation.

Arguments
inputUpdateJobCandidateStepInput!
Input data to update a job candidate’s step.

Example

mutation UpdateJobCandidateStep {
  updateJobCandidateStep(input: {
    # UpdateJobCandidateStepInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

updateMilestones

Type: [Milestone!]!

Update one or more milestones.

Arguments
inputUpdateMilestonesInput!
The details for the milestones to update.

Example

mutation UpdateMilestones {
  updateMilestones(input: {
    # UpdateMilestonesInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

updateNote

Type: Note!

Update a note.

Arguments
inputUpdateNoteInput!
The details for updating a note.

Example

mutation UpdateNote {
  updateNote(input: {
    # UpdateNoteInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

updatePassword

Type: User!

Update a user’s password.

Arguments
inputUpdatePasswordInput!
The input for the user update mutation.

Example

mutation UpdatePassword {
  updatePassword(input: {
    # UpdatePasswordInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

updatePaymentRequest

Type: PaymentRequest!

Update a payment request.

Arguments
inputUpdatePaymentRequestInput!
The details for updating a payment request.

Example

mutation UpdatePaymentRequest {
  updatePaymentRequest(input: {
    # UpdatePaymentRequestInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

updateProject

Type: Project!

Update a project.

Only companies can update projects.

Arguments
inputUpdateProjectInput!
The details for updating a project.

Example

mutation UpdateProject {
  updateProject(input: {
    # UpdateProjectInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

updateRecruiterCandidate

Type: RecruiterCandidate

Update a recruiter candidate information.

Only recruiters can edit the relationship.

Arguments
inputUpdateRecruiterCandidateInput!
The details of the recruiter candidate relationship to be updated.

Example

mutation UpdateRecruiterCandidate {
  updateRecruiterCandidate(input: {
    # UpdateRecruiterCandidateInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

updateSupplierCandidate

Type: SupplierCandidate

Update a supplier candidate.

Only the owning supplier can update a candidate.

Arguments
inputUpdateSupplierCandidateInput!
The details of the supplier candidate to update.

Example

mutation UpdateSupplierCandidate {
  updateSupplierCandidate(input: {
    # UpdateSupplierCandidateInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

updateTimesheet

Type: Timesheet!

Update a timesheet.

Only workers can update timesheets.

Arguments
inputUpdateTimesheetInput!
The details for the timesheet.

Example

mutation UpdateTimesheet {
  updateTimesheet(input: {
    # UpdateTimesheetInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

updateTimesheetRegistration

Type: TimesheetRegistration!

Update a timesheet registration.

Only workers can update timesheet registrations.

Arguments
inputUpdateTimesheetRegistrationInput!
The details for the timesheet registration.

Example

mutation UpdateTimesheetRegistration {
  updateTimesheetRegistration(input: {
    # UpdateTimesheetRegistrationInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

updateTrustedContact

Type: TrustedContact!

Update a trusted contact.

Only companies can edit trusted contacts.

Arguments
inputUpdateTrustedContactInput!
The details of the trusted contact to be edited.

Example

mutation UpdateTrustedContact {
  updateTrustedContact(input: {
    # UpdateTrustedContactInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

updateUserGroup

Type: UserGroup!

Update a user group.

Only companies can update user groups.

Arguments
inputUpdateUserGroupInput!
The details for updating a group.

Example

mutation UpdateUserGroup {
  updateUserGroup(input: {
    # UpdateUserGroupInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

updateWebhook

Type: Webhook!

Update a webhook.

Arguments
inputUpdateWebhookInput!
The input required for updating a webhook.

Example

mutation UpdateWebhook {
  updateWebhook(input: {
    # UpdateWebhookInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

updateWorker

Type: Worker!

Update a worker.

Arguments
inputUpdateWorkerInput!
The details for updating a worker.

Example

mutation UpdateWorker {
  updateWorker(input: {
    # UpdateWorkerInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

updateWorkerCustomFieldValues

Type: UpdateWorkerCustomFieldValuesPayload!

Update custom field values for a fieldable entity as a worker.

Accepts a collection of field values in a single payload. Only fields with workerInputAllowed: true can be updated. Partial updates are supported - fields not included are ignored.

Arguments
inputUpdateWorkerCustomFieldValuesInput!
The input for updating custom field values as a worker.

Example

mutation UpdateWorkerCustomFieldValues {
  updateWorkerCustomFieldValues(input: {
    # UpdateWorkerCustomFieldValuesInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

updateWorkerIdentification

Type: WorkerIdentification!

Save a worker’s identification details.

Arguments
inputUpdateWorkerIdentificationInput!
The identification details to persist.

Example

mutation UpdateWorkerIdentification {
  updateWorkerIdentification(input: {
    # UpdateWorkerIdentificationInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

updateWorkflow

Type: Workflow!

Update an existing approval workflow as a complete tree.

Only companies can update workflows. Replaces the entire workflow structure (root, rules, and approvers) with the provided tree. Creates a new version of the underlying approval.

Arguments
inputUpdateWorkflowInput!
The updated workflow tree.

Example

mutation UpdateWorkflow {
  updateWorkflow(input: {
    # UpdateWorkflowInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

updateWorksomeIntelligenceConsent

Type: Boolean!

Update consent to use Worksome Intelligence for the current user.

Arguments
inputUpdateWorksomeIntelligenceConsentInput!
The input required for consent.

Example

mutation UpdateWorksomeIntelligenceConsent {
  updateWorksomeIntelligenceConsent(input: {
    # UpdateWorksomeIntelligenceConsentInput fields
  })
}

uploadFiles

Type: [TemporaryFileUploadResponse!]!

Generate temporary upload URLs for files for the given account.

The temporary URL will expire after 1 week.

Arguments
input[UploadFileInput!]!
The input required for upload a file.

Example

mutation UploadFiles {
  uploadFiles(input: [{
    # UploadFileInput fields
  }]) {
    __typename
    # ...plus the fields you need
  }
}

verifySmsMultiFactor

Type: SmsMultiFactor

Verify a multi-factor authentication implementation.

Arguments
inputVerifySmsMultiFactorInput!
The details for the verification of the SMS multi-factor authentication implementation.

Example

mutation VerifySmsMultiFactor {
  verifySmsMultiFactor(input: {
    # VerifySmsMultiFactorInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

verifyTotpMultiFactor

Type: TotpMultiFactor

Verify a TOTP multi-factor authentication implementation.

Arguments
inputVerifyTotpMultiFactorInput!
The details for the verification of the TOTP multi-factor authentication implementation.

Example

mutation VerifyTotpMultiFactor {
  verifyTotpMultiFactor(input: {
    # VerifyTotpMultiFactorInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

withdrawForwardedCandidate

Type: JobCandidate!

Reverse of forwardCandidate — withdraws a candidate that was presented to a client. The candidate is removed from the client’s job and the source candidate’s step is set to withdrawn.

Arguments
inputWithdrawForwardedCandidateInput!
Input data to withdraw a forwarded candidate.

Example

mutation WithdrawForwardedCandidate {
  withdrawForwardedCandidate(input: {
    # WithdrawForwardedCandidateInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}

withdrawJobCandidate

Type: JobCandidate!

Withdraw an own submitted candidate from the hiring process. Used by suppliers; moves the candidate to the withdrawn step of its current phase.

Arguments
inputWithdrawJobCandidateInput!
Input data to withdraw a job candidate.

Example

mutation WithdrawJobCandidate {
  withdrawJobCandidate(input: {
    # WithdrawJobCandidateInput fields
  }) {
    __typename
    # ...plus the fields you need
  }
}