Deputy MCP
for AI agents

• list_employees read

  List employees

  Search employees. Common filters: `Active` (true for current staff, false for archived), `Company` (primary location id), `StartDate`, `Modified` (for incremental sync). Join ['CompanyObject','ContactObject'] to get the location name and contact details inline instead of bare ids. Pay lives on EmployeeAgreement, not here.

• get_employee read

  Get employee

  Fetch one employee by Id, including their address/contact record ids, position, role and start date.

• update_employee write

  Update employee

  Update an employee's details — name, contact, address, role, position, primary location. Only the fields you pass are changed. This connector cannot END someone's employment: Active, TerminationDate and the EmploymentEnd fields are deliberately not writable, and there is no terminate or delete tool. Offboarding is done by a person in Deputy.

• create_employee write

  Create employee

  Add a new employee and assign them to their primary location. FirstName, LastName, DisplayName, Company (their location id) and StressProfile are required. Two calls in one: Deputy's employee create does NOT create the workplace assignment, and without one Deputy refuses to manage the person at all — every later deputy_update_employee returns 403 (verified live 2026-08-06) — so this tool makes both. It does NOT give them a pay rate: create an EmployeeAgreement afterwards to set their employment terms and payroll id. It does NOT invite them either; deputy_invite_employee is the separate step, and it is what provisions their login.

• list_addresses read

  List addresses

  Search address records. Addresses are standalone rows that employees and locations point at by Id, so this is mostly used to resolve an address id you already hold.

• get_address read

  Get address

  Fetch one address by Id.

• create_address write

  Create address

  Create an address record. Returns an Id you then set on an employee (MainAddress / PostalAddress / EmergencyAddress) or a location.

• update_address write

  Update address

  Update an address. Only the fields you pass are changed. Note the same address row may be referenced by more than one record.

• delete_address write

  Delete address

  Delete an address record. Works only while NOTHING references it — an address set as an employee's MainAddress/PostalAddress/EmergencyAddress or as a location's address returns 401 'Not authorized to delete', which sounds like a permission problem and is not (verified live 2026-08-06: the same address deleted cleanly once nothing pointed at it). Re-point or clear the reference first, or just overwrite the row with deputy_update_address.

• list_contacts read

  List contact records

  Search contact records — the phone/email rows that employees and locations point at by Id.

• get_contact read

  Get contact record

  Fetch one contact record by Id.

• create_contact write

  Create contact record

  Create a contact record holding phone numbers and email addresses. Returns an Id you then set on an employee's Contact field.

• update_contact write

  Update contact record

  Update a contact record's phone numbers or email addresses.

• delete_contact write

  Delete contact record

  Delete a contact record. Anything still pointing at it is left with a dangling reference.

• list_employee_workplaces read

  List employee workplaces

  List which LOCATIONS each employee is allowed to work at. An employee has one primary location (Employee.Company) but can be assigned to several through these rows — filter by `EmployeeId` or `Company`.

• get_employee_workplace read

  Get employee workplace

  Fetch one employee-workplace assignment by Id.

• create_employee_workplace write

  Create employee workplace

  Allow an employee to work at an additional location. Prefer deputy_add_employee_location for an ADDITIONAL location — it takes the employee and location directly and is the endpoint Deputy documents for this. Use THIS tool when the employee has no workplace at all: add_employee_location cannot grant the first one (it has to resolve the employee to authorise the call, and Deputy resolves employees through their workplaces), so it answers 401 'not authorized to access the requested employee'. deputy_create_employee already does this for you.

• update_employee_workplace write

  Update employee workplace

  Change an employee-workplace assignment.

• delete_employee_workplace write

  Delete employee workplace

  Remove an employee's access to a location. They keep their primary location; only this assignment goes.

• list_employee_roles read

  List employee roles

  List the permission levels (roles) defined in this Deputy account — Employee, Supervisor, Location Manager, System Administrator and any custom levels. Read-only reference data; the Id is what goes on Employee.Role.

• get_employee_role read

  Get employee role

  Fetch one employee role by Id, including its ranking and whether it enforces two-factor auth.

• list_employee_agreements read

  List employee agreements

  Search employee agreements — THE JOIN between an employee and their award/pay rate, and where the PAYROLL ID lives. This is how you answer 'what does this person earn' or 'what is their payroll id'. Filter by `EmployeeId` and `Active` true for the current agreement. Join ['ContractObject','PayPeriodObject'] to resolve the award and pay cycle inline.

• get_employee_agreement read

  Get employee agreement

  Fetch one employee agreement by Id, including employment type, base rate or salary, payroll id and the award it applies.

