> ## Documentation Index
> Fetch the complete documentation index at: https://developers.dwolla.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Create customer beneficial owner

> Creates a new beneficial owner for a business verified customer. Beneficial owners are individuals who own 25% or more of the company's equity. Requires personal information, address, and SSN or passport for identity verification.



## OpenAPI

````yaml post /customers/{id}/beneficial-owners
openapi: 3.1.0
info:
  title: Dwolla API
  description: Dwolla API Documentation
  contact:
    name: Dwolla Developer Relations Team
    url: https://developers.dwolla.com
    email: api@dwolla.com
  version: '2.0'
  termsOfService: https://www.dwolla.com/legal/tos/
  license:
    name: MIT
    url: https://github.com/Dwolla/dwolla-openapi/blob/master/LICENSE
servers:
  - url: https://api.dwolla.com
    description: Production server
  - url: https://api-sandbox.dwolla.com
    description: Sandbox server
security:
  - clientCredentials: []
tags:
  - name: tokens
    description: Operations related to Application Access Tokens
  - name: root
    description: Root API operations
  - name: accounts
    description: Operations related to Accounts
  - name: customers
    description: Operations related to Customers
  - name: kba
    description: Operations related to Knowledge-Based Authentication
  - name: beneficial owners
    description: Operations related to Beneficial Owners
  - name: documents
    description: Operations related to Documents
  - name: exchanges
    description: Operations related to Exchanges
  - name: exchange sessions
    description: Operations related to Exchange Sessions
  - name: funding sources
    description: Operations related to Funding Sources
  - name: transfers
    description: Operations related to Transfers
  - name: labels
    description: Operations related to Labels
  - name: mass payments
    description: Operations related to Mass Payments
  - name: events
    description: Operations related to Events
  - name: webhook subscriptions
    description: Operations related to Webhook Subscriptions
  - name: webhooks
    description: Operations related to Webhooks
  - name: client tokens
    description: Operations related to Client Tokens
  - name: sandbox simulations
    description: Sandbox-only operations for simulating processing of bank transfers
paths:
  /customers/{id}/beneficial-owners:
    post:
      tags:
        - beneficial owners
      summary: Create customer beneficial owner
      description: >-
        Creates a new beneficial owner for a business verified customer.
        Beneficial owners are individuals who own 25% or more of the company's
        equity. Requires personal information, address, and SSN or passport for
        identity verification.
      operationId: createBeneficialOwnerForCustomer
      parameters:
        - name: id
          in: path
          description: Customer ID for which to create a Beneficial Owner
          required: true
          style: simple
          explode: false
          schema:
            type: string
        - $ref: '#/components/parameters/Accept'
      requestBody:
        required: true
        description: Parameters for creating a beneficial owner
        content:
          application/json:
            schema:
              oneOf:
                - $ref: '#/components/schemas/CreateUSBeneficialOwner'
                - $ref: '#/components/schemas/CreateInternationalBeneficialOwner'
      responses:
        '201':
          description: successful operation
          headers:
            Location:
              $ref: '#/components/headers/Location'
        '400':
          description: Bad Request
          headers: {}
          content:
            application/vnd.dwolla.v1.hal+json:
              schema:
                $ref: '#/components/schemas/BadRequestError'
        '403':
          description: Forbidden
          headers: {}
          content:
            application/vnd.dwolla.v1.hal+json:
              schema:
                $ref: '#/components/schemas/ForbiddenError'
        '404':
          description: Not Found
          headers: {}
          content:
            application/vnd.dwolla.v1.hal+json:
              schema:
                $ref: '#/components/schemas/NotFoundError'
      x-codeSamples:
        - lang: bash
          source: >
            POST
            https://api-sandbox.dwolla.com/customers/81696e5d-a593-45a6-8863-3c20ad634de5/beneficial-owners

            Content-Type: application/vnd.dwolla.v1.hal+json

            Accept: application/vnd.dwolla.v1.hal+json

            Authorization: Bearer
            pBA9fVDBEyYZCEsLf/wKehyh1RTpzjUj5KzIRfDi0wKTii7DqY


            {
              "firstName": "document",
              "lastName": "owner",
              "ssn": "123-46-7890",
              "dateOfBirth": "1960-11-30",
              "address": {
                "address1": "123 Main St.",
                "city": "New York",
                "stateProvinceRegion": "NY",
                "country": "US",
                "postalCode": "10005"
              }
            }
        - lang: javascript
          source: >
            // Using dwolla-v2 - https://github.com/Dwolla/dwolla-v2-node

            var customerUrl =
            'https://api-sandbox.dwolla.com/customers/07d59716-ef22-4fe6-98e8-f3190233dfb8';

            var requestBody = {
              firstName: 'John',
              lastName: 'Doe',
              dateOfBirth: '1970-01-01',
              ssn: '123-56-7890',
              address: {
                address1: '99-99 33rd St',
                city: 'Some City',
                stateProvinceRegion: 'NY',
                country: 'US',
                postalCode: '11101'
              }
            };


            dwolla
              .post(`${customerUrl}/beneficial-owners`, requestBody)
              .then(res => res.headers.get('location'));
        - lang: python
          source: >
            # Using dwollav2 - https://github.com/Dwolla/dwolla-v2-python

            customer_url =
            'https://api-sandbox.dwolla.com/customers/AB443D36-3757-44C1-A1B4-29727FB3111C'

            request_body = {
              'firstName': 'John',
              'lastName': 'Doe',
              'dateOfBirth': '1970-01-01',
              'ssn': '123-46-7890',
              'address': {
                'address1': '99-99 33rd St',
                'city': 'Some City',
                'stateProvinceRegion': 'NY',
                'country': 'US',
                'postalCode': '11101'
              }
            }


            beneficial_owner = app_token.post('%s/beneficial-owners' %
            customer_url, request_body)

            beneficial_owner.headers['location']
        - lang: php
          source: >
            <?php

            // Using dwollaswagger -
            https://github.com/Dwolla/dwolla-swagger-php

            $customersApi = new DwollaSwagger\CustomersApi($apiClient);

            $verified_customer =
            'https://api-sandbox.dwolla.com/customers/81696e5d-a593-45a6-8863-3c20ad634de5';


            $addOwner = $customersApi->addBeneficialOwner([
                  'firstName' => 'document',
                  'lastName'=> 'owner',
                  'dateOfBirth' => '1990-11-11',
                  'ssn' => '123-34-9876',
                  'address' =>
                  [
                      'address1' => '18749 18th st',
                      'address2' => 'apt 12',
                      'address3' => '',
                      'city' => 'Des Moines',
                      'stateProvinceRegion' => 'IA',
                      'postalCode' => '50265',
                      'country' => 'US'
                  ],
              ], $verified_customer);
            ?>
        - lang: ruby
          source: >
            # Using dwolla_v2 - https://github.com/Dwolla/dwolla-v2-ruby

            customer_url =
            'https://api-sandbox.dwolla.com/customers/81696e5d-a593-45a6-8863-3c20ad634de5'

            request_body = {
              :firstName => 'John',
              :lastName => 'Doe',
              :ssn => '123-46-7890',
              :dateOfBirth => '1970-01-01',
              :address => {
                :address1 => '99-99 33rd St',
                :city => 'Some City',
                :stateProvinceRegion => 'NY',
                :country => 'US',
                :postalCode => '11101'
              }
            }


            beneficial_owner = app_token.post
            "#{customer_url}/beneficial-owners", request_body

            beneficial_owner.response_headers[:location]
