model

Documentation

Index

• type Application
• type ApplicationRequisitionForHire
• type ArchiveReason
• type Archived
• type Contact
• type ContactLocation
• type FeedbackForm
• type Interview
• type Interviewer
• type LeverError
  • func (e *LeverError) Error() string
• type Opportunity
• type OpportunityDataProtection
• type OpportunityDataProtectionConsent
• type OpportunityURLs
• type Phone
• type Posting
• type PostingCategories
• type PostingContent
• type PostingURLs
• type Reader
• type Resume
• type ResumeFile
• type ResumeParsedData
• type Source
• type Stage
• type StageChange
• type Tag
• type User

Types

type Application

type Application struct {
	// Application UID
	ID string `json:"id,omitempty"`

	// Opportunity profile associated with an application.
	OpportunityID string `json:"opportunityId,omitempty"`

	// Datestamp when application was created in Lever.
	CreatedAt *int64 `json:"createdAt,omitempty"`

	// An application can be of type referral, user, or posting. Applications of type referral are
	// created when a user refers a candidate for a job posting. Applications have type user when
	// they are applied manually to a posting in Lever. Applications have type posting when a
	// candidate applies to a job posting through your company's jobs page.
	Type string `json:"type,omitempty"`

	// Job posting to apply to candidate.
	PostingID string `json:"posting,omitempty"`

	// Job posting to apply to candidate. Returned if expand=posting is specified.
	Posting *Posting `json:"-"`

	// The owner of the job posting at the time when the candidate applies to that job.
	PostingOwnerID string `json:"postingOwner,omitempty"`

	// The owner of the job posting at the time when the candidate applies to that job. Returned if
	// expand=postingOwner is specified.
	PostingOwner *User `json:"-"`

	// The hiring manager of the job posting at the time when the candidate applies to that job.
	PostingHiringManagerID string `json:"postingHiringManager,omitempty"`

	// The hiring manager of the job posting at the time when the candidate applies to that job.
	// Returned if expand=postingHiringManager is specified.
	PostingHiringManager *User `json:"-"`

	// If the application is of type referral, this is the user who made the referral.
	UserID string `json:"user,omitempty"`

	// If the application is of type referral, this is the user who made the referral. Returned if
	// expand=user is specified.
	User *User `json:"-"`

	// Name of candidate who applied.
	Name string `json:"name,omitempty"`

	// Candidate email
	Email string `json:"email,omitempty"`

	// Candidate phone number
	Phone *Phone `json:"phone,omitempty"`

	// Candidate's current company or organization
	Company string `json:"company,omitempty"`

	// List of candidate links (e.g. personal website, LinkedIn profile, etc.)
	Links []string `json:"links,omitempty"`

	// Any additional comments from candidate included in job application
	Comments string `json:"comments,omitempty"`

	// An array of customized forms. If the application is of type referral, the custom questions
	// will include a referral form. If the application is type posting, the custom questions
	// include customized posting forms.
	CustomQuestions []any `json:"customQuestions,omitempty"`

	// Application archived status
	Archived *Archived `json:"archived,omitempty"`

	// If the application was archived as hired against a requisition, this is the data related to
	// the requisition.
	RequisitionForHire *ApplicationRequisitionForHire `json:"requisitionForHire,omitempty"`
}

When a candidate applies to a job posting, an application is created.

Lever is candidate-centric, meaning that candidates can exist in the system without being applied to a specific job posting. However, almost all candidates are applied to job postings, and thus almost all candidates have one or more applications.

There are three different ways that applications can be created in Lever:

* Through a posting: An application is created when a candidate applies to a job posting through your company's public or internal job site, or is submitted by an agency.

* By a user: A team member at your company manually adds a job posting to a specific candidate in Lever.

* As a referral: A team member at your company refers the candidate into Lever for a specific job posting.

Candidates can be applied to multiple job postings, meaning that candidates can have multiple applications. A candidate or contact may have multiple applications, each of which will be on a unique Opportunity. An Opportunity will have no more than one Application.

type ApplicationRequisitionForHire

type ApplicationRequisitionForHire struct {
	// The Lever id of the requisition against which the application was hired
	ID string `json:"id,omitempty"`

	// The requisitionCode field from the requisition.
	RequisitionCode string `json:"requisitionCode,omitempty"`

	// The Lever user id of the hiring manager specified on the requisition, if any.
	HiringManagerIdOnHire string `json:"hiringManagerOnHire,omitempty"`
}