• create_employee_agreement write

  Create employee agreement

  Give an employee their employment terms. EmployeeId is required; set Contract to the award/pay rate, plus BaseRate or AnnualSalary and the PayrollId your payroll system uses. A new employee has no pay until an agreement exists.

• update_employee_agreement write

  Update employee agreement

  Change an employee's employment terms — their rate, salary, award or payroll id. Changing a rate affects how future timesheets are costed, not already-approved ones.

• delete_employee_agreement write

  Delete employee agreement

  Delete an employment agreement. Works only while NOTHING references it — an agreement still named on an EmployeeWorkplace row (Agreement1/2/3) returns 401 'Not authorized to delete', which sounds like a permission problem and is not (verified live 2026-08-06: the same agreement deleted cleanly once its workplace was removed). Prefer setting Active false to retire one anyway: deleting removes the employee's pay terms and the payroll id linking them to your payroll system.

• list_employment_contracts read

  List employment contracts (awards / pay rates)

  List the AWARDS / PAY RATES / EMPLOYMENT TERMS defined in this account — Deputy's UI uses all three names for this one object. A reference table of pay and leave rules that employee agreements point at, not a per-person record. Cache it. Awards cannot be CREATED through the API — Deputy accepts the call and writes nothing — so they must be set up in the Deputy UI first.

• get_employment_contract read

  Get employment contract (award / pay rate)

  Fetch one award by Id, including its base pay rule, employment conditions and leave rules.

• update_employment_contract write

  Update employment contract (award / pay rate)

  Change an award's configuration. Affects every employee whose agreement points at it, so the blast radius is everyone on that award.

• delete_employment_contract write

  Delete employment contract (award / pay rate)

  Delete an award. Refuse to do this while employee agreements still reference it — they would be left pointing at a missing row.

• list_pay_rules read

  List pay rules

  List the pay rules — the individual rate lines (ordinary hours, overtime, weekend and public-holiday penalties) that awards compose and that timesheets are costed against. A TimesheetPayReturn points at one of these. Reference data; cache it.

• get_pay_rule read

  Get pay rule

  Fetch one pay rule by Id, including its rate or multiplier and its payroll category.

• create_pay_rule write

  Create pay rule

  Define a new pay rate line. PayTitle is required; give either an HourlyRate or set IsMultiplier with a MultiplierValue and MultiplierBaseRate. Account-wide configuration.

• update_pay_rule write

  Update pay rule

  Change a pay rule's rate, multiplier or payroll category. This changes what future work costs for every award that uses it.

• delete_pay_rule write

  Delete pay rule

  Delete a pay rule. Awards and historic timesheet pay lines reference these by Id — check before removing one.

• list_employment_conditions read

  List employment conditions

  List employment conditions — the usual working hours, probationary period, minimum hours per day and leave thresholds that an award attaches to. Read-only reference data.

• get_employment_condition read

  Get employment condition

  Fetch one employment condition by Id.

• list_pay_periods read

  List pay periods

  List the PAY CYCLES configured in this account (weekly, fortnightly, monthly) — the cadence an employee agreement is paid on. Reference data.

• get_pay_period read

  Get pay period

  Fetch one pay period by Id, including its cycle and start date.

• list_company_pay_periods read

  List company pay periods

  List the CONCRETE dated pay periods per location — the actual start/end windows a pay cycle has produced. Use these to find the exact window a payroll export should cover. Filter by `Company` (the location) and a `DateStart` range.

• get_company_pay_period read

  Get company pay period

  Fetch one dated company pay period by Id.

• list_employee_pay_cycles read

  List employee pay cycles

  Search per-employee pay-cycle summaries — for one employee in one period: their timesheets, how many are time-approved vs pay-approved, whether the cycle was exported, and the time and cost totals. The best single place to answer 'is this employee ready for payroll'. Filter by `EmployeeId` and `PeriodId`.

• get_employee_pay_cycle read

  Get employee pay cycle

  Fetch one employee pay cycle by Id, including its approval counts, export state and totals.

• list_stress_profiles read

  List stress profiles

  List stress profiles — the fatigue rules capping how long and how often an employee can be rostered (max hours per shift/day/period, minimum rest between shifts). Deputy warns managers who roster past them.

• get_stress_profile read

  Get stress profile

  Fetch one stress profile by Id.

• create_stress_profile write

  Create stress profile

  Define a fatigue-rule profile. Name is required. Assign it to employees or to an award to have Deputy warn when a roster breaches it.

• update_stress_profile write

  Update stress profile

  Change a stress profile's limits. Affects every employee and award pointing at it.

• delete_stress_profile write

  Delete stress profile

  Delete a stress profile. Employees and awards referencing it lose their fatigue caps.