components:
  parameters:
    Accept:
      name: Accept
      in: header
      required: true
      description: >-
        The media type of the response. Must be
        application/vnd.dwolla.v1.hal+json
      schema:
        type: string
        enum:
          - application/vnd.dwolla.v1.hal+json
        default: application/vnd.dwolla.v1.hal+json
  schemas:
    CreateUSBeneficialOwner:
      title: CreateUSBeneficialOwner
      description: >-
        Create a US Beneficial Owner (identified by SSN). For US-based
        beneficial owners only. Use SSN for identity verification instead of
        passport.
      required:
        - firstName
        - lastName
        - dateOfBirth
        - address
        - ssn
      type: object
      properties:
        firstName:
          type: string
          example: John
        lastName:
          type: string
          example: Doe
        dateOfBirth:
          type: string
          example: '1980-01-31'
        address:
          $ref: '#/components/schemas/InternationalAddress'
        ssn:
          type: string
          example: '123456789'
    CreateInternationalBeneficialOwner:
      title: CreateInternationalBeneficialOwner
      description: >-
        Create an International Beneficial Owner (identified by Passport). For
        non-US beneficial owners who don't have a US SSN. Requires passport
        information for identity verification.
      required:
        - firstName
        - lastName
        - dateOfBirth
        - address
        - passport
      type: object
      properties:
        firstName:
          type: string
          example: Jane
        lastName:
          type: string
          example: Smith
        dateOfBirth:
          type: string
          example: '1985-03-15'
        address:
          $ref: '#/components/schemas/InternationalAddress'
        passport:
          $ref: '#/components/schemas/Passport'
    BadRequestError:
      title: BadRequestError
      description: Error response schema for 400 Bad Request
      type: object
      required:
        - code
        - message
      properties:
        code:
          type: string
          example: BadRequest
        message:
          type: string
          example: The request body contains bad syntax or is incomplete.
    ForbiddenError:
      title: ForbiddenError
      description: Error response schema for 403 Forbidden
      type: object
      required:
        - code
        - message
      properties:
        code:
          type: string
          example: Forbidden
        message:
          type: string
          example: The supplied credentials are not authorized for this resource.
    NotFoundError:
      title: NotFoundError
      description: Error response schema for 404 NotFound
      type: object
      required:
        - code
        - message
      properties:
        code:
          type: string
          example: NotFound
        message:
          type: string
          example: The requested resource was not found.
    InternationalAddress:
      title: InternationalAddress
      type: object
      required:
        - address1
        - city
        - country
        - stateProvinceRegion
      properties:
        address1:
          type: string
          example: 462 Main Street
        address2:
          type: string
          example: Suite 123
        address3:
          type: string
          example: Unit 123
        city:
          type: string
          example: Des Moines
        postalCode:
          type: string
          example: '50309'
        country:
          type: string
          example: USA
        stateProvinceRegion:
          type: string
          example: IA
    Passport:
      title: Passport
      type: object
      required:
        - number
        - country
      properties:
        number:
          type: string
        country:
          type: string
  headers:
    Location:
      description: The location of the created resource
      schema:
        type: string
  securitySchemes:
    clientCredentials:
      type: oauth2
      flows:
        clientCredentials:
          tokenUrl: /token
          x-speakeasy-token-endpoint-authentication: client_secret_basic
          scopes: {}

````