Data related to an application requisition.

TODO: Determine whether this struct should be shared with other models.

type ArchiveReason

type ArchiveReason struct {
	// Archive reason UID
	ID string `json:"id,omitempty"`

	// The name of the archive reason as shown in the Lever interface.
	Text string `json:"text,omitempty"`

	// The status of the archive reason. Can be either active or inactive.
	Status string `json:"status,omitempty"`

	// The type of the archive reason. Can be either hired or non-hired.
	Type string `json:"type,omitempty"`
}

Archive reasons provide granularity behind to candidates who have exited your active hiring pipeline.

Candidates exit your active pipeline either due to being hired at your company or due to being rejected for a specific reason. These dispositions allow you to track each and every candidate who is no longer active within your pipeline.

type Archived

type Archived struct {
	// Datetime when application was last archived in Lever
	ArchivedAt *int64 `json:"archivedAt,omitempty"`

	// Reason why application was last archived
	ReasonID string `json:"reason,omitempty"`
}

Archived status.

type Contact

type Contact struct {
	// Contact UID
	ID string `json:"id,omitempty"`

	// Name of the contact
	Name string `json:"name,omitempty"`

	// Contact headline, typically a list of previous companies where the contact has worked or
	// schools that the contact has attended
	Headline string `json:"headline,omitempty"`

	// The current location of the contact
	Location *ContactLocation `json:"location,omitempty"`

	// Emails that the contact can be reached at
	Emails []string `json:"emails,omitempty"`

	// Indicates whether a contact has been anonymized. Anonymized contacts have their personal
	// information removed. Non-personal metadata may remain for accurate reporting purposes.
	IsAnonymized bool `json:"isAnonymized,omitempty"`

	// Phone numbers
	Phones []Phone `json:"phones,omitempty"`
}

A contact represents the person associated with one or more opportunities and the various methods to contact them.

type ContactLocation

type ContactLocation struct {
	// A single line description of the location
	Name string `json:"name,omitempty"`
}

The current location of the contact.

TODO: Determine whether this struct should be shared with other models.

type FeedbackForm

type FeedbackForm struct {
	// Form UID.
	ID string

	// Form type. Feedback forms are of type interview.
	Type string

	// Form title. This can be edited in Feedback and Form Settings.
	Text string

	// Form instructions.
	Instructions string

	// Form template UID. This form represents a completed form template.
	BaseTemplateID string

	// An array of form fields. Feedback forms support the follow field types:
	//     - code - for programming questions
	//     - date - special field for dates
	//     - dropdown - a dropdown menu
	//     - multiple choice - choose only one
	//     - multiple select - choose 1 or more
	//     - score system - overall candidate rating
	//     - score - thumbs up / thumbs down format
	//     - scorecard - customized evaluation for multiple skills
	//     - text - single line answer
	//     - textarea - longer form answer
	//     - yes/no - a yes or no question
	Forms []any

	// The user ID who completed and submitted the feedback.
	UserID string

	// The user who completed and submitted the feedback. Returned if expand=user is specified.
	User *User

	// The interview panel that the feedback is associated with, if the feedback is associated with
	// an interview.
	PanelID string

	// The interview for which the feedback was submitted. Manually added feedback forms will not
	// be associated with an interview.
	InterviewID string

	// Datetime when form was created.
	CreatedAt *int64

	// This value is null when the updatedAt property has not been previously set. This is likely
	// to occur for feedback that were created prior to the introduction of this property, and have
	// not since been updated.
	UpdatedAt *int64

	// Datetime when form was completed.
	CompletedAt *int64

	// Datetime when form was deleted.
	DeletedAt *int64
}

Feedback forms are added to Opportunities as they are completed after interviews by interviewers or they can be manually added directly to the profile.

type Interview

type Interview struct {
	// Interview UID
	ID string

	// Interview Panel UID
	PanelID string

	// Interview subject
	Subject string

	// Interview note
	Note string

	// Array of interviewers
	Interviewers []Interviewer

	// Name of timezone in which interview was scheduled to occur.
	Timezone string

	// Datetime when interview was created.
	CreatedAt *int64

	// Datetime when interview is scheduled to occur.
	Date *int64

	// Interview duration in minutes
	Duration int

	// Interview location. Usually the name of a booked conference room but can also be a phone
	// number to call.
	Location string

	// The feedback form template selected for this interview.
	FeedbackTemplateID string

	// The feedback forms IDs associated with this interview.
	FeedbackFormIDs []string

	// The feedback forms associated with this interview. Returned if expand=feedbackForms is
	// specified.
	FeedbackForms []FeedbackForm

	// Frequency of feedback reminders (i.e. once, daily, frequently, none). Defaults to
	// 'frequently' which is every 6 hours.
	FeedbackReminder string

	// The user ID who created the interview.
	UserID string

	// The user who created the interview. Returned if expand=user is specified.
	User *User

	// The stage ID in which the candidate resided when this interview was scheduled.
	StageID string

	// The stage in which the candidate resided when this interview was scheduled. Returned if
	// expand=stage is specified.
	Stage *Stage

	// Datetime when interview was canceled. Value is nil if interview was never canceled.
	CanceledAt *int64

	// List of job posting IDs that the interview is associated with
	PostingIDs []string

	// List of job postings that the interview is associated with. Returned if expand=postings is
	// specified.
	Postings []Posting
}

Individual interviews can be returned on this endpoint. Interviews are also contained in interview panels, and can be updated via the Panels endpoint.

type Interviewer

type Interviewer struct {
	// User UID
	ID string `json:"id,omitempty"`

	// User's name
	Name string `json:"name,omitempty"`

	// User's email
	Email string `json:"email,omitempty"`
}

Interviewer is a user who is scheduled to conduct an interview.

type LeverError

type LeverError struct {
	HTTPResponse *http.Response `json:"-"`
	Code         string         `json:"code"`
	Message      string         `json:"message"`
}

Lever error response

func (*LeverError) Error

func (e *LeverError) Error() string

type Opportunity

type Opportunity struct {
	// Opportunity UID
	ID string

	// Contact full name
	Name string

	// Contact headline, typically a list of previous companies where the contact has worked or
	// schools that the contact has attended
	Headline string

	// Contact UID
	ContactID string

	// The stage ID of this Opportunity's current stage
	StageID string

	// The stage of this Opportunity's current stage. Returned if expand=stage is specified.
	Stage *Stage

	// An array of historical stage changes for this Opportunity
	StageChanges []StageChange

	// The confidentiality of the opportunity. An opportunity can only be confidential if it is
	// associated with a confidential job posting. Learn more about confidential data in the API.
	// Can be one of the following values: non-confidential, confidential.
	Confidentiality string

	// Contact current location
	Location string

	// Contact phone number(s)
	Phones []Phone

	// Contact emails
	Emails []string

	// List of Contact links (e.g. personal website, LinkedIn profile, etc.)
	Links []string

	// Opportunity archived status
	Archived *Archived

	// An array containing a list of tags for this Opportunity. Tags are specified as strings,
	// identical to the ones displayed in the Lever interface.
	Tags []string

	// An array of source strings for this Opportunity.
	Sources []string

	// The user ID of the user who created the opportunity.
	SourcedByID string

	// The user who created the opportunity. Returned if expand=sourcedBy is specified.
	SourcedBy *User

	// The way this Opportunity was added to Lever. Can be one of the following values: "agency",
	// "applied", "internal", "referred", "sourced", "university"
	Origin string

	// The user ID of the owner of this Opportunity.
	OwnerID string

	// The owner of this Opportunity. Returned if expand=owner is specified.
	Owner *User

	// An array of user IDs of the followers of this Opportunity.
	FollowerIDs []string

	// An array of users who are following this Opportunity. Returned if expand=followers is
	// specified.
	Followers []User

	// An array, containing up to one Application ID (can be either an active or archived
	// Application). Each Opportunity can only have up to one application.
	ApplicationIDs []string

	// Datetime when this Opportunity was created in Lever. For candidates who applied to a job
	// posting on your website, the date and time when the Opportunity was created in Lever is the
	// moment when the candidate clicked the "Apply" button on their application.
	CreatedAt *int64

	// Datetime when this Opportunity was updated in Lever. This property is updated when the
	// following fields are modified: applications, archived, confidentiality, contact,
	// dataProtection, emails, followers, headline, isAnonymized, lastAdvancedAt,
	// lastInteractionAt, links, location, name, origin, owner, phones, snoozedUntil, sourcedBy,
	// sources, stage, stageChanges, tags. It is also updated when the following fields on the
	// expanded applications object are modified: archived, candidateId, comments, company,
	// customQuestions, email, links, name, opportunityId, phone, postingId, postingHiringManager,
	// postingOwner, primarySource, requisitionForHire, secondarySources, type, user.
	//
	// WARNING: The dataProtection status is based on candidate-provided consent and applicable
	// data policy regulations which can change according to many factors. The updatedAt field is
	// only updated when the candidate-provided consent changes.
	//
	// This value is null when the updatedAt property has not been previously set. This is likely
	// to occur for opportunities that were created prior to the introduction of this property,
	// and have not since been updated.
	UpdatedAt *int64

	// Datetime when the last interaction with this Opportunity profile occurred.
	LastInteractionAt *int64

	// Datetime when the candidate advanced to the pipeline stage where they are currently located
	// in your hiring process for this Opportunity
	LastAdvancedAt *int64

	// If this Opportunity is snoozed, the timestamp will reflect the datetime when the snooze
	// period ends
	SnoozedUntil *int64

	// An object containing the list and show urls for this Opportunity.
	URLs *OpportunityURLs

	// An object containing a candidate's data protection status based on candidate-provided
	// consent and applicable data policy regulations. If there is no policy in place or if no
	// policies apply to the candidate, value is null. (shared by contact)
	DataProtection *OpportunityDataProtection

	// Indicates whether an Opportunity has been anonymized. When all of a contact’s Opportunities
	// have been anonymized, the contact is fully anonymized and their personal information is
	// removed. Non-personal metadata may remain for accurate reporting purposes.
	IsAnonymized bool

	// User ID of the user who deleted the Opportunity. Note that this attribute only appears for
	// deleted Opportunities.
	DeletedByID string

	// Timestamp for when the Opportunity was deleted. Note that this attribute only appears for
	// deleted Opportunities.
	DeletedAt *int64

	// The posting location associated with the opportunity. Can be “unspecified” if not selected,
	// or absent for opportunities not associated with a posting, or for a posting that currently
	// has no location.
	OpportunityLocation string
}

Opportunities

"Candidates" are individuals who have been added to your Lever account as potential fits for your open job positions. "Opportunities" represent each of an individual’s unique candidacies or journeys through your pipeline for a given job position, meaning a single Candidate can be associated with multiple Opportunities. A “Contact” is a unique individual who may or may not have multiple candidacies or Opportunities.

Candidates enter your pipeline for a new Opportunity by:

* Applying to a posting on your jobs site

* Being added by an external recruiting agency

* Being referred by an employee

* Being manually added by a Lever user, or

* Being sourced from an online profile.

Each Opportunity can have their own notes, feedback, interview schedules, and additional forms. An opportunity may be “confidential” if it is moving through your pipeline for a job posting that has been created as confidential. Opportunities exit your pipeline by being archived for one of two reasons: (1) The candidate was rejected for the opportunity, or (2) The candidate was hired for the opportunity.

A "Contact" is an object that our application uses internally to identify an individual person and their personal or contact information, even though they may have multiple opportunities. From this API, the "Contact" is exposed via the contact field, which returns the unique ID for a Contact across your account. Contact information will be shared and consistent across an individual person's opportunities, and will continue to be aggregated onto individual opportunities in the responses to all GET and POST requests to /opportunities.

WARNING: These Opportunities endpoints should be used instead of the now deprecated Candidates endpoints. Prior to the migration, for any given Candidate, the candidateId you would use for a request to a Candidates endpoint can be used as the opportunityId in a request to the corresponding Opportunities endpoint.

Going forward, the contact field is the unique identifier for a Contact or an individual person in Lever, so all integrations should be built and updated using the contact as the unique person identifier and opportunityId as a specific opportunity or candidacy moving through the pipeline.

type OpportunityDataProtection

type OpportunityDataProtection struct {
	// The candidate's consent status for contacting them.
	Contact *OpportunityDataProtectionConsent `json:"contact,omitempty"`

	// The candidate's consent status for storing their data
	Store *OpportunityDataProtectionConsent `json:"store,omitempty"`
}

An object containing a candidate's data protection status based on candidate-provided consent and applicable data policy regulations.

TODO: Determine whether this struct should be shared with other models.

type OpportunityDataProtectionConsent

type OpportunityDataProtectionConsent struct {
	// True if the applicable data policy regulation allows for storage of this record.
	Allowed bool `json:"allowed,omitempty"`

	// Timestamp of when this permission expires.
	ExpiresAt *int64 `json:"expiresAt,omitempty"`
}

An object representing the consent status for a processing activity

TODO: Determine whether this struct should be shared with other models.

type OpportunityURLs

type OpportunityURLs struct {
	// URL that points to the account's list of candidates
	List string `json:"list,omitempty"`

	// URL that points to the candidate's profile page for this Opportunity
	Show string `json:"show,omitempty"`
}

An object containing the list and show urls for this Opportunity.

TODO: Determine whether this struct should be shared with other models.

type Phone

type Phone struct {
	// One of 'other', 'home', 'mobile', 'work', 'skype'
	Type string `json:"type,omitempty"`

	// The phone number.
	Value string `json:"value,omitempty"`
}

Phone number.

type Posting

type Posting struct {
	// Posting UID
	ID string `json:"id,omitempty"`

	// Title of the job posting
	Text string `json:"text,omitempty"`

	// Datetime when posting was created in Lever
	CreatedAt *int64 `json:"createdAt,omitempty"`

	// Datetime when posting was last updated
	UpdatedAt *int64 `json:"updatedAt,omitempty"`

	// Posting's current status
	State string `json:"state,omitempty"`

	// Array of job sites that a published posting appears on.
	DistributionChannels []string `json:"distributionChannels,omitempty"`

	// The confidentiality of the posting. It is not possible to update a posting’s
	// confidentiality. Can be one of the following values: non-confidential, confidential.
	Confidentiality string `json:"confidentiality,omitempty"`

	// The user ID of the user who created the posting.
	UserID string `json:"user,omitempty"`

	// The user who created the posting. Returned if expand=user is specified.
	User *User `json:"-"`

	// The user ID of the posting owner. The posting owner is the individual who is directly
	// responsible for managing all candidates who are applied to that role.
	OwnerID string `json:"owner,omitempty"`

	// The posting owner. Returned if expand=owner is specified.
	Owner *User `json:"-"`

	// The user ID of the hiring manager for the job posting.
	HiringManagerID string `json:"hiringManager,omitempty"`

	// The hiring manager for the job posting. Returned if expand=hiringManager is specified.
	HiringManager *User `json:"-"`

	// An object containing the tags of various categories.
	Categories *PostingCategories `json:"categories,omitempty"`

	// An array of additional posting tags.
	Tags []string `json:"tags,omitempty"`

	// Content of the job posting including any custom questions that you've built into the job
	// application.
	Content *PostingContent `json:"content,omitempty"`

	// An ISO 3166-1 alpha-2 code for a country / territory
	Country string `json:"country,omitempty"`

	// An array of user IDs of the followers of this posting.
	FollowerIds []string `json:"followers,omitempty"`

	// An array of users who are following this posting. Returned if expand=followers is specified.
	Followers []User `json:"-"`

	// Requisition code associated with this posting.
	// WARNING: This field is deprecated but maintained for backwards compatibility.
	RequisitionCode string `json:"requisitionCode,omitempty"`

	// Array of requisition codes associated with this posting.
	RequisitionCodes []string `json:"requisitionCodes,omitempty"`

	// An object containing the list, show and apply URLs for the job posting.
	URLs *PostingURLs `json:"urls,omitempty"`

	// Workplace type of this posting. Defaults to 'unspecified'. Can be one of the following
	// values: onsite, remote, hybrid
	WorkplaceType string `json:"workplaceType,omitempty"`
}

Job postings organize candidates based on the specific roles that they may fit into on your growing team.

There are four different states of job postings: published, internal, closed, and draft. NOTE: In the Lever app, we refer to internal postings as “unlisted” postings. For organizations that have enabled job posting approvals, there are two additional states: pending and rejected.

* published job postings are postings that appear on your public job site, internal job site, or both, depending on which distribution channels you have configured. You'll want to mark a job posting as published when you would like the posting to appear on one or more of your job sites.

* internal job postings are postings that will NOT appear on your public or internal job sites. In the Lever app, internal postings are referred to as “unlisted” postings. You can, however, apply candidates to these internal postings. In addition, anyone with the link to an internal posting can apply, and people can refer candidates to any internal postings.

* closed job postings are postings that will NOT appear on your public or internal job sites, likely because they are roles that you've already filled! You'll want to keep a job posting in the closed state instead of deleting it so that you can easily build reports on this specific job posting. If you and your team re-open the role, you can always move a closed posting back to published or internal.

* draft job postings are postings that you are still in the process of finalizing. draft postings will NOT appear on your public or internal job sites. Once you've finalized a draft job posting, you'll want to change the state of the posting to published or internal.

* pending job postings are postings that are awaiting approval. This state is applicable for organizations that are using the job posting approval workflows in Lever.

* rejected job postings are postings that were submitted for approval and rejected. This state is applicable for organizations that are using the job posting approval workflows in Lever.

type PostingCategories

type PostingCategories struct {
	// Tag for the team to which the job posting belongs (e.g. Sales, Engineering)
	Team string `json:"team,omitempty"`

	// Tag for the department to which the job posting's team belongs, if present
	Department string `json:"department,omitempty"`

	// Tag for job position location
	Location string `json:"location,omitempty"`

	// An array of strings containing all the locations associated with the posting.
	AllLocations []string `json:"allLocations,omitempty"`

	// Tag for job position work type (e.g. Full-time, Part-time, Internship)
	Commitment string `json:"commitment,omitempty"`

	// Tag for job posting level (e.g. Senior, Junior).
	// Deprecated but currently maintained for backward compatibility.
	Level string `json:"level,omitempty"`
}

An object containing the tags of various categories.

type PostingContent

type PostingContent struct {
	// Job posting description that is shown at the top of the jobs pagem, as plaintext.
	Description string `json:"description,omitempty"`

	// Job posting description that is shown at the top of the jobs page.
	DescriptionHtml string `json:"descriptionHtml,omitempty"`

	// Lists of requirements, responsibilities, etc. that have been added to this posting
	Lists []struct {
		// Title of the list.
		Title string `json:"title,omitempty"`

		// Content of the list, as styled HTML.
		Content string `json:"content,omitempty"`
	} `json:"lists,omitempty"`

	// Closing statement on job posting, as plaintext.
	Closing string `json:"closing,omitempty"`

	// Closing statement on job posting, as styled HTML.
	ClosingHtml string `json:"closingHtml,omitempty"`
}

Content of the job posting including any custom questions that you've built into the job application.

TODO: Determine whether this struct should be shared with other models.

type PostingURLs

type PostingURLs struct {
	// URL that points to the account's list of job postings
	List string `json:"list,omitempty"`

	// URL that points to the posting's information page
	Show string `json:"show,omitempty"`

	// URL that points to the posting's apply page
	Apply string `json:"apply,omitempty"`
}

An object containing the list, show and apply urls for the job posting.

TODO: Determine whether this struct should be shared with other models.

type Reader

type Reader struct {
	// The file name
	Name string

	// The file contents
	Contents io.ReadCloser

	// The MIME type for the file.
	MIMEType string
}

Reader provides the contents and the name of a file.

type Resume

type Resume struct {
	// Resume UID
	ID string `json:"id,omitempty"`

	// Datetime when resume was created in Lever. For candidates who applied to a job posting on
	// your website, the date and time when the candidate's resume was created in Lever is the
	// moment when the candidate clicked the "Attach Resume/CV" button on their application.
	CreatedAt *int64 `json:"createdAt,omitempty"`

	// An object containing resume file metadata and download url.
	File *ResumeFile `json:"file,omitempty"`

	// The candidate's parsed resume, usually extracted from an attached PDF/Word document or
	// online profile (LinkedIn, GitHub, AngelList, etc.).
	ParsedData ResumeParsedData `json:"parsedData,omitempty"`
}

Resumes are data about a candidate's work history and/or education. Some resumes may have files associated with them. Resumes can be added to an Opportunity in a number of ways. For example, when (1) the candidate applies to a job posting and uploads a resume (usually this will have a file associated with it), (2) when a recruiter uses the Chrome extension tool via Linkedin, Github, Twitter, etc., (3) the candidate is manually added by a recruiter or (4) a resume file is added directly to an Opportunity from within Lever.

type ResumeFile

type ResumeFile struct {
	// Resume file download URL
	DownloadURL string `json:"downloadUrl,omitempty"`

	// Resume file extension
	Ext string `json:"ext,omitempty"`

	// Resume file name
	Name string `json:"name,omitempty"`

	// Datetime when file was uploaded in Lever
	UploadedAt *int64 `json:"uploadedAt,omitempty"`

	// The status of processing the file. Can be one of the following values: processing,
	// processed, unsupported, error, or null.
	Status string `json:"status,omitempty"`

	// The size of the file in bytes.
	Size *int64 `json:"size,omitempty"`
}