• list_leave_requests read

  List leave requests

  Search leave requests and bookings. Filter by `Employee`, `Status`, `LeaveRule` (the leave type), and a `Start` window (UNIX EPOCH SECONDS, use ge/le). Join ['EmployeeObject','LeaveRuleObject'] to resolve the person and the leave type inline. Approved leave also shows up as timesheets with IsLeave=true.

• get_leave_request read

  Get leave request

  Fetch one leave request by Id, including its dates, day/hour totals, status and approval comment.

• create_leave_request write

  Create leave request

  Lodge a leave request for an employee, for management approval. Employee is required; set LeaveRule to the leave type and give the dates via DateStart/DateEnd. Deputy applies the account's own approval workflow — creating a request does not approve it.

• update_leave_request write

  Update leave request

  Update a leave request — change its dates, or set Status to approve, reject or withdraw it. This is also how a request is CANCELLED: there is no delete tool, because Deputy refuses the delete and a status change is the right action anyway (an approved request may already have generated timesheets and balance movements that a delete would strand). Approving leave generates timesheets, so this is not a cosmetic field write.

• list_leave_rules read

  List leave rules

  List the LEAVE TYPES this account offers — annual, personal/sick, long service and any custom types — with how each accrues, whether it is paid, and whether it rolls over. Reference data: the Id is what a leave request points at. Cache it rather than re-reading per request.

• get_leave_rule read

  Get leave rule

  Fetch one leave rule by Id, including its accrual configuration and payroll category.

• create_leave_rule write

  Create leave rule

  Define a new leave type. Name is required. This changes what every employee in the account can request, so it is an administrative action, not a per-employee one.

• update_leave_rule write

  Update leave rule

  Change a leave type's configuration — its cap, rollover, visibility or payroll category. Affects every employee the rule applies to.

• delete_leave_rule write

  Delete leave rule

  Delete a leave type. Do this only if nothing references it — existing leave requests point at this row by Id.

• list_leave_accruals read

  List leave accruals

  Search leave balance movements — the ledger behind an employee's leave balance. Filter by `Employee` and `LeaveRule` to reconstruct a balance, or by `TransactionDate` for a period. Join ['EmployeeObject','LeaveRuleObject'] to resolve names.

• get_leave_accrual read

  Get leave accrual

  Fetch one leave accrual entry by Id.

• create_leave_accrual write

  Create leave accrual

  Post a manual adjustment to an employee's leave balance. Employee is required; give Hours or Days plus a Comment explaining why. This directly changes what the employee can take, so it is an administrative correction rather than a routine write — Deputy accrues automatically from the employee's agreement.

• update_leave_accrual write

  Update leave accrual

  Change a leave accrual entry. Prefer posting a correcting entry over editing history.

• delete_leave_accrual write

  Delete leave accrual

  Delete a leave accrual entry. This silently changes an employee's leave balance with no audit trail — post a correcting adjustment instead.

• list_public_holidays read

  List public holidays

  List the public holidays configured in this account. Deputy uses these when applying penalty pay rules, so what is listed here changes what shifts cost.

• get_public_holiday read

  Get public holiday

  Fetch one public holiday by Id.

• create_public_holiday write

  Create public holiday

  Add a public holiday. Adding one changes how shifts on that date are costed. ⚠️ `Schedule` is NOT optional despite the schema — Deputy's column is NOT NULL and a create without it fails with "Column 'schedule' cannot be null" (verified live 2026-08-06). The Schedule row carries the actual date and recurrence, and this connector exposes no way to list or create one, so in practice a public holiday must be added in the Deputy UI unless you already hold a Schedule id.

• update_public_holiday write

  Update public holiday

  Change a public holiday's name or date.

• delete_public_holiday write

  Delete public holiday

  Remove a public holiday. Shifts on that date revert to ordinary pay rules.