An object containing resume file metadata and download url.

type ResumeParsedData

type ResumeParsedData struct {
	// An array of objects containing various information about positions the candidate has held.
	// This includes company name, location, job title, job summary, and start and end date. This
	// information can be parsed from the candidate's resume, LinkedIn profile, or entered
	// manually.
	Positions []map[string]any `json:"positions,omitempty"`

	// An array of objects containing various information about schools the candidate has attended.
	// This includes the school name, degree, field of study, school summary, and start and end
	// date. This information can be parsed from the candidate's resume, LinkedIn profile, or
	// entered manually.
	Schools []map[string]any `json:"school,omitempty"`
}

The candidate's parsed resume, usually extracted from an attached PDF/Word document or online profile (LinkedIn, GitHub, AngelList, etc.).

type Source

type Source struct {
	// Source text
	Text string `json:"text,omitempty"`

	// Number of candidates tagged with this source
	Count int64 `json:"count,omitempty"`
}

A source is the way that a candidate entered into your Lever account. The most common sources in your Lever account are:

* Posting - Candidate applied to a posting on your careers page.

* Referral - Candidate was referred by an employee at your company.

* Add New - Candidate was added manually into your Lever account in the app.

* Email Applicant - Candidate was added via applicant@hire.lever.co email address.

* Email Lead - Candidate was added via lead@hire.lever.co email address.

* LinkedIn - Candidate was added from LinkedIn using the Lever Chrome Extension.

* GitHub - Candidate was added from GitHub using the Lever Chrome Extension.

* AngelList - Candidate was added from AngelList using the Lever Chrome Extension.

type Stage

type Stage struct {
	// Stage UID
	ID string `json:"id,omitempty"`

	// Title of the stage
	Text string `json:"text,omitempty"`
}

Stages are steps in the recruiting workflow of your hiring pipeline. All candidates belong to a stage and change stages as they progress through the recruiting pipeline, typically in a linear fashion.

type StageChange

type StageChange struct {
	// Stage UID of the stage the candidate entered
	ToStageID string `json:"toStageId,omitempty"`

	// The index of the stage in the pipeline at the time the stage change occurred
	ToStageIndex int `json:"toStageIndex,omitempty"`

	// Time at which stage change occurred
	UpdatedAt *int64 `json:"updatedAt,omitempty"`

	// User UID
	UserID string `json:"userId,omitempty"`
}

Stage change for an opportunity

type Tag

type Tag struct {
	// Tag text
	Text string `json:"text,omitempty"`

	// Number of candidates tagged
	Count int64 `json:"count,omitempty"`
}

Tags provide additional information or context to a candidate within your pipeline. Tags serve as a way of grouping candidates for easy viewing of individuals with specific attributes.

type User

type User struct {
	// User UID
	ID string `json:"id,omitempty"`

	// User's preferred name
	Name string `json:"name,omitempty"`

	// Username, extracted from user's email address
	Username string `json:"username,omitempty"`

	// User's email address
	Email string `json:"email,omitempty"`

	// Datetime when user was created
	CreatedAt *int64 `json:"createdAt,omitempty"`

	// Datetime when user was deactivated, null for an active user
	DeactivatedAt *int64 `json:"deactivatedAt,omitempty"`

	// User's access role. One of: 'super admin', 'admin', 'team member', 'limited team member',
	// 'interviewer'
	AccessRole string `json:"accessRole,omitempty"`

	// URL for user's gravatar, if enabled
	Photo string `json:"photo,omitempty"`

	// Unique id for user in external HR directory
	ExternalDirectoryID string `json:"externalDirectoryId,omitempty"`

	// An array of contact IDs which helps identify all contacts associated with a User. This can
	// be used to control User access to any Opportunities linked to a User.
	LinkedContactIds []string `json:"linkedContactIds,omitempty"`

	// User's job title
	JobTitle string `json:"jobTitle,omitempty"`

	// User's manager ID
	ManagerID string `json:"manager,omitempty"`
}

Users in Lever include anyone who has been invited to join in on recruiting efforts. There are five different access roles in Lever. From most to least access, these roles are Super admin, Admin, Team member, Limited team member, and Interviewer.