• list_shifts read

  List shifts

  Search scheduled shifts (Deputy's API calls a shift a Roster). Filter with `StartTime` (UNIX EPOCH SECONDS, use ge/le for a date window), `Employee`, `OperationalUnit` (area), `Published`, and `Open` (true for unassigned shifts employees can claim). Join ['EmployeeObject','OperationalUnitObject'] to resolve names inline. `MatchedByTimesheet` is set once someone clocks on against the shift, which is how you tell a scheduled shift from a worked one.

• get_shift read

  Get shift

  Fetch one shift by Id, including its break slots, cost, publish state and the timesheet it was matched to.

• create_shift write

  Create shift

  Schedule a shift. StartTime and EndTime (UNIX EPOCH SECONDS) and OperationalUnit (the area) are required. Set Employee to assign it, or Open=true to leave it unassigned for staff to claim. Published=false keeps it a manager-only draft — the safe default when building a roster you are not ready to release.

• update_shift write

  Update shift

  Change a shift's time, area, assignee or publish state. Moving a shift that already has a matched timesheet does not move the worked time.

• delete_shift write

  Delete shift

  Delete a scheduled shift. IRREVERSIBLE. If the shift has already been published, the assigned employee loses it from their roster without an explicit notification.

• list_open_shift_offers read

  List open shift offers

  List offers of OPEN shifts to employees, and what each employee did with them — `Accepted`, `Declined`, `Seen`. Filter by `Roster` (the shift) or `Employee`. Read-only here; use the V2 shift-offer tools to create or resolve an offer.

• get_open_shift_offer read

  Get open shift offer

  Fetch one open-shift offer by Id.

• list_shift_swaps read

  List shift swaps

  List shift swap requests between employees, with their `Status` and the source and target shifts. Filter by `Employee` or `Status`. Read-only here; approving a swap is a V2 workflow.

• get_shift_swap read

  Get shift swap

  Fetch one shift swap request by Id, including both shifts and the request/response messages.

• list_availabilities read

  List availability entries

  Search employee availability and unavailability — when someone cannot be rostered. Filter by `Employee` and a `StartTime` window. Recurring entries carry a Schedule id; one-off entries do not. Entries cannot be CREATED through the API — Deputy accepts the call and writes nothing — so staff enter their own unavailability in Deputy, and this connector can read, amend and clear it but not add it.

• get_availability read

  Get availability entry

  Fetch one availability entry by Id.

• update_availability write

  Update availability entry

  Change an availability entry's window or comment.

• delete_availability write

  Delete availability entry

  Delete an availability entry, making the employee rosterable in that window again.

• list_events read

  List events

  List schedule events — things happening in the business that managers should see against the roster, such as a public sale, stocktake or blackout period.

• get_event read

  Get event

  Fetch one event by Id.

• create_event write

  Create event

  Create a schedule event. Set BlockTimeOff true to automatically refuse leave requests over the period — the most common reason to add one. ⚠️ `Schedule` is NOT optional despite the schema — Deputy's column is NOT NULL and a create without it fails with "Column 'schedule' cannot be null" (verified live 2026-08-06). The Schedule row carries the event's dates and recurrence, and this connector exposes no way to list or create one, so in practice an event must be added in the Deputy UI unless you already hold a Schedule id.

• update_event write

  Update event

  Change an event's title, colour, or whether it blocks time off.

• delete_event write

  Delete event

  Delete an event. If it was blocking time off, that restriction lifts immediately.

• list_timesheets read

  List timesheets

  Search timesheets — worked time, not scheduled shifts. Filter with `StartTime` (UNIX EPOCH SECONDS, use ge/le for a date window), `Employee`, `OperationalUnit`, and the state flags: `TimeApproved` true once a manager approves the hours, `PayRuleApproved` true once approved for payroll, `IsInProgress` true while the employee is clocked on right now, `IsLeave` true for leave-generated rows. For payroll export, filter PayRuleApproved = true. Join ['EmployeeObject','OperationalUnitObject'] to resolve names inline. Costs live on TimesheetPayReturn, not here. Note a live clock-on DOES appear here with IsInProgress true — but if a clock-off is rejected for being under Deputy's 15-minute minimum, Deputy deletes that row outright, so an in-progress timesheet vanishing is a failed clock-off rather than a read problem.

• get_timesheet read

  Get timesheet

  Fetch one timesheet by Id, including its break slots, total time, approval flags and the roster it was matched to.

• create_timesheet write

  Create timesheet

  Create a timesheet directly. Employee and StartTime (UNIX EPOCH SECONDS) are required. NOTE the normal way time gets into Deputy is the time clock — prefer deputy_clock_on / deputy_clock_off, which run Deputy's own shift logic. Use this for importing historical time from another system.

• update_timesheet write

  Update timesheet

  Update a timesheet's times, area, or comments. To APPROVE a timesheet use the approval tools (deputy_approve_timesheets) rather than flipping fields here — approval runs pay recalculation that a direct field write skips.

• delete_timesheet write

  Delete timesheet

  Delete a timesheet. Works only while the timesheet is UNAPPROVED — once it has been pay-approved Deputy refuses with 401 'Not authorized to delete' (verified live 2026-08-06). IRREVERSIBLE where it does work, and it removes recorded worked time, so the hours disappear from reports and from any payroll export that has not already run. Prefer deputy_discard_timesheet, which keeps the record for audit.

• list_timesheet_pay_returns read

  List timesheet pay returns

  Search timesheet pay lines — the MONEY side of a timesheet: which pay rule applied, the hours it covered, the dollar cost, and whether a manager overrode it. One timesheet can produce several of these (ordinary hours, overtime, penalties). THE EFFICIENT PATTERN: call this with join ['TimesheetObject'] to get time and money in one request instead of listing timesheets and then fetching costs per row.

• get_timesheet_pay_return read

  Get timesheet pay return

  Fetch one timesheet pay line by Id.

• create_timesheet_pay_return write

  Create timesheet pay return

  Add a pay line to a timesheet. Rarely correct by hand — Deputy generates these from its own pay rules when a timesheet is approved. Use it only when importing already-costed time from another system.

• update_timesheet_pay_return write

  Update timesheet pay return

  Override a calculated pay line's value or cost. Set Overridden true and give an OverrideComment so the change is auditable.

• delete_timesheet_pay_return write

  Delete timesheet pay return

  Delete a pay line. Works only while its timesheet is UNAPPROVED — a pay line on an approved timesheet returns 401 'Not authorized to delete', which sounds like a permission problem and is not. Unapprove the timesheet first. Deleting changes what the timesheet costs and what will be exported to payroll.

• list_locations read

  List locations

  List the LOCATIONS in this Deputy account. Deputy's API calls a location a `Company` — it is a site (a store, a warehouse, a truck, even a website), NOT an employer. Filter `Active` true for live sites and `IsWorkplace` true for real workplaces. Join ['AddressObject','ContactObject'] to resolve the address and contact inline. Start here when you need a location Id for anything else.

• get_location read

  Get location

  Fetch one location by Id, including its trading name, business number, payroll export code and address.

• list_areas read

  List areas

  List the AREAS (Deputy's API calls an area an `OperationalUnit`; the UI also says Department). Areas sit inside a location and are what SHIFTS ARE SCHEDULED AGAINST — you need an area Id to create a shift, not a location Id. Filter by `Company` (the location) and `Active`. Join ['CompanyObject'] to resolve the location name.

• get_area read

  Get area

  Fetch one area by Id, including its location, roster colour and daily labour budget.

• create_area write

  Create area

  Create an area inside a location. Company (the location Id) and OperationalUnitName are required. Shifts and timesheets are recorded against areas, so a location needs at least one before it can be rostered.

• update_area write

  Update area

  Change an area's name, colour, budget or whether it shows on the roster.

• delete_area write

  Delete area

  Delete an area. IRREVERSIBLE, and shifts and timesheets recorded against it reference it by Id. Set Active false to archive it instead.

• list_countries read

  List countries

  List Deputy's country reference table. You need the numeric Id here when writing an Address, which takes a country Id rather than a name or ISO code. Static reference data — cache it.

• get_country read

  Get country

  Fetch one country by Id, including its ISO codes and postcode/phone validation patterns.

• list_states read

  List states

  List Deputy's state/region reference table. Filter by `Country` to get the states of one country. Static reference data — cache it.

• get_state read

  Get state

  Fetch one state by Id.

• list_tasks read

  List tasks

  Search tasks — Deputy's shift checklists. Filter by `OpUnitId` (the area), `Date`, and `TsCompleted` to separate done from outstanding. Useful for 'what wasn't completed at this site yesterday'.

• get_task read

  Get task

  Fetch one task by Id, including its question, answer and completion timestamp.

• create_task write

  Create task

  Create a task on a shift checklist. FOUR fields are required in practice despite the schema marking them optional: `TaskSetupId`, `GroupId`, `UserEntry` (the acting user — take `UserId` from deputy_whoami) and `SortOrder` (defaulted to 0 for you). ⚠️ OMITTING `GroupId` DOES NOT ERROR — Deputy answers 200 with an EMPTY BODY and writes no row at all (verified live 2026-08-06; a create that returns `{}` has silently done nothing, so re-read with deputy_list_tasks if you are unsure). Deputy exposes no endpoint that lists or creates a TaskSetup or a TaskGroup, so get both ids by reading an existing task with deputy_list_tasks and reusing its `TaskSetupId` and `GroupId` — every task carries them, including ad-hoc tasks added in the Deputy UI. If the account has no tasks at all, one has to be added in Deputy first. To COMPLETE a task rather than create one, use deputy_update_task and set Answer.

• update_task write

  Update task

  Update a task — most usefully setting Answer to complete it, or moving its due date.

• delete_task write

  Delete task

  Delete a task. It disappears from the checklist for that day.

• list_training_modules read

  List training modules

  List the training courses this business runs, with their provider, cost and renewal period. The renewal period is what makes a completion expire.

• get_training_module read

  Get training module

  Fetch one training module by Id.

• create_training_module write

  Create training module

  Define a training course. Title is required. Set RenewalPeriodMonths so completions of it expire and show up as due for renewal.

• update_training_module write

  Update training module

  Change a training course's details or renewal period.

• delete_training_module write

  Delete training module

  Delete a training course. Existing training records reference it by Id.

• list_training_records read

  List training records

  Search which employees have completed which training, and when it expires. THE HIGH-VALUE QUERY: filter `ExpiryDate` with le and a date to find lapsed or soon-to-lapse certifications. Join ['EmployeeObject','ModuleObject'] to resolve names inline.

• get_training_record read

  Get training record

  Fetch one training record by Id.

• create_training_record write

  Create training record

  Record that an employee completed a training course. Employee and Module are required; set TrainingDate and ExpiryDate so the qualification lapses on schedule.

• update_training_record write

  Update training record

  Update a training record — most often extending an ExpiryDate after a refresher.

• delete_training_record write

  Delete training record

  Delete a training record. The employee no longer shows as having completed that course.

• list_sales_metrics read

  List sales metrics

  Search sales / metric data pushed into Deputy. Filter by `OperationalUnit` (area), `SalesType` (the metric series) and a `Timestamp` window. Deputy uses this to drive demand-based scheduling, so it is how you check what a POS integration has actually delivered.

• get_sales_metric read

  Get sales metric

  Fetch one sales metric row by Id.

• create_sales_metric write

  Create sales metric

  Push a sales or metric data point into Deputy — the main inbound integration point for a point-of-sale system. Give OperationalUnit (the area), a SalesType series name, and SalesAmount and/or SalesQty. Set SalesRef to your own transaction id so a retry does not double-count.

• update_sales_metric write

  Update sales metric

  Correct a sales metric row.

• delete_sales_metric write

  Delete sales metric

  Delete a sales metric row. Demand forecasts and labour budgets built on it change accordingly.

• list_memos read

  List memos

  List company memos — the notices Deputy shows staff in the app, with their display window and whether staff must confirm having read them. Read-only here; posting a memo is a Supervise verb (deputy_post_memo).

• get_memo read

  Get memo

  Fetch one memo by Id, including its content, display window and confirmation setting.

• list_journal_entries read

  List journal entries

  Search journal entries — private performance and incident notes managers keep against an employee. Filter by `EmployeeId` and a `Date` window. Treat the contents as confidential HR material.

• get_journal_entry read

  Get journal entry

  Fetch one journal entry by Id.

• create_journal_entry write

  Create journal entry

  Add a performance or incident note against an employee. EmployeeId and Comment are required. This is an HR record about a person — write it as something the employee could reasonably read.

• update_journal_entry write

  Update journal entry

  Edit a journal entry's text or date.

• delete_journal_entry write

  Delete journal entry

  Delete a journal entry. IRREVERSIBLE, and journal entries are often the written record behind a performance process.

• whoami read

  Who am I

  Return the Deputy user this connection authenticates as, and the install it belongs to. Call this FIRST when something returns nothing or 403: Deputy has a single OAuth scope and no least-privilege model, so what this connection can see and do is exactly what this user can see and do in Deputy. An empty employee list usually means a permissions ceiling, not an empty account.

• describe_resource read

  Describe a resource

  Return the LIVE field list, types and associations for one Deputy object on THIS install — Deputy's `/INFO` endpoint. Use it before building a filter you are unsure of, or when a search returns nothing: an unrecognised field name is a common cause, and Enterprise installs carry custom fields that appear in no published schema. Also the way to discover which `...Object` associations you can pass to a list tool's `join`.

• list_custom_fields read

  List custom fields

  List the custom fields DEFINED in this account — their names, which object each is attached to (`System`), and which CustomFieldData slot (F01..F128) holds the value. Read this first: the values themselves are stored in numbered slots that mean nothing without this mapping. Field definitions are read-only through this connector and are managed in the Deputy UI; use deputy_create_custom_field_data to write values against one that already exists.

• get_custom_field read

  Get custom field

  Fetch one custom field definition by Id.

• list_custom_field_data_rows read

  List custom field data rows

  Search custom field VALUES. Values live in numbered slots (F01..F128) whose meaning is per-account, so call deputy_list_custom_fields first to learn which slot is which field. Employees, timesheets and shifts point at one of these rows by Id.

• get_custom_field_data read

  Get custom field data row

  Fetch one custom field data row by Id.

• create_custom_field_data write

  Create custom field data row

  Create a row of custom field values, then set its Id on the employee, timesheet or shift it belongs to. Only slots F01-F20 are exposed here; Deputy supports up to F128, which the vast majority of accounts do not use.

• update_custom_field_data write

  Update custom field data row

  Update custom field values in slots F01-F20 on an existing row.

• delete_custom_field_data write

  Delete custom field data row

  Delete a custom field data row. Whatever pointed at it loses its custom values.

• clock_on write

  Clock on

  Start an employee's timesheet — the equivalent of them clocking on. Creates a live timesheet against the given AREA and runs Deputy's own shift-matching, so prefer this over creating a Timesheet record directly. The resulting timesheet has IsInProgress true until it is clocked off.

• clock_off write

  Clock off

  Stop an in-progress timesheet — the equivalent of the employee clocking off. Takes the timesheet Id and the total meal-break minutes taken during the shift. This closes the shift and lets Deputy cost it; the timesheet then moves into the approval workflow. ⚠️ DESTRUCTIVE ON FAILURE: if the timesheet is shorter than Deputy's 15-minute minimum, the call fails with 'The length of the timesheet is less than the minimum of 15 minutes' AND DELETES the in-progress timesheet — the row is gone from the Resource API entirely, not left running. Verified live 2026-08-06. Do not use this to 'try' closing a shift someone just started.

• pause_timesheet write

  Start or end a break

  Start or end a break on an in-progress timesheet. This is a TOGGLE against the one timesheet: the first call opens a break slot, the second closes it. Deputy records the REAL elapsed time between the two calls — `mealbreak_minutes` is accepted but inert, so you cannot book a 30-minute break with a single call. Verified live 2026-08-06 (which is also what resolves the old doubt about Deputy documenting the same body as clock-off: the body is right, that one field just does nothing here).

• get_timesheet_detail read

  Get timesheet detail

  Fetch one timesheet through the Supervise surface, which returns a richer view than the plain Resource read — including the pay breakdown Deputy computed for it.

• get_employee_shift_info read

  Get employee shift info

  Return what an employee is currently doing — whether they are on shift, and what is next. The quickest answer to 'is this person working right now'.

• add_employee write

  Add employee

  Add an employee through Deputy's own onboarding endpoint. Prefer this over deputy_create_employee: it takes the payroll id directly and runs Deputy's own setup — creating the employee, their default EmployeeAgreement and their workplace assignment in one call — rather than only writing a person record. ⚠️ `weekday_rate` is a SILENT NO-OP: Deputy accepts it and leaves the new agreement on BaseRate null / EmployeeHourlyRate 0 (verified live 2026-08-06 with both an integer and a decimal). To actually set pay, follow up with deputy_update_employee_agreement and set BaseRate on the agreement this call returns. `payroll_id` does land. Note the Hungarian field names — this surface does not share the Resource API's conventions.

• invite_employee write

  Invite employee to Deputy

  Send an employee their invitation to Deputy, so they can log in, see their roster and clock on. Creating an employee does NOT invite them — this is the separate step.

• add_employee_location write

  Add a location to an employee

  Allow an employee to work at an additional LOCATION. They keep their primary location; this grants another.

• remove_employee_location write

  Remove a location from an employee

  Revoke an employee's access to a LOCATION. They can no longer be rostered there. Their primary location is unaffected.

• get_server_time read

  Get Deputy server time

  Return Deputy's current server time. Useful before writing any UNIX-epoch timestamp, and worth remembering that each LOCATION carries its own timezone — pass a location id to get that site's local time rather than the account's.

• post_journal write

  Post a journal note

  Add a performance or incident note against an employee through the Supervise surface. Treat the contents as confidential HR material.

• post_memo write

  Post a memo

  Post a company memo — a notice shown to staff in the Deputy app. Set require_confirm to make staff acknowledge having read it. This is broadcast to everyone at the location, so check the audience before sending.

• list_shifts_v2 read

  List shifts (detailed)

  List ONE EMPLOYEE'S shifts with Deputy's full V2 detail — break slots and their states, publish and confirmation status, swap status, bid counts and child shifts. employee_id is REQUIRED: without it Deputy returns 403, not an empty list (verified live 2026-08-06). Filters use ISO-8601 datetimes (e.g. 2026-08-11T13:45:00+11:00), NOT epoch seconds, and paging is by cursor. To list shifts across employees or for a whole area, use deputy_list_shifts instead.

• get_shift_v2 read

  Get shift (detailed)

  Fetch one shift with full V2 detail — breaks, states, costs and workflow status.

• get_shift_history read

  Get shift history

  Return the change history for one shift — who changed what and when. Use it to answer 'why does this shift look different from what was published'.

• get_late_employees read

  Get late employees

  Return employees who were late for a shift during a date range — it compares scheduled shifts against clock-on records so you do not have to. BOTH dates are required and must be plain Y-m-d (2026-08-06), NOT a timestamp: Deputy answers 'startDate is required' with neither and 'Error occurred during parsing' if you hand it an ISO-8601 datetime. Deputy processes at most 1000 shifts per request, so narrow the range or the locations on a large account.

• preview_shift_publish read

  Preview a shift publish

  Show which shifts WOULD be published for a location and date range, without publishing anything. Run this before deputy_publish_shifts: publishing notifies staff, and there is no undo that un-notifies them.

• publish_shifts write

  Publish shifts

  Publish shifts to employees. ASYNCHRONOUS — the operation id comes back on `metadata.operation`, and deputy_get_publish_status polls it. Publishing NOTIFIES STAFF and cannot be un-notified, so run deputy_preview_shift_publish first. `start` and `end` are ALWAYS required, even when you name explicit shift_ids, and must be plain Y-m-d — an ISO-8601 datetime is rejected. Deputy also returns `success:false` with a validation list (e.g. staff with no email) rather than publishing; re-send with force=true to publish through those soft warnings.

• get_publish_status read

  Get shift publish status

  Check how an asynchronous shift publish went, using the operation id deputy_publish_shifts returns on `metadata.operation.operationId`. Note the publish itself completes fast enough that the shifts are usually already published by the time you poll — check `Published` on the shift if this comes back empty.

• list_pending_shift_swaps read

  List shift swaps awaiting approval

  List shift swap requests waiting on a manager's decision, for the given locations.

• confirm_shift_swap write

  Approve a shift swap

  Approve one or more shift swaps, moving the shifts between the employees involved. BOTH sides are required — a swap is an exchange, and Deputy rejects a one-sided call with 'Target shift Ids must not be empty for this action.' Set trial true to validate the swap without committing it — worth doing first, since approving reassigns real shifts, and the trial returns the swap's cost.

• decline_shift_swap write

  Decline a shift swap

  Decline one or more shift swap requests, optionally with a message back to the employees. BOTH sides are required, as with the approve verb. Deputy answers 'Target Shift does not exist or swap status has been changed.' when the pair does not name a live swap request.

• list_pending_open_shifts read

  List open shifts awaiting approval

  List open-shift claims waiting on a manager's decision — staff who have put their hand up for an unassigned shift.

• notify_shift_offer write

  Offer shifts to employees

  Offer one or more shifts to specific employees — Deputy notifies them and they can accept. This is how you fill an open shift or find a replacement for someone who called in sick.

• cancel_shift_offer write

  Cancel a shift offer

  Withdraw a shift offer so employees can no longer accept it.

• approve_timesheet write

  Approve a timesheet (time and pay)

  Approve one timesheet for BOTH time and pay — the full approval that makes it ready for payroll. This runs Deputy's pay calculation; setting TimeApproved/PayRuleApproved directly on the record skips it and leaves the costs wrong. Approving is what moves a timesheet into a payroll export.

• approve_timesheet_time write

  Approve a timesheet (time only)

  Approve only the HOURS on a timesheet, leaving pay approval for later. Use this for the common two-stage workflow where a supervisor confirms the time and payroll signs off the cost separately.

• discard_timesheet write

  Discard a timesheet

  Discard a timesheet — Deputy's soft rejection. The record survives for audit but stops counting towards hours, cost or payroll. Prefer this over deputy_delete_timesheet, which destroys the record.

• end_shift write

  End an in-progress shift

  End a timesheet that is still running, through the approval surface. Use this to close out someone who forgot to clock off; deputy_clock_off is the normal path when you have the break minutes to record. Unlike clock-off this does NOT destroy a too-short timesheet, but Deputy still refuses one whose end time is more than 15 minutes in the future.

• get_timesheet_permissions read

  Get timesheet permissions

  Return what the authorising user is allowed to do with timesheets — their role and approval permissions. Worth checking before an approval automation: Deputy has one OAuth scope, so what this connection can approve is exactly what this user can approve.

• list_leave_requests_v2 read

  List leave requests (V2)

  List leave requests through the V2 surface, which returns the richer approval-workflow view. Use deputy_list_leave_requests for bulk export and filtering; use this one when you care about approval state.

• get_upcoming_leave read

  Get an employee's upcoming leave

  List an employee's leave over a date window. The direct answer to 'is this person away soon' before rostering them. Both the employee and a start/end window are required — Deputy has no 'just the upcoming ones' mode despite the endpoint's name, and rejects the call with `data is required.` if the window is missing.

No tools match your